aboutsummaryrefslogtreecommitdiff
path: root/vendors/simpletest/test
diff options
context:
space:
mode:
Diffstat (limited to 'vendors/simpletest/test')
-rwxr-xr-xvendors/simpletest/test/acceptance_test.php1633
-rwxr-xr-xvendors/simpletest/test/adapter_test.php77
-rwxr-xr-xvendors/simpletest/test/all_tests.php13
-rwxr-xr-xvendors/simpletest/test/authentication_test.php145
-rwxr-xr-xvendors/simpletest/test/autorun_test.php13
-rwxr-xr-xvendors/simpletest/test/bad_test_suite.php10
-rwxr-xr-xvendors/simpletest/test/browser_test.php779
-rwxr-xr-xvendors/simpletest/test/collector_test.php51
-rwxr-xr-xvendors/simpletest/test/command_line_test.php40
-rwxr-xr-xvendors/simpletest/test/compatibility_test.php97
-rwxr-xr-xvendors/simpletest/test/cookies_test.php227
-rwxr-xr-xvendors/simpletest/test/detached_test.php15
-rwxr-xr-xvendors/simpletest/test/dumper_test.php88
-rwxr-xr-xvendors/simpletest/test/eclipse_test.php32
-rwxr-xr-xvendors/simpletest/test/encoding_test.php213
-rwxr-xr-xvendors/simpletest/test/errors_test.php300
-rwxr-xr-xvendors/simpletest/test/exceptions_test.php153
-rwxr-xr-xvendors/simpletest/test/expectation_test.php245
-rwxr-xr-xvendors/simpletest/test/form_test.php323
-rwxr-xr-xvendors/simpletest/test/frames_test.php549
-rwxr-xr-xvendors/simpletest/test/http_test.php427
-rwxr-xr-xvendors/simpletest/test/interfaces_test.php137
-rwxr-xr-xvendors/simpletest/test/live_test.php47
-rwxr-xr-xvendors/simpletest/test/mock_objects_test.php994
-rwxr-xr-xvendors/simpletest/test/page_test.php903
-rwxr-xr-xvendors/simpletest/test/parse_error_test.php9
-rwxr-xr-xvendors/simpletest/test/parser_test.php551
-rwxr-xr-xvendors/simpletest/test/reflection_php4_test.php61
-rwxr-xr-xvendors/simpletest/test/reflection_php5_test.php271
-rwxr-xr-xvendors/simpletest/test/remote_test.php20
-rwxr-xr-xvendors/simpletest/test/shell_test.php38
-rwxr-xr-xvendors/simpletest/test/shell_tester_test.php42
-rwxr-xr-xvendors/simpletest/test/simpletest_test.php58
-rwxr-xr-xvendors/simpletest/test/socket_test.php25
-rwxr-xr-xvendors/simpletest/test/support/collector/collectable.10
-rwxr-xr-xvendors/simpletest/test/support/collector/collectable.20
-rwxr-xr-xvendors/simpletest/test/support/empty_test_file.php3
-rwxr-xr-xvendors/simpletest/test/support/latin1_sample1
-rwxr-xr-xvendors/simpletest/test/support/spl_examples.php15
-rwxr-xr-xvendors/simpletest/test/support/supplementary_upload_sample.txt1
-rwxr-xr-xvendors/simpletest/test/support/test1.php7
-rwxr-xr-xvendors/simpletest/test/support/upload_sample.txt1
-rwxr-xr-xvendors/simpletest/test/tag_test.php554
-rwxr-xr-xvendors/simpletest/test/test_with_parse_error.php8
-rwxr-xr-xvendors/simpletest/test/unit_tester_test.php55
-rwxr-xr-xvendors/simpletest/test/unit_tests.php55
-rwxr-xr-xvendors/simpletest/test/url_test.php443
-rwxr-xr-xvendors/simpletest/test/user_agent_test.php358
-rwxr-xr-xvendors/simpletest/test/visual_test.php495
-rwxr-xr-xvendors/simpletest/test/web_tester_test.php156
-rwxr-xr-xvendors/simpletest/test/xml_test.php187
51 files changed, 10925 insertions, 0 deletions
diff --git a/vendors/simpletest/test/acceptance_test.php b/vendors/simpletest/test/acceptance_test.php
new file mode 100755
index 000000000..9dbb5a35a
--- /dev/null
+++ b/vendors/simpletest/test/acceptance_test.php
@@ -0,0 +1,1633 @@
+<?php
+// $Id: acceptance_test.php 1700 2008-03-24 16:17:48Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../compatibility.php');
+require_once(dirname(__FILE__) . '/../browser.php');
+require_once(dirname(__FILE__) . '/../web_tester.php');
+require_once(dirname(__FILE__) . '/../unit_tester.php');
+
+class SimpleTestAcceptanceTest extends WebTestCase {
+ function samples() {
+ return 'http://www.lastcraft.com/test/';
+ }
+}
+
+class TestOfLiveBrowser extends UnitTestCase {
+ function samples() {
+ return SimpleTestAcceptanceTest::samples();
+ }
+
+ function testGet() {
+ $browser = &new SimpleBrowser();
+ $browser->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ $this->assertTrue($browser->get($this->samples() . 'network_confirm.php'));
+ $this->assertPattern('/target for the SimpleTest/', $browser->getContent());
+ $this->assertPattern('/Request method.*?<dd>GET<\/dd>/', $browser->getContent());
+ $this->assertEqual($browser->getTitle(), 'Simple test target file');
+ $this->assertEqual($browser->getResponseCode(), 200);
+ $this->assertEqual($browser->getMimeType(), 'text/html');
+ }
+
+ function testPost() {
+ $browser = &new SimpleBrowser();
+ $browser->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ $this->assertTrue($browser->post($this->samples() . 'network_confirm.php'));
+ $this->assertPattern('/target for the SimpleTest/', $browser->getContent());
+ $this->assertPattern('/Request method.*?<dd>POST<\/dd>/', $browser->getContent());
+ }
+
+ function testAbsoluteLinkFollowing() {
+ $browser = &new SimpleBrowser();
+ $browser->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ $browser->get($this->samples() . 'link_confirm.php');
+ $this->assertTrue($browser->clickLink('Absolute'));
+ $this->assertPattern('/target for the SimpleTest/', $browser->getContent());
+ }
+
+ function testRelativeEncodedeLinkFollowing() {
+ $browser = &new SimpleBrowser();
+ $browser->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ $browser->get($this->samples() . 'link_confirm.php');
+ $this->assertTrue($browser->clickLink("märcêl kiek'eboe"));
+ $this->assertPattern('/target for the SimpleTest/', $browser->getContent());
+ }
+
+ function testRelativeLinkFollowing() {
+ $browser = &new SimpleBrowser();
+ $browser->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ $browser->get($this->samples() . 'link_confirm.php');
+ $this->assertTrue($browser->clickLink('Relative'));
+ $this->assertPattern('/target for the SimpleTest/', $browser->getContent());
+ }
+
+ function testUnifiedClickLinkClicking() {
+ $browser = &new SimpleBrowser();
+ $browser->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ $browser->get($this->samples() . 'link_confirm.php');
+ $this->assertTrue($browser->click('Relative'));
+ $this->assertPattern('/target for the SimpleTest/', $browser->getContent());
+ }
+
+ function testIdLinkFollowing() {
+ $browser = &new SimpleBrowser();
+ $browser->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ $browser->get($this->samples() . 'link_confirm.php');
+ $this->assertTrue($browser->clickLinkById(1));
+ $this->assertPattern('/target for the SimpleTest/', $browser->getContent());
+ }
+
+ function testCookieReading() {
+ $browser = &new SimpleBrowser();
+ $browser->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ $browser->get($this->samples() . 'set_cookies.php');
+ $this->assertEqual($browser->getCurrentCookieValue('session_cookie'), 'A');
+ $this->assertEqual($browser->getCurrentCookieValue('short_cookie'), 'B');
+ $this->assertEqual($browser->getCurrentCookieValue('day_cookie'), 'C');
+ }
+
+ function testSimpleSubmit() {
+ $browser = &new SimpleBrowser();
+ $browser->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ $browser->get($this->samples() . 'form.html');
+ $this->assertTrue($browser->clickSubmit('Go!'));
+ $this->assertPattern('/Request method.*?<dd>POST<\/dd>/', $browser->getContent());
+ $this->assertPattern('/go=\[Go!\]/', $browser->getContent());
+ }
+
+ function testUnifiedClickCanSubmit() {
+ $browser = &new SimpleBrowser();
+ $browser->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ $browser->get($this->samples() . 'form.html');
+ $this->assertTrue($browser->click('Go!'));
+ $this->assertPattern('/go=\[Go!\]/', $browser->getContent());
+ }
+}
+
+class TestRadioFields extends SimpleTestAcceptanceTest {
+ function testSetFieldAsInteger() {
+ $this->get($this->samples() . 'form_with_radio_buttons.html');
+ $this->assertTrue($this->setField('tested_field', 2));
+ $this->clickSubmitByName('send');
+ $this->assertEqual($this->getUrl(), $this->samples() . 'form_with_radio_buttons.html?tested_field=2&send=click+me');
+ }
+
+ function testSetFieldAsString() {
+ $this->get($this->samples() . 'form_with_radio_buttons.html');
+ $this->assertTrue($this->setField('tested_field', '2'));
+ $this->clickSubmitByName('send');
+ $this->assertEqual($this->getUrl(), $this->samples() . 'form_with_radio_buttons.html?tested_field=2&send=click+me');
+ }
+}
+
+class TestOfLiveFetching extends SimpleTestAcceptanceTest {
+ function setUp() {
+ $this->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ }
+
+ function testFormWithArrayBasedInputs() {
+ $this->get($this->samples() . 'form_with_array_based_inputs.php');
+ $this->setField('value[]', '3', '1');
+ $this->setField('value[]', '4', '2');
+ $this->clickSubmit('Go');
+ $this->assertPattern('/QUERY_STRING : value%5B%5D=3&value%5B%5D=4&submit=Go/');
+ }
+
+ function testFormWithQuotedValues() {
+ $this->get($this->samples() . 'form_with_quoted_values.php');
+ $this->assertField('a', 'default');
+ $this->assertFieldById('text_field', 'default');
+ $this->clickSubmit('Go');
+ $this->assertPattern('/a=default&submit=Go/');
+ }
+
+ function testGet() {
+ $this->assertTrue($this->get($this->samples() . 'network_confirm.php'));
+ $this->assertEqual($this->getUrl(), $this->samples() . 'network_confirm.php');
+ $this->assertText('target for the SimpleTest');
+ $this->assertPattern('/Request method.*?<dd>GET<\/dd>/');
+ $this->assertTitle('Simple test target file');
+ $this->assertTitle(new PatternExpectation('/target file/'));
+ $this->assertResponse(200);
+ $this->assertMime('text/html');
+ $this->assertHeader('connection', 'close');
+ $this->assertHeader('connection', new PatternExpectation('/los/'));
+ }
+
+ function testSlowGet() {
+ $this->assertTrue($this->get($this->samples() . 'slow_page.php'));
+ }
+
+ function testTimedOutGet() {
+ $this->setConnectionTimeout(1);
+ $this->ignoreErrors();
+ $this->assertFalse($this->get($this->samples() . 'slow_page.php'));
+ }
+
+ function testPost() {
+ $this->assertTrue($this->post($this->samples() . 'network_confirm.php'));
+ $this->assertText('target for the SimpleTest');
+ $this->assertPattern('/Request method.*?<dd>POST<\/dd>/');
+ }
+
+ function testGetWithData() {
+ $this->get($this->samples() . 'network_confirm.php', array("a" => "aaa"));
+ $this->assertPattern('/Request method.*?<dd>GET<\/dd>/');
+ $this->assertText('a=[aaa]');
+ }
+
+ function testPostWithData() {
+ $this->post($this->samples() . 'network_confirm.php', array("a" => "aaa"));
+ $this->assertPattern('/Request method.*?<dd>POST<\/dd>/');
+ $this->assertText('a=[aaa]');
+ }
+
+ function testPostWithRecursiveData() {
+ $this->post($this->samples() . 'network_confirm.php', array("a" => "aaa"));
+ $this->assertPattern('/Request method.*?<dd>POST<\/dd>/');
+ $this->assertText('a=[aaa]');
+
+ $this->post($this->samples() . 'network_confirm.php', array("a[aa]" => "aaa"));
+ $this->assertPattern('/Request method.*?<dd>POST<\/dd>/');
+ $this->assertText('a=[aa=[aaa]]');
+
+ $this->post($this->samples() . 'network_confirm.php', array("a[aa][aaa]" => "aaaa"));
+ $this->assertPattern('/Request method.*?<dd>POST<\/dd>/');
+ $this->assertText('a=[aa=[aaa=[aaaa]]]');
+
+ $this->post($this->samples() . 'network_confirm.php', array("a" => array("aa" => "aaa")));
+ $this->assertPattern('/Request method.*?<dd>POST<\/dd>/');
+ $this->assertText('a=[aa=[aaa]]');
+
+ $this->post($this->samples() . 'network_confirm.php', array("a" => array("aa" => array("aaa" => "aaaa"))));
+ $this->assertPattern('/Request method.*?<dd>POST<\/dd>/');
+ $this->assertText('a=[aa=[aaa=[aaaa]]]');
+ }
+
+ function testRelativeGet() {
+ $this->get($this->samples() . 'link_confirm.php');
+ $this->assertTrue($this->get('network_confirm.php'));
+ $this->assertText('target for the SimpleTest');
+ }
+
+ function testRelativePost() {
+ $this->post($this->samples() . 'link_confirm.php');
+ $this->assertTrue($this->post('network_confirm.php'));
+ $this->assertText('target for the SimpleTest');
+ }
+}
+
+class TestOfLinkFollowing extends SimpleTestAcceptanceTest {
+ function setUp() {
+ $this->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ }
+
+ function testLinkAssertions() {
+ $this->get($this->samples() . 'link_confirm.php');
+ $this->assertLink('Absolute', $this->samples() . 'network_confirm.php');
+ $this->assertLink('Absolute', new PatternExpectation('/confirm/'));
+ $this->assertClickable('Absolute');
+ }
+
+ function testAbsoluteLinkFollowing() {
+ $this->get($this->samples() . 'link_confirm.php');
+ $this->assertTrue($this->clickLink('Absolute'));
+ $this->assertText('target for the SimpleTest');
+ }
+
+ function testRelativeLinkFollowing() {
+ $this->get($this->samples() . 'link_confirm.php');
+ $this->assertTrue($this->clickLink('Relative'));
+ $this->assertText('target for the SimpleTest');
+ }
+
+ function testLinkIdFollowing() {
+ $this->get($this->samples() . 'link_confirm.php');
+ $this->assertLinkById(1);
+ $this->assertTrue($this->clickLinkById(1));
+ $this->assertText('target for the SimpleTest');
+ }
+
+ function testAbsoluteUrlBehavesAbsolutely() {
+ $this->get($this->samples() . 'link_confirm.php');
+ $this->get('http://www.lastcraft.com');
+ $this->assertText('No guarantee of quality is given or even intended');
+ }
+
+ function testRelativeUrlRespectsBaseTag() {
+ $this->get($this->samples() . 'base_tag/base_link.html');
+ $this->click('Back to test pages');
+ $this->assertTitle('Simple test target file');
+ }
+}
+
+class TestOfLivePageLinkingWithMinimalLinks extends SimpleTestAcceptanceTest {
+ function setUp() {
+ $this->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ }
+
+ function testClickToExplicitelyNamedSelfReturns() {
+ $this->get($this->samples() . 'front_controller_style/a_page.php');
+ $this->assertEqual($this->getUrl(), $this->samples() . 'front_controller_style/a_page.php');
+ $this->assertTitle('Simple test page with links');
+ $this->assertLink('Self');
+ $this->clickLink('Self');
+ $this->assertTitle('Simple test page with links');
+ }
+
+ function testClickToMissingPageReturnsToSamePage() {
+ $this->get($this->samples() . 'front_controller_style/a_page.php');
+ $this->clickLink('No page');
+ $this->assertTitle('Simple test page with links');
+ $this->assertText('[action=no_page]');
+ }
+
+ function testClickToBareActionReturnsToSamePage() {
+ $this->get($this->samples() . 'front_controller_style/a_page.php');
+ $this->clickLink('Bare action');
+ $this->assertTitle('Simple test page with links');
+ $this->assertText('[action=]');
+ }
+
+ function testClickToSingleQuestionMarkReturnsToSamePage() {
+ $this->get($this->samples() . 'front_controller_style/a_page.php');
+ $this->clickLink('Empty query');
+ $this->assertTitle('Simple test page with links');
+ }
+
+ function testClickToEmptyStringReturnsToSamePage() {
+ $this->get($this->samples() . 'front_controller_style/a_page.php');
+ $this->clickLink('Empty link');
+ $this->assertTitle('Simple test page with links');
+ }
+
+ function testClickToSingleDotGoesToCurrentDirectory() {
+ $this->get($this->samples() . 'front_controller_style/a_page.php');
+ $this->clickLink('Current directory');
+ $this->assertTitle(
+ 'Simple test front controller',
+ '%s -> index.php needs to be set as a default web server home page');
+ }
+
+ function testClickBackADirectoryLevel() {
+ $this->get($this->samples() . 'front_controller_style/');
+ $this->clickLink('Down one');
+ $this->assertPattern('|Index of .*?/test|i');
+ }
+}
+
+class TestOfLiveFrontControllerEmulation extends SimpleTestAcceptanceTest {
+ function setUp() {
+ $this->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ }
+
+ function testJumpToNamedPage() {
+ $this->get($this->samples() . 'front_controller_style/');
+ $this->assertText('Simple test front controller');
+ $this->clickLink('Index');
+ $this->assertResponse(200);
+ $this->assertText('[action=index]');
+ }
+
+ function testJumpToUnnamedPage() {
+ $this->get($this->samples() . 'front_controller_style/');
+ $this->clickLink('No page');
+ $this->assertResponse(200);
+ $this->assertText('Simple test front controller');
+ $this->assertText('[action=no_page]');
+ }
+
+ function testJumpToUnnamedPageWithBareParameter() {
+ $this->get($this->samples() . 'front_controller_style/');
+ $this->clickLink('Bare action');
+ $this->assertResponse(200);
+ $this->assertText('Simple test front controller');
+ $this->assertText('[action=]');
+ }
+
+ function testJumpToUnnamedPageWithEmptyQuery() {
+ $this->get($this->samples() . 'front_controller_style/');
+ $this->clickLink('Empty query');
+ $this->assertResponse(200);
+ $this->assertPattern('/Simple test front controller/');
+ $this->assertPattern('/raw get data.*?\[\].*?get data/si');
+ }
+
+ function testJumpToUnnamedPageWithEmptyLink() {
+ $this->get($this->samples() . 'front_controller_style/');
+ $this->clickLink('Empty link');
+ $this->assertResponse(200);
+ $this->assertPattern('/Simple test front controller/');
+ $this->assertPattern('/raw get data.*?\[\].*?get data/si');
+ }
+
+ function testJumpBackADirectoryLevel() {
+ $this->get($this->samples() . 'front_controller_style/');
+ $this->clickLink('Down one');
+ $this->assertPattern('|Index of .*?/test|');
+ }
+
+ function testSubmitToNamedPage() {
+ $this->get($this->samples() . 'front_controller_style/');
+ $this->assertText('Simple test front controller');
+ $this->clickSubmit('Index');
+ $this->assertResponse(200);
+ $this->assertText('[action=Index]');
+ }
+
+ function testSubmitToSameDirectory() {
+ $this->get($this->samples() . 'front_controller_style/index.php');
+ $this->clickSubmit('Same directory');
+ $this->assertResponse(200);
+ $this->assertText('[action=Same+directory]');
+ }
+
+ function testSubmitToEmptyAction() {
+ $this->get($this->samples() . 'front_controller_style/index.php');
+ $this->clickSubmit('Empty action');
+ $this->assertResponse(200);
+ $this->assertText('[action=Empty+action]');
+ }
+
+ function testSubmitToNoAction() {
+ $this->get($this->samples() . 'front_controller_style/index.php');
+ $this->clickSubmit('No action');
+ $this->assertResponse(200);
+ $this->assertText('[action=No+action]');
+ }
+
+ function testSubmitBackADirectoryLevel() {
+ $this->get($this->samples() . 'front_controller_style/');
+ $this->clickSubmit('Down one');
+ $this->assertPattern('|Index of .*?/test|');
+ }
+
+ function testSubmitToNamedPageWithMixedPostAndGet() {
+ $this->get($this->samples() . 'front_controller_style/?a=A');
+ $this->assertText('Simple test front controller');
+ $this->clickSubmit('Index post');
+ $this->assertText('action=[Index post]');
+ $this->assertNoText('[a=A]');
+ }
+
+ function testSubmitToSameDirectoryMixedPostAndGet() {
+ $this->get($this->samples() . 'front_controller_style/index.php?a=A');
+ $this->clickSubmit('Same directory post');
+ $this->assertText('action=[Same directory post]');
+ $this->assertNoText('[a=A]');
+ }
+
+ function testSubmitToEmptyActionMixedPostAndGet() {
+ $this->get($this->samples() . 'front_controller_style/index.php?a=A');
+ $this->clickSubmit('Empty action post');
+ $this->assertText('action=[Empty action post]');
+ $this->assertText('[a=A]');
+ }
+
+ function testSubmitToNoActionMixedPostAndGet() {
+ $this->get($this->samples() . 'front_controller_style/index.php?a=A');
+ $this->clickSubmit('No action post');
+ $this->assertText('action=[No action post]');
+ $this->assertText('[a=A]');
+ }
+}
+
+class TestOfLiveHeaders extends SimpleTestAcceptanceTest {
+ function setUp() {
+ $this->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ }
+
+ function testConfirmingHeaderExistence() {
+ $this->get('http://www.lastcraft.com/');
+ $this->assertHeader('content-type');
+ $this->assertHeader('content-type', 'text/html');
+ $this->assertHeaderPattern('content-type', '/HTML/i');
+ $this->assertNoHeader('WWW-Authenticate');
+ }
+}
+
+class TestOfLiveRedirects extends SimpleTestAcceptanceTest {
+ function setUp() {
+ $this->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ }
+
+ function testNoRedirects() {
+ $this->setMaximumRedirects(0);
+ $this->get($this->samples() . 'redirect.php');
+ $this->assertTitle('Redirection test');
+ }
+
+ function testRedirects() {
+ $this->setMaximumRedirects(1);
+ $this->get($this->samples() . 'redirect.php');
+ $this->assertTitle('Simple test target file');
+ }
+
+ function testRedirectLosesGetData() {
+ $this->get($this->samples() . 'redirect.php', array('a' => 'aaa'));
+ $this->assertNoText('a=[aaa]');
+ }
+
+ function testRedirectKeepsExtraRequestDataOfItsOwn() {
+ $this->get($this->samples() . 'redirect.php');
+ $this->assertText('r=[rrr]');
+ }
+
+ function testRedirectLosesPostData() {
+ $this->post($this->samples() . 'redirect.php', array('a' => 'aaa'));
+ $this->assertTitle('Simple test target file');
+ $this->assertNoText('a=[aaa]');
+ }
+
+ function testRedirectWithBaseUrlChange() {
+ $this->get($this->samples() . 'base_change_redirect.php');
+ $this->assertTitle('Simple test target file in folder');
+ $this->get($this->samples() . 'path/base_change_redirect.php');
+ $this->assertTitle('Simple test target file');
+ }
+
+ function testRedirectWithDoubleBaseUrlChange() {
+ $this->get($this->samples() . 'double_base_change_redirect.php');
+ $this->assertTitle('Simple test target file');
+ }
+}
+
+class TestOfLiveCookies extends SimpleTestAcceptanceTest {
+ function setUp() {
+ $this->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ }
+
+ function here() {
+ return new SimpleUrl($this->samples());
+ }
+
+ function thisHost() {
+ $here = $this->here();
+ return $here->getHost();
+ }
+
+ function thisPath() {
+ $here = $this->here();
+ return $here->getPath();
+ }
+
+ function testCookieSettingAndAssertions() {
+ $this->setCookie('a', 'Test cookie a');
+ $this->setCookie('b', 'Test cookie b', $this->thisHost());
+ $this->setCookie('c', 'Test cookie c', $this->thisHost(), $this->thisPath());
+ $this->get($this->samples() . 'network_confirm.php');
+ $this->assertText('Test cookie a');
+ $this->assertText('Test cookie b');
+ $this->assertText('Test cookie c');
+ $this->assertCookie('a');
+ $this->assertCookie('b', 'Test cookie b');
+ $this->assertTrue($this->getCookie('c') == 'Test cookie c');
+ }
+
+ function testNoCookieSetWhenCookiesDisabled() {
+ $this->setCookie('a', 'Test cookie a');
+ $this->ignoreCookies();
+ $this->get($this->samples() . 'network_confirm.php');
+ $this->assertNoText('Test cookie a');
+ }
+
+ function testCookieReading() {
+ $this->get($this->samples() . 'set_cookies.php');
+ $this->assertCookie('session_cookie', 'A');
+ $this->assertCookie('short_cookie', 'B');
+ $this->assertCookie('day_cookie', 'C');
+ }
+
+ function testNoCookieReadingWhenCookiesDisabled() {
+ $this->ignoreCookies();
+ $this->get($this->samples() . 'set_cookies.php');
+ $this->assertNoCookie('session_cookie');
+ $this->assertNoCookie('short_cookie');
+ $this->assertNoCookie('day_cookie');
+ }
+
+ function testCookiePatternAssertions() {
+ $this->get($this->samples() . 'set_cookies.php');
+ $this->assertCookie('session_cookie', new PatternExpectation('/a/i'));
+ }
+
+ function testTemporaryCookieExpiry() {
+ $this->get($this->samples() . 'set_cookies.php');
+ $this->restart();
+ $this->assertNoCookie('session_cookie');
+ $this->assertCookie('day_cookie', 'C');
+ }
+
+ function testTimedCookieExpiryWith100SecondMargin() {
+ $this->get($this->samples() . 'set_cookies.php');
+ $this->ageCookies(3600);
+ $this->restart(time() + 100);
+ $this->assertNoCookie('session_cookie');
+ $this->assertNoCookie('hour_cookie');
+ $this->assertCookie('day_cookie', 'C');
+ }
+
+ function testNoClockOverDriftBy100Seconds() {
+ $this->get($this->samples() . 'set_cookies.php');
+ $this->restart(time() + 200);
+ $this->assertNoCookie(
+ 'short_cookie',
+ '%s -> Please check your computer clock setting if you are not using NTP');
+ }
+
+ function testNoClockUnderDriftBy100Seconds() {
+ $this->get($this->samples() . 'set_cookies.php');
+ $this->restart(time() + 0);
+ $this->assertCookie(
+ 'short_cookie',
+ 'B',
+ '%s -> Please check your computer clock setting if you are not using NTP');
+ }
+
+ function testCookiePath() {
+ $this->get($this->samples() . 'set_cookies.php');
+ $this->assertNoCookie('path_cookie', 'D');
+ $this->get('./path/show_cookies.php');
+ $this->assertPattern('/path_cookie/');
+ $this->assertCookie('path_cookie', 'D');
+ }
+}
+
+class LiveTestOfForms extends SimpleTestAcceptanceTest {
+ function setUp() {
+ $this->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ }
+
+ function testSimpleSubmit() {
+ $this->get($this->samples() . 'form.html');
+ $this->assertTrue($this->clickSubmit('Go!'));
+ $this->assertPattern('/Request method.*?<dd>POST<\/dd>/');
+ $this->assertText('go=[Go!]');
+ }
+
+ function testDefaultFormValues() {
+ $this->get($this->samples() . 'form.html');
+ $this->assertFieldByName('a', '');
+ $this->assertFieldByName('b', 'Default text');
+ $this->assertFieldByName('c', '');
+ $this->assertFieldByName('d', 'd1');
+ $this->assertFieldByName('e', false);
+ $this->assertFieldByName('f', 'on');
+ $this->assertFieldByName('g', 'g3');
+ $this->assertFieldByName('h', 2);
+ $this->assertFieldByName('go', 'Go!');
+ $this->assertClickable('Go!');
+ $this->assertSubmit('Go!');
+ $this->assertTrue($this->clickSubmit('Go!'));
+ $this->assertText('go=[Go!]');
+ $this->assertText('a=[]');
+ $this->assertText('b=[Default text]');
+ $this->assertText('c=[]');
+ $this->assertText('d=[d1]');
+ $this->assertNoText('e=[');
+ $this->assertText('f=[on]');
+ $this->assertText('g=[g3]');
+ }
+
+ function testFormSubmissionByButtonLabel() {
+ $this->get($this->samples() . 'form.html');
+ $this->setFieldByName('a', 'aaa');
+ $this->setFieldByName('b', 'bbb');
+ $this->setFieldByName('c', 'ccc');
+ $this->setFieldByName('d', 'D2');
+ $this->setFieldByName('e', 'on');
+ $this->setFieldByName('f', false);
+ $this->setFieldByName('g', 'g2');
+ $this->setFieldByName('h', 1);
+ $this->assertTrue($this->clickSubmit('Go!'));
+ $this->assertText('a=[aaa]');
+ $this->assertText('b=[bbb]');
+ $this->assertText('c=[ccc]');
+ $this->assertText('d=[d2]');
+ $this->assertText('e=[on]');
+ $this->assertNoText('f=[');
+ $this->assertText('g=[g2]');
+ }
+
+ function testAdditionalFormValues() {
+ $this->get($this->samples() . 'form.html');
+ $this->assertTrue($this->clickSubmit('Go!', array('add' => 'A')));
+ $this->assertText('go=[Go!]');
+ $this->assertText('add=[A]');
+ }
+
+ function testFormSubmissionByName() {
+ $this->get($this->samples() . 'form.html');
+ $this->setFieldByName('a', 'A');
+ $this->assertTrue($this->clickSubmitByName('go'));
+ $this->assertText('a=[A]');
+ }
+
+ function testFormSubmissionByNameAndAdditionalParameters() {
+ $this->get($this->samples() . 'form.html');
+ $this->assertTrue($this->clickSubmitByName('go', array('add' => 'A')));
+ $this->assertText('go=[Go!]');
+ $this->assertText('add=[A]');
+ }
+
+ function testFormSubmissionBySubmitButtonLabeledSubmit() {
+ $this->get($this->samples() . 'form.html');
+ $this->assertTrue($this->clickSubmitByName('test'));
+ $this->assertText('test=[Submit]');
+ }
+
+ function testFormSubmissionWithIds() {
+ $this->get($this->samples() . 'form.html');
+ $this->assertFieldById(1, '');
+ $this->assertFieldById(2, 'Default text');
+ $this->assertFieldById(3, '');
+ $this->assertFieldById(4, 'd1');
+ $this->assertFieldById(5, false);
+ $this->assertFieldById(6, 'on');
+ $this->assertFieldById(8, 'g3');
+ $this->assertFieldById(11, 2);
+ $this->setFieldById(1, 'aaa');
+ $this->setFieldById(2, 'bbb');
+ $this->setFieldById(3, 'ccc');
+ $this->setFieldById(4, 'D2');
+ $this->setFieldById(5, 'on');
+ $this->setFieldById(6, false);
+ $this->setFieldById(8, 'g2');
+ $this->setFieldById(11, 'H1');
+ $this->assertTrue($this->clickSubmitById(99));
+ $this->assertText('a=[aaa]');
+ $this->assertText('b=[bbb]');
+ $this->assertText('c=[ccc]');
+ $this->assertText('d=[d2]');
+ $this->assertText('e=[on]');
+ $this->assertNoText('f=[');
+ $this->assertText('g=[g2]');
+ $this->assertText('h=[1]');
+ $this->assertText('go=[Go!]');
+ }
+
+ function testFormSubmissionWithLabels() {
+ $this->get($this->samples() . 'form.html');
+ $this->assertField('Text A', '');
+ $this->assertField('Text B', 'Default text');
+ $this->assertField('Text area C', '');
+ $this->assertField('Selection D', 'd1');
+ $this->assertField('Checkbox E', false);
+ $this->assertField('Checkbox F', 'on');
+ $this->assertField('3', 'g3');
+ $this->assertField('Selection H', 2);
+ $this->setField('Text A', 'aaa');
+ $this->setField('Text B', 'bbb');
+ $this->setField('Text area C', 'ccc');
+ $this->setField('Selection D', 'D2');
+ $this->setField('Checkbox E', 'on');
+ $this->setField('Checkbox F', false);
+ $this->setField('2', 'g2');
+ $this->setField('Selection H', 'H1');
+ $this->clickSubmit('Go!');
+ $this->assertText('a=[aaa]');
+ $this->assertText('b=[bbb]');
+ $this->assertText('c=[ccc]');
+ $this->assertText('d=[d2]');
+ $this->assertText('e=[on]');
+ $this->assertNoText('f=[');
+ $this->assertText('g=[g2]');
+ $this->assertText('h=[1]');
+ $this->assertText('go=[Go!]');
+ }
+
+ function testSettingCheckboxWithBooleanTrueSetsUnderlyingValue() {
+ $this->get($this->samples() . 'form.html');
+ $this->setField('Checkbox E', true);
+ $this->assertField('Checkbox E', 'on');
+ $this->clickSubmit('Go!');
+ $this->assertText('e=[on]');
+ }
+
+ function testFormSubmissionWithMixedPostAndGet() {
+ $this->get($this->samples() . 'form_with_mixed_post_and_get.html');
+ $this->setField('Text A', 'Hello');
+ $this->assertTrue($this->clickSubmit('Go!'));
+ $this->assertText('a=[Hello]');
+ $this->assertText('x=[X]');
+ $this->assertText('y=[Y]');
+ }
+
+ function testFormSubmissionWithMixedPostAndEncodedGet() {
+ $this->get($this->samples() . 'form_with_mixed_post_and_get.html');
+ $this->setField('Text B', 'Hello');
+ $this->assertTrue($this->clickSubmit('Go encoded!'));
+ $this->assertText('b=[Hello]');
+ $this->assertText('x=[X]');
+ $this->assertText('y=[Y]');
+ }
+
+ function testFormSubmissionWithoutAction() {
+ $this->get($this->samples() . 'form_without_action.php?test=test');
+ $this->assertText('_GET : [test]');
+ $this->assertTrue($this->clickSubmit('Submit Post With Empty Action'));
+ $this->assertText('_GET : [test]');
+ $this->assertText('_POST : [test]');
+ }
+
+ function testImageSubmissionByLabel() {
+ $this->get($this->samples() . 'form.html');
+ $this->assertImage('Image go!');
+ $this->assertTrue($this->clickImage('Image go!', 10, 12));
+ $this->assertText('go_x=[10]');
+ $this->assertText('go_y=[12]');
+ }
+
+ function testImageSubmissionByLabelWithAdditionalParameters() {
+ $this->get($this->samples() . 'form.html');
+ $this->assertTrue($this->clickImage('Image go!', 10, 12, array('add' => 'A')));
+ $this->assertText('add=[A]');
+ }
+
+ function testImageSubmissionByName() {
+ $this->get($this->samples() . 'form.html');
+ $this->assertTrue($this->clickImageByName('go', 10, 12));
+ $this->assertText('go_x=[10]');
+ $this->assertText('go_y=[12]');
+ }
+
+ function testImageSubmissionById() {
+ $this->get($this->samples() . 'form.html');
+ $this->assertTrue($this->clickImageById(97, 10, 12));
+ $this->assertText('go_x=[10]');
+ $this->assertText('go_y=[12]');
+ }
+
+ function testButtonSubmissionByLabel() {
+ $this->get($this->samples() . 'form.html');
+ $this->assertTrue($this->clickSubmit('Button go!', 10, 12));
+ $this->assertPattern('/go=\[ButtonGo\]/s');
+ }
+
+ function testNamelessSubmitSendsNoValue() {
+ $this->get($this->samples() . 'form_with_unnamed_submit.html');
+ $this->click('Go!');
+ $this->assertNoText('Go!');
+ $this->assertNoText('submit');
+ }
+
+ function testNamelessImageSendsXAndYValues() {
+ $this->get($this->samples() . 'form_with_unnamed_submit.html');
+ $this->clickImage('Image go!', 4, 5);
+ $this->assertNoText('ImageGo');
+ $this->assertText('x=[4]');
+ $this->assertText('y=[5]');
+ }
+
+ function testNamelessButtonSendsNoValue() {
+ $this->get($this->samples() . 'form_with_unnamed_submit.html');
+ $this->click('Button Go!');
+ $this->assertNoText('ButtonGo');
+ }
+
+ function testSelfSubmit() {
+ $this->get($this->samples() . 'self_form.php');
+ $this->assertNoText('[Submitted]');
+ $this->assertNoText('[Wrong form]');
+ $this->assertTrue($this->clickSubmit());
+ $this->assertText('[Submitted]');
+ $this->assertNoText('[Wrong form]');
+ $this->assertTitle('Test of form self submission');
+ }
+
+ function testSelfSubmitWithParameters() {
+ $this->get($this->samples() . 'self_form.php');
+ $this->setFieldByName('visible', 'Resent');
+ $this->assertTrue($this->clickSubmit());
+ $this->assertText('[Resent]');
+ }
+
+ function testSettingOfBlankOption() {
+ $this->get($this->samples() . 'form.html');
+ $this->assertTrue($this->setFieldByName('d', ''));
+ $this->clickSubmit('Go!');
+ $this->assertText('d=[]');
+ }
+
+ function testAssertingFieldValueWithPattern() {
+ $this->get($this->samples() . 'form.html');
+ $this->setField('c', 'A very long string');
+ $this->assertField('c', new PatternExpectation('/very long/'));
+ }
+
+ function testSendingMultipartFormDataEncodedForm() {
+ $this->get($this->samples() . 'form_data_encoded_form.html');
+ $this->assertField('Text A', '');
+ $this->assertField('Text B', 'Default text');
+ $this->assertField('Text area C', '');
+ $this->assertField('Selection D', 'd1');
+ $this->assertField('Checkbox E', false);
+ $this->assertField('Checkbox F', 'on');
+ $this->assertField('3', 'g3');
+ $this->assertField('Selection H', 2);
+ $this->setField('Text A', 'aaa');
+ $this->setField('Text B', 'bbb');
+ $this->setField('Text area C', 'ccc');
+ $this->setField('Selection D', 'D2');
+ $this->setField('Checkbox E', 'on');
+ $this->setField('Checkbox F', false);
+ $this->setField('2', 'g2');
+ $this->setField('Selection H', 'H1');
+ $this->assertTrue($this->clickSubmit('Go!'));
+ $this->assertText('a=[aaa]');
+ $this->assertText('b=[bbb]');
+ $this->assertText('c=[ccc]');
+ $this->assertText('d=[d2]');
+ $this->assertText('e=[on]');
+ $this->assertNoText('f=[');
+ $this->assertText('g=[g2]');
+ $this->assertText('h=[1]');
+ $this->assertText('go=[Go!]');
+ }
+
+ function testSettingVariousBlanksInFields() {
+ $this->get($this->samples() . 'form_with_false_defaults.html');
+ $this->assertField('Text A', '');
+ $this->setField('Text A', '0');
+ $this->assertField('Text A', '0');
+ $this->assertField('Text area B', '');
+ $this->setField('Text area B', '0');
+ $this->assertField('Text area B', '0');
+ $this->assertField('Text area C', " ");
+ $this->assertField('Selection D', '');
+ $this->setField('Selection D', 'D2');
+ $this->assertField('Selection D', 'D2');
+ $this->setField('Selection D', 'D3');
+ $this->assertField('Selection D', '0');
+ $this->setField('Selection D', 'D4');
+ $this->assertField('Selection D', '?');
+ $this->assertField('Checkbox E', '');
+ $this->assertField('Checkbox F', 'on');
+ $this->assertField('Checkbox G', '0');
+ $this->assertField('Checkbox H', '?');
+ $this->assertFieldByName('i', 'on');
+ $this->setFieldByName('i', '');
+ $this->assertFieldByName('i', '');
+ $this->setFieldByName('i', '0');
+ $this->assertFieldByName('i', '0');
+ $this->setFieldByName('i', '?');
+ $this->assertFieldByName('i', '?');
+ }
+
+ function testSubmissionOfBlankFields() {
+ $this->get($this->samples() . 'form_with_false_defaults.html');
+ $this->setField('Text A', '');
+ $this->setField('Text area B', '');
+ $this->setFieldByName('i', '');
+ $this->click('Go!');
+ $this->assertText('a=[]');
+ $this->assertText('b=[]');
+ $this->assertPattern('/c=\[ \]/');
+ $this->assertText('d=[]');
+ $this->assertText('e=[]');
+ $this->assertText('i=[]');
+ }
+
+ function testSubmissionOfEmptyValues() {
+ $this->get($this->samples() . 'form_with_false_defaults.html');
+ $this->setField('Selection D', 'D2');
+ $this->click('Go!');
+ $this->assertText('a=[]');
+ $this->assertText('b=[]');
+ $this->assertText('d=[D2]');
+ $this->assertText('f=[on]');
+ $this->assertText('i=[on]');
+ }
+
+ function testSubmissionOfZeroes() {
+ $this->get($this->samples() . 'form_with_false_defaults.html');
+ $this->setField('Text A', '0');
+ $this->setField('Text area B', '0');
+ $this->setField('Selection D', 'D3');
+ $this->setFieldByName('i', '0');
+ $this->click('Go!');
+ $this->assertText('a=[0]');
+ $this->assertText('b=[0]');
+ $this->assertText('d=[0]');
+ $this->assertText('g=[0]');
+ $this->assertText('i=[0]');
+ }
+
+ function testSubmissionOfQuestionMarks() {
+ $this->get($this->samples() . 'form_with_false_defaults.html');
+ $this->setField('Text A', '?');
+ $this->setField('Text area B', '?');
+ $this->setField('Selection D', 'D4');
+ $this->setFieldByName('i', '?');
+ $this->click('Go!');
+ $this->assertText('a=[?]');
+ $this->assertText('b=[?]');
+ $this->assertText('d=[?]');
+ $this->assertText('h=[?]');
+ $this->assertText('i=[?]');
+ }
+
+ function testSubmissionOfHtmlEncodedValues() {
+ $this->get($this->samples() . 'form_with_tricky_defaults.html');
+ $this->assertField('Text A', '&\'"<>');
+ $this->assertField('Text B', '"');
+ $this->assertField('Text area C', '&\'"<>');
+ $this->assertField('Selection D', "'");
+ $this->assertField('Checkbox E', '&\'"<>');
+ $this->assertField('Checkbox F', false);
+ $this->assertFieldByname('i', "'");
+ $this->click('Go!');
+ $this->assertText('a=[&\'"<>, "]');
+ $this->assertText('c=[&\'"<>]');
+ $this->assertText("d=[']");
+ $this->assertText('e=[&\'"<>]');
+ $this->assertText("i=[']");
+ }
+
+ function testFormActionRespectsBaseTag() {
+ $this->get($this->samples() . 'base_tag/form.html');
+ $this->assertTrue($this->clickSubmit('Go!'));
+ $this->assertText('go=[Go!]');
+ $this->assertText('a=[]');
+ }
+}
+
+class TestOfLiveMultiValueWidgets extends SimpleTestAcceptanceTest {
+ function setUp() {
+ $this->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ }
+
+ function testDefaultFormValueSubmission() {
+ $this->get($this->samples() . 'multiple_widget_form.html');
+ $this->assertFieldByName('a', array('a2', 'a3'));
+ $this->assertFieldByName('b', array('b2', 'b3'));
+ $this->assertFieldByName('c[]', array('c2', 'c3'));
+ $this->assertFieldByName('d', array('2', '3'));
+ $this->assertFieldByName('e', array('2', '3'));
+ $this->assertTrue($this->clickSubmit('Go!'));
+ $this->assertText('a=[a2, a3]');
+ $this->assertText('b=[b2, b3]');
+ $this->assertText('c=[c2, c3]');
+ $this->assertText('d=[2, 3]');
+ $this->assertText('e=[2, 3]');
+ }
+
+ function testSubmittingMultipleValues() {
+ $this->get($this->samples() . 'multiple_widget_form.html');
+ $this->setFieldByName('a', array('a1', 'a4'));
+ $this->assertFieldByName('a', array('a1', 'a4'));
+ $this->assertFieldByName('a', array('a4', 'a1'));
+ $this->setFieldByName('b', array('b1', 'b4'));
+ $this->assertFieldByName('b', array('b1', 'b4'));
+ $this->setFieldByName('c[]', array('c1', 'c4'));
+ $this->assertField('c[]', array('c1', 'c4'));
+ $this->setFieldByName('d', array('1', '4'));
+ $this->assertField('d', array('1', '4'));
+ $this->setFieldByName('e', array('e1', 'e4'));
+ $this->assertField('e', array('1', '4'));
+ $this->assertTrue($this->clickSubmit('Go!'));
+ $this->assertText('a=[a1, a4]');
+ $this->assertText('b=[b1, b4]');
+ $this->assertText('c=[c1, c4]');
+ $this->assertText('d=[1, 4]');
+ $this->assertText('e=[1, 4]');
+ }
+
+ function testSettingByOptionValue() {
+ $this->get($this->samples() . 'multiple_widget_form.html');
+ $this->setFieldByName('d', array('1', '4'));
+ $this->assertField('d', array('1', '4'));
+ $this->assertTrue($this->clickSubmit('Go!'));
+ $this->assertText('d=[1, 4]');
+ }
+
+ function testSubmittingMultipleValuesByLabel() {
+ $this->get($this->samples() . 'multiple_widget_form.html');
+ $this->setField('Multiple selection A', array('a1', 'a4'));
+ $this->assertField('Multiple selection A', array('a1', 'a4'));
+ $this->assertField('Multiple selection A', array('a4', 'a1'));
+ $this->setField('multiple selection C', array('c1', 'c4'));
+ $this->assertField('multiple selection C', array('c1', 'c4'));
+ $this->assertTrue($this->clickSubmit('Go!'));
+ $this->assertText('a=[a1, a4]');
+ $this->assertText('c=[c1, c4]');
+ }
+
+ function testSavantStyleHiddenFieldDefaults() {
+ $this->get($this->samples() . 'savant_style_form.html');
+ $this->assertFieldByName('a', array('a0'));
+ $this->assertFieldByName('b', array('b0'));
+ $this->assertTrue($this->clickSubmit('Go!'));
+ $this->assertText('a=[a0]');
+ $this->assertText('b=[b0]');
+ }
+
+ function testSavantStyleHiddenDefaultsAreOverridden() {
+ $this->get($this->samples() . 'savant_style_form.html');
+ $this->assertTrue($this->setFieldByName('a', array('a1')));
+ $this->assertTrue($this->setFieldByName('b', 'b1'));
+ $this->assertTrue($this->clickSubmit('Go!'));
+ $this->assertText('a=[a1]');
+ $this->assertText('b=[b1]');
+ }
+
+ function testSavantStyleFormSettingById() {
+ $this->get($this->samples() . 'savant_style_form.html');
+ $this->assertFieldById(1, array('a0'));
+ $this->assertFieldById(4, array('b0'));
+ $this->assertTrue($this->setFieldById(2, 'a1'));
+ $this->assertTrue($this->setFieldById(5, 'b1'));
+ $this->assertTrue($this->clickSubmitById(99));
+ $this->assertText('a=[a1]');
+ $this->assertText('b=[b1]');
+ }
+}
+
+class TestOfFileUploads extends SimpleTestAcceptanceTest {
+ function setUp() {
+ $this->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ }
+
+ function testSingleFileUpload() {
+ $this->get($this->samples() . 'upload_form.html');
+ $this->assertTrue($this->setField('Content:',
+ dirname(__FILE__) . '/support/upload_sample.txt'));
+ $this->assertField('Content:', dirname(__FILE__) . '/support/upload_sample.txt');
+ $this->click('Go!');
+ $this->assertText('Sample for testing file upload');
+ }
+
+ function testMultipleFileUpload() {
+ $this->get($this->samples() . 'upload_form.html');
+ $this->assertTrue($this->setField('Content:',
+ dirname(__FILE__) . '/support/upload_sample.txt'));
+ $this->assertTrue($this->setField('Supplemental:',
+ dirname(__FILE__) . '/support/supplementary_upload_sample.txt'));
+ $this->assertField('Supplemental:',
+ dirname(__FILE__) . '/support/supplementary_upload_sample.txt');
+ $this->click('Go!');
+ $this->assertText('Sample for testing file upload');
+ $this->assertText('Some more text content');
+ }
+
+ function testBinaryFileUpload() {
+ $this->get($this->samples() . 'upload_form.html');
+ $this->assertTrue($this->setField('Content:',
+ dirname(__FILE__) . '/support/latin1_sample'));
+ $this->click('Go!');
+ $this->assertText(
+ implode('', file(dirname(__FILE__) . '/support/latin1_sample')));
+ }
+}
+
+class TestOfLiveHistoryNavigation extends SimpleTestAcceptanceTest {
+ function setUp() {
+ $this->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ }
+
+ function testRetry() {
+ $this->get($this->samples() . 'cookie_based_counter.php');
+ $this->assertPattern('/count: 1/i');
+ $this->retry();
+ $this->assertPattern('/count: 2/i');
+ $this->retry();
+ $this->assertPattern('/count: 3/i');
+ }
+
+ function testOfBackButton() {
+ $this->get($this->samples() . '1.html');
+ $this->clickLink('2');
+ $this->assertTitle('2');
+ $this->assertTrue($this->back());
+ $this->assertTitle('1');
+ $this->assertTrue($this->forward());
+ $this->assertTitle('2');
+ $this->assertFalse($this->forward());
+ }
+
+ function testGetRetryResubmitsData() {
+ $this->assertTrue($this->get(
+ $this->samples() . 'network_confirm.php?a=aaa'));
+ $this->assertPattern('/Request method.*?<dd>GET<\/dd>/');
+ $this->assertText('a=[aaa]');
+ $this->retry();
+ $this->assertPattern('/Request method.*?<dd>GET<\/dd>/');
+ $this->assertText('a=[aaa]');
+ }
+
+ function testGetRetryResubmitsExtraData() {
+ $this->assertTrue($this->get(
+ $this->samples() . 'network_confirm.php',
+ array('a' => 'aaa')));
+ $this->assertPattern('/Request method.*?<dd>GET<\/dd>/');
+ $this->assertText('a=[aaa]');
+ $this->retry();
+ $this->assertPattern('/Request method.*?<dd>GET<\/dd>/');
+ $this->assertText('a=[aaa]');
+ }
+
+ function testPostRetryResubmitsData() {
+ $this->assertTrue($this->post(
+ $this->samples() . 'network_confirm.php',
+ array('a' => 'aaa')));
+ $this->assertPattern('/Request method.*?<dd>POST<\/dd>/');
+ $this->assertText('a=[aaa]');
+ $this->retry();
+ $this->assertPattern('/Request method.*?<dd>POST<\/dd>/');
+ $this->assertText('a=[aaa]');
+ }
+
+ function testGetRetryResubmitsRepeatedData() {
+ $this->assertTrue($this->get(
+ $this->samples() . 'network_confirm.php?a=1&a=2'));
+ $this->assertPattern('/Request method.*?<dd>GET<\/dd>/');
+ $this->assertText('a=[1, 2]');
+ $this->retry();
+ $this->assertPattern('/Request method.*?<dd>GET<\/dd>/');
+ $this->assertText('a=[1, 2]');
+ }
+}
+
+class TestOfLiveAuthentication extends SimpleTestAcceptanceTest {
+ function setUp() {
+ $this->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ }
+
+ function testChallengeFromProtectedPage() {
+ $this->get($this->samples() . 'protected/');
+ $this->assertResponse(401);
+ $this->assertAuthentication('Basic');
+ $this->assertRealm('SimpleTest basic authentication');
+ $this->assertRealm(new PatternExpectation('/simpletest/i'));
+ $this->authenticate('test', 'secret');
+ $this->assertResponse(200);
+ $this->retry();
+ $this->assertResponse(200);
+ }
+
+ function testTrailingSlashImpliedWithinRealm() {
+ $this->get($this->samples() . 'protected/');
+ $this->authenticate('test', 'secret');
+ $this->assertResponse(200);
+ $this->get($this->samples() . 'protected');
+ $this->assertResponse(200);
+ }
+
+ function testTrailingSlashImpliedSettingRealm() {
+ $this->get($this->samples() . 'protected');
+ $this->authenticate('test', 'secret');
+ $this->assertResponse(200);
+ $this->get($this->samples() . 'protected/');
+ $this->assertResponse(200);
+ }
+
+ function testEncodedAuthenticationFetchesPage() {
+ $this->get('http://test:secret@www.lastcraft.com/test/protected/');
+ $this->assertResponse(200);
+ }
+
+ function testEncodedAuthenticationFetchesPageAfterTrailingSlashRedirect() {
+ $this->get('http://test:secret@www.lastcraft.com/test/protected');
+ $this->assertResponse(200);
+ }
+
+ function testRealmExtendsToWholeDirectory() {
+ $this->get($this->samples() . 'protected/1.html');
+ $this->authenticate('test', 'secret');
+ $this->clickLink('2');
+ $this->assertResponse(200);
+ $this->clickLink('3');
+ $this->assertResponse(200);
+ }
+
+ function testRedirectKeepsAuthentication() {
+ $this->get($this->samples() . 'protected/local_redirect.php');
+ $this->authenticate('test', 'secret');
+ $this->assertTitle('Simple test target file');
+ }
+
+ function testRedirectKeepsEncodedAuthentication() {
+ $this->get('http://test:secret@www.lastcraft.com/test/protected/local_redirect.php');
+ $this->assertResponse(200);
+ $this->assertTitle('Simple test target file');
+ }
+
+ function testSessionRestartLosesAuthentication() {
+ $this->get($this->samples() . 'protected/');
+ $this->authenticate('test', 'secret');
+ $this->assertResponse(200);
+ $this->restart();
+ $this->get($this->samples() . 'protected/');
+ $this->assertResponse(401);
+ }
+}
+
+class TestOfLoadingFrames extends SimpleTestAcceptanceTest {
+ function setUp() {
+ $this->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ }
+
+ function testNoFramesContentWhenFramesDisabled() {
+ $this->ignoreFrames();
+ $this->get($this->samples() . 'one_page_frameset.html');
+ $this->assertTitle('Frameset for testing of SimpleTest');
+ $this->assertText('This content is for no frames only');
+ }
+
+ function testPatternMatchCanReadTheOnlyFrame() {
+ $this->get($this->samples() . 'one_page_frameset.html');
+ $this->assertText('A target for the SimpleTest test suite');
+ $this->assertNoText('This content is for no frames only');
+ }
+
+ function testMessyFramesetResponsesByName() {
+ $this->assertTrue($this->get(
+ $this->samples() . 'messy_frameset.html'));
+ $this->assertTitle('Frameset for testing of SimpleTest');
+
+ $this->assertTrue($this->setFrameFocus('Front controller'));
+ $this->assertResponse(200);
+ $this->assertText('Simple test front controller');
+
+ $this->assertTrue($this->setFrameFocus('One'));
+ $this->assertResponse(200);
+ $this->assertLink('2');
+
+ $this->assertTrue($this->setFrameFocus('Frame links'));
+ $this->assertResponse(200);
+ $this->assertLink('Set one to 2');
+
+ $this->assertTrue($this->setFrameFocus('Counter'));
+ $this->assertResponse(200);
+ $this->assertText('Count: 1');
+
+ $this->assertTrue($this->setFrameFocus('Redirected'));
+ $this->assertResponse(200);
+ $this->assertText('r=rrr');
+
+ $this->assertTrue($this->setFrameFocus('Protected'));
+ $this->assertResponse(401);
+
+ $this->assertTrue($this->setFrameFocus('Protected redirect'));
+ $this->assertResponse(401);
+
+ $this->assertTrue($this->setFrameFocusByIndex(1));
+ $this->assertResponse(200);
+ $this->assertText('Simple test front controller');
+
+ $this->assertTrue($this->setFrameFocusByIndex(2));
+ $this->assertResponse(200);
+ $this->assertLink('2');
+
+ $this->assertTrue($this->setFrameFocusByIndex(3));
+ $this->assertResponse(200);
+ $this->assertLink('Set one to 2');
+
+ $this->assertTrue($this->setFrameFocusByIndex(4));
+ $this->assertResponse(200);
+ $this->assertText('Count: 1');
+
+ $this->assertTrue($this->setFrameFocusByIndex(5));
+ $this->assertResponse(200);
+ $this->assertText('r=rrr');
+
+ $this->assertTrue($this->setFrameFocusByIndex(6));
+ $this->assertResponse(401);
+
+ $this->assertTrue($this->setFrameFocusByIndex(7));
+ }
+
+ function testReloadingFramesetPage() {
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->assertText('Count: 1');
+ $this->retry();
+ $this->assertText('Count: 2');
+ $this->retry();
+ $this->assertText('Count: 3');
+ }
+
+ function testReloadingSingleFrameWithCookieCounter() {
+ $this->get($this->samples() . 'counting_frameset.html');
+ $this->setFrameFocus('a');
+ $this->assertText('Count: 1');
+ $this->setFrameFocus('b');
+ $this->assertText('Count: 2');
+
+ $this->setFrameFocus('a');
+ $this->retry();
+ $this->assertText('Count: 3');
+ $this->retry();
+ $this->assertText('Count: 4');
+ $this->setFrameFocus('b');
+ $this->assertText('Count: 2');
+ }
+
+ function testReloadingFrameWhenUnfocusedReloadsWholeFrameset() {
+ $this->get($this->samples() . 'counting_frameset.html');
+ $this->setFrameFocus('a');
+ $this->assertText('Count: 1');
+ $this->setFrameFocus('b');
+ $this->assertText('Count: 2');
+
+ $this->clearFrameFocus('a');
+ $this->retry();
+
+ $this->assertTitle('Frameset for testing of SimpleTest');
+ $this->setFrameFocus('a');
+ $this->assertText('Count: 3');
+ $this->setFrameFocus('b');
+ $this->assertText('Count: 4');
+ }
+
+ function testClickingNormalLinkReplacesJustThatFrame() {
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->clickLink('2');
+ $this->assertLink('3');
+ $this->assertText('Simple test front controller');
+ }
+
+ function testJumpToNamedPageReplacesJustThatFrame() {
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->assertPattern('/Simple test front controller/');
+ $this->clickLink('Index');
+ $this->assertResponse(200);
+ $this->assertText('[action=index]');
+ $this->assertText('Count: 1');
+ }
+
+ function testJumpToUnnamedPageReplacesJustThatFrame() {
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->clickLink('No page');
+ $this->assertResponse(200);
+ $this->assertText('Simple test front controller');
+ $this->assertText('[action=no_page]');
+ $this->assertText('Count: 1');
+ }
+
+ function testJumpToUnnamedPageWithBareParameterReplacesJustThatFrame() {
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->clickLink('Bare action');
+ $this->assertResponse(200);
+ $this->assertText('Simple test front controller');
+ $this->assertText('[action=]');
+ $this->assertText('Count: 1');
+ }
+
+ function testJumpToUnnamedPageWithEmptyQueryReplacesJustThatFrame() {
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->clickLink('Empty query');
+ $this->assertResponse(200);
+ $this->assertPattern('/Simple test front controller/');
+ $this->assertPattern('/raw get data.*?\[\].*?get data/si');
+ $this->assertPattern('/Count: 1/');
+ }
+
+ function testJumpToUnnamedPageWithEmptyLinkReplacesJustThatFrame() {
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->clickLink('Empty link');
+ $this->assertResponse(200);
+ $this->assertPattern('/Simple test front controller/');
+ $this->assertPattern('/raw get data.*?\[\].*?get data/si');
+ $this->assertPattern('/Count: 1/');
+ }
+
+ function testJumpBackADirectoryLevelReplacesJustThatFrame() {
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->clickLink('Down one');
+ $this->assertPattern('/index of .*\/test/i');
+ $this->assertPattern('/Count: 1/');
+ }
+
+ function testSubmitToNamedPageReplacesJustThatFrame() {
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->assertPattern('/Simple test front controller/');
+ $this->clickSubmit('Index');
+ $this->assertResponse(200);
+ $this->assertText('[action=Index]');
+ $this->assertText('Count: 1');
+ }
+
+ function testSubmitToSameDirectoryReplacesJustThatFrame() {
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->clickSubmit('Same directory');
+ $this->assertResponse(200);
+ $this->assertText('[action=Same+directory]');
+ $this->assertText('Count: 1');
+ }
+
+ function testSubmitToEmptyActionReplacesJustThatFrame() {
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->clickSubmit('Empty action');
+ $this->assertResponse(200);
+ $this->assertText('[action=Empty+action]');
+ $this->assertText('Count: 1');
+ }
+
+ function testSubmitToNoActionReplacesJustThatFrame() {
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->clickSubmit('No action');
+ $this->assertResponse(200);
+ $this->assertText('[action=No+action]');
+ $this->assertText('Count: 1');
+ }
+
+ function testSubmitBackADirectoryLevelReplacesJustThatFrame() {
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->clickSubmit('Down one');
+ $this->assertPattern('/index of .*\/test/i');
+ $this->assertPattern('/Count: 1/');
+ }
+
+ function testTopLinkExitsFrameset() {
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->clickLink('Exit the frameset');
+ $this->assertTitle('Simple test target file');
+ }
+
+ function testLinkInOnePageCanLoadAnother() {
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->assertNoLink('3');
+ $this->clickLink('Set one to 2');
+ $this->assertLink('3');
+ $this->assertNoLink('2');
+ $this->assertTitle('Frameset for testing of SimpleTest');
+ }
+
+ function testFrameWithRelativeLinksRespectsBaseTagForThatPage() {
+ $this->get($this->samples() . 'base_tag/frameset.html');
+ $this->click('Back to test pages');
+ $this->assertTitle('Frameset for testing of SimpleTest');
+ $this->assertText('A target for the SimpleTest test suite');
+ }
+
+ function testRelativeLinkInFrameIsNotAffectedByFramesetBaseTag() {
+ $this->get($this->samples() . 'base_tag/frameset_with_base_tag.html');
+ $this->assertText('This is page 1');
+ $this->click('To page 2');
+ $this->assertTitle('Frameset for testing of SimpleTest');
+ $this->assertText('This is page 2');
+ }
+}
+
+class TestOfFrameAuthentication extends SimpleTestAcceptanceTest {
+ function setUp() {
+ $this->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ }
+
+ function testUnauthenticatedFrameSendsChallenge() {
+ $this->get($this->samples() . 'protected/');
+ $this->setFrameFocus('Protected');
+ $this->assertAuthentication('Basic');
+ $this->assertRealm('SimpleTest basic authentication');
+ $this->assertResponse(401);
+ }
+
+ function testCanReadFrameFromAlreadyAuthenticatedRealm() {
+ $this->get($this->samples() . 'protected/');
+ $this->authenticate('test', 'secret');
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->setFrameFocus('Protected');
+ $this->assertResponse(200);
+ $this->assertText('A target for the SimpleTest test suite');
+ }
+
+ function testCanAuthenticateFrame() {
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->setFrameFocus('Protected');
+ $this->authenticate('test', 'secret');
+ $this->assertResponse(200);
+ $this->assertText('A target for the SimpleTest test suite');
+ $this->clearFrameFocus();
+ $this->assertText('Count: 1');
+ }
+
+ function testCanAuthenticateRedirectedFrame() {
+ $this->get($this->samples() . 'messy_frameset.html');
+ $this->setFrameFocus('Protected redirect');
+ $this->assertResponse(401);
+ $this->authenticate('test', 'secret');
+ $this->assertResponse(200);
+ $this->assertText('A target for the SimpleTest test suite');
+ $this->clearFrameFocus();
+ $this->assertText('Count: 1');
+ }
+}
+
+class TestOfNestedFrames extends SimpleTestAcceptanceTest {
+ function setUp() {
+ $this->addHeader('User-Agent: SimpleTest ' . SimpleTest::getVersion());
+ }
+
+ function testCanNavigateToSpecificContent() {
+ $this->get($this->samples() . 'nested_frameset.html');
+ $this->assertTitle('Nested frameset for testing of SimpleTest');
+
+ $this->assertPattern('/This is frame A/');
+ $this->assertPattern('/This is frame B/');
+ $this->assertPattern('/Simple test front controller/');
+ $this->assertLink('2');
+ $this->assertLink('Set one to 2');
+ $this->assertPattern('/Count: 1/');
+ $this->assertPattern('/r=rrr/');
+
+ $this->setFrameFocus('pair');
+ $this->assertPattern('/This is frame A/');
+ $this->assertPattern('/This is frame B/');
+ $this->assertNoPattern('/Simple test front controller/');
+ $this->assertNoLink('2');
+
+ $this->setFrameFocus('aaa');
+ $this->assertPattern('/This is frame A/');
+ $this->assertNoPattern('/This is frame B/');
+
+ $this->clearFrameFocus();
+ $this->assertResponse(200);
+ $this->setFrameFocus('messy');
+ $this->assertResponse(200);
+ $this->setFrameFocus('Front controller');
+ $this->assertResponse(200);
+ $this->assertPattern('/Simple test front controller/');
+ $this->assertNoLink('2');
+ }
+
+ function testReloadingFramesetPage() {
+ $this->get($this->samples() . 'nested_frameset.html');
+ $this->assertPattern('/Count: 1/');
+ $this->retry();
+ $this->assertPattern('/Count: 2/');
+ $this->retry();
+ $this->assertPattern('/Count: 3/');
+ }
+
+ function testRetryingNestedPageOnlyRetriesThatSet() {
+ $this->get($this->samples() . 'nested_frameset.html');
+ $this->assertPattern('/Count: 1/');
+ $this->setFrameFocus('messy');
+ $this->retry();
+ $this->assertPattern('/Count: 2/');
+ $this->setFrameFocus('Counter');
+ $this->retry();
+ $this->assertPattern('/Count: 3/');
+
+ $this->clearFrameFocus();
+ $this->setFrameFocus('messy');
+ $this->setFrameFocus('Front controller');
+ $this->retry();
+
+ $this->clearFrameFocus();
+ $this->assertPattern('/Count: 3/');
+ }
+
+ function testAuthenticatingNestedPage() {
+ $this->get($this->samples() . 'nested_frameset.html');
+ $this->setFrameFocus('messy');
+ $this->setFrameFocus('Protected');
+ $this->assertAuthentication('Basic');
+ $this->assertRealm('SimpleTest basic authentication');
+ $this->assertResponse(401);
+
+ $this->authenticate('test', 'secret');
+ $this->assertResponse(200);
+ $this->assertPattern('/A target for the SimpleTest test suite/');
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/adapter_test.php b/vendors/simpletest/test/adapter_test.php
new file mode 100755
index 000000000..f4564ea87
--- /dev/null
+++ b/vendors/simpletest/test/adapter_test.php
@@ -0,0 +1,77 @@
+<?php
+// $Id: adapter_test.php 1505 2007-04-30 23:39:59Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../extensions/pear_test_case.php');
+require_once(dirname(__FILE__) . '/../extensions/phpunit_test_case.php');
+
+class SameTestClass {
+}
+
+class TestOfPearAdapter extends PHPUnit_TestCase {
+
+ function testBoolean() {
+ $this->assertTrue(true, "PEAR true");
+ $this->assertFalse(false, "PEAR false");
+ }
+
+ function testName() {
+ $this->assertTrue($this->getName() == get_class($this));
+ }
+
+ function testPass() {
+ $this->pass("PEAR pass");
+ }
+
+ function testNulls() {
+ $value = null;
+ $this->assertNull($value, "PEAR null");
+ $value = 0;
+ $this->assertNotNull($value, "PEAR not null");
+ }
+
+ function testType() {
+ $this->assertType("Hello", "string", "PEAR type");
+ }
+
+ function testEquals() {
+ $this->assertEquals(12, 12, "PEAR identity");
+ $this->setLooselyTyped(true);
+ $this->assertEquals("12", 12, "PEAR equality");
+ }
+
+ function testSame() {
+ $same = &new SameTestClass();
+ $this->assertSame($same, $same, "PEAR same");
+ }
+
+ function testRegExp() {
+ $this->assertRegExp('/hello/', "A big hello from me", "PEAR regex");
+ }
+}
+
+class TestOfPhpUnitAdapter extends TestCase {
+ function TestOfPhpUnitAdapter() {
+ $this->TestCase('TestOfPhpUnitAdapter');
+ }
+
+ function testBoolean() {
+ $this->assert(true, 'PHP Unit true');
+ }
+
+ function testName() {
+ $this->assert($this->name() == 'TestOfPhpUnitAdapter');
+ }
+
+ function testEquals() {
+ $this->assertEquals(12, 12, 'PHP Unit equality');
+ }
+
+ function testMultilineEquals() {
+ $this->assertEquals("a\nb\n", "a\nb\n", 'PHP Unit equality');
+ }
+
+ function testRegExp() {
+ $this->assertRegexp('/hello/', 'A big hello from me', 'PHPUnit regex');
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/all_tests.php b/vendors/simpletest/test/all_tests.php
new file mode 100755
index 000000000..99ce9451e
--- /dev/null
+++ b/vendors/simpletest/test/all_tests.php
@@ -0,0 +1,13 @@
+<?php
+require_once(dirname(__FILE__) . '/../autorun.php');
+
+class AllTests extends TestSuite {
+ function AllTests() {
+ $this->TestSuite('All tests for SimpleTest ' . SimpleTest::getVersion());
+ $this->addFile(dirname(__FILE__) . '/unit_tests.php');
+ $this->addFile(dirname(__FILE__) . '/shell_test.php');
+ $this->addFile(dirname(__FILE__) . '/live_test.php');
+ $this->addFile(dirname(__FILE__) . '/acceptance_test.php');
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/authentication_test.php b/vendors/simpletest/test/authentication_test.php
new file mode 100755
index 000000000..8573eddc8
--- /dev/null
+++ b/vendors/simpletest/test/authentication_test.php
@@ -0,0 +1,145 @@
+<?php
+// $Id: authentication_test.php 1505 2007-04-30 23:39:59Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../authentication.php');
+require_once(dirname(__FILE__) . '/../http.php');
+Mock::generate('SimpleHttpRequest');
+
+class TestOfRealm extends UnitTestCase {
+
+ function testWithinSameUrl() {
+ $realm = &new SimpleRealm(
+ 'Basic',
+ new SimpleUrl('http://www.here.com/path/hello.html'));
+ $this->assertTrue($realm->isWithin(
+ new SimpleUrl('http://www.here.com/path/hello.html')));
+ }
+
+ function testInsideWithLongerUrl() {
+ $realm = &new SimpleRealm(
+ 'Basic',
+ new SimpleUrl('http://www.here.com/path/'));
+ $this->assertTrue($realm->isWithin(
+ new SimpleUrl('http://www.here.com/path/hello.html')));
+ }
+
+ function testBelowRootIsOutside() {
+ $realm = &new SimpleRealm(
+ 'Basic',
+ new SimpleUrl('http://www.here.com/path/'));
+ $this->assertTrue($realm->isWithin(
+ new SimpleUrl('http://www.here.com/path/more/hello.html')));
+ }
+
+ function testOldNetscapeDefinitionIsOutside() {
+ $realm = &new SimpleRealm(
+ 'Basic',
+ new SimpleUrl('http://www.here.com/path/'));
+ $this->assertFalse($realm->isWithin(
+ new SimpleUrl('http://www.here.com/pathmore/hello.html')));
+ }
+
+ function testInsideWithMissingTrailingSlash() {
+ $realm = &new SimpleRealm(
+ 'Basic',
+ new SimpleUrl('http://www.here.com/path/'));
+ $this->assertTrue($realm->isWithin(
+ new SimpleUrl('http://www.here.com/path')));
+ }
+
+ function testDifferentPageNameStillInside() {
+ $realm = &new SimpleRealm(
+ 'Basic',
+ new SimpleUrl('http://www.here.com/path/hello.html'));
+ $this->assertTrue($realm->isWithin(
+ new SimpleUrl('http://www.here.com/path/goodbye.html')));
+ }
+
+ function testNewUrlInSameDirectoryDoesNotChangeRealm() {
+ $realm = &new SimpleRealm(
+ 'Basic',
+ new SimpleUrl('http://www.here.com/path/hello.html'));
+ $realm->stretch(new SimpleUrl('http://www.here.com/path/goodbye.html'));
+ $this->assertTrue($realm->isWithin(
+ new SimpleUrl('http://www.here.com/path/index.html')));
+ $this->assertFalse($realm->isWithin(
+ new SimpleUrl('http://www.here.com/index.html')));
+ }
+
+ function testNewUrlMakesRealmTheCommonPath() {
+ $realm = &new SimpleRealm(
+ 'Basic',
+ new SimpleUrl('http://www.here.com/path/here/hello.html'));
+ $realm->stretch(new SimpleUrl('http://www.here.com/path/there/goodbye.html'));
+ $this->assertTrue($realm->isWithin(
+ new SimpleUrl('http://www.here.com/path/here/index.html')));
+ $this->assertTrue($realm->isWithin(
+ new SimpleUrl('http://www.here.com/path/there/index.html')));
+ $this->assertTrue($realm->isWithin(
+ new SimpleUrl('http://www.here.com/path/index.html')));
+ $this->assertFalse($realm->isWithin(
+ new SimpleUrl('http://www.here.com/index.html')));
+ $this->assertFalse($realm->isWithin(
+ new SimpleUrl('http://www.here.com/paths/index.html')));
+ $this->assertFalse($realm->isWithin(
+ new SimpleUrl('http://www.here.com/pathindex.html')));
+ }
+}
+
+class TestOfAuthenticator extends UnitTestCase {
+
+ function testNoRealms() {
+ $request = &new MockSimpleHttpRequest();
+ $request->expectNever('addHeaderLine');
+ $authenticator = &new SimpleAuthenticator();
+ $authenticator->addHeaders($request, new SimpleUrl('http://here.com/'));
+ }
+
+ function &createSingleRealm() {
+ $authenticator = &new SimpleAuthenticator();
+ $authenticator->addRealm(
+ new SimpleUrl('http://www.here.com/path/hello.html'),
+ 'Basic',
+ 'Sanctuary');
+ $authenticator->setIdentityForRealm('www.here.com', 'Sanctuary', 'test', 'secret');
+ return $authenticator;
+ }
+
+ function testOutsideRealm() {
+ $request = &new MockSimpleHttpRequest();
+ $request->expectNever('addHeaderLine');
+ $authenticator = &$this->createSingleRealm();
+ $authenticator->addHeaders(
+ $request,
+ new SimpleUrl('http://www.here.com/hello.html'));
+ }
+
+ function testWithinRealm() {
+ $request = &new MockSimpleHttpRequest();
+ $request->expectOnce('addHeaderLine');
+ $authenticator = &$this->createSingleRealm();
+ $authenticator->addHeaders(
+ $request,
+ new SimpleUrl('http://www.here.com/path/more/hello.html'));
+ }
+
+ function testRestartingClearsRealm() {
+ $request = &new MockSimpleHttpRequest();
+ $request->expectNever('addHeaderLine');
+ $authenticator = &$this->createSingleRealm();
+ $authenticator->restartSession();
+ $authenticator->addHeaders(
+ $request,
+ new SimpleUrl('http://www.here.com/hello.html'));
+ }
+
+ function testDifferentHostIsOutsideRealm() {
+ $request = &new MockSimpleHttpRequest();
+ $request->expectNever('addHeaderLine');
+ $authenticator = &$this->createSingleRealm();
+ $authenticator->addHeaders(
+ $request,
+ new SimpleUrl('http://here.com/path/hello.html'));
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/autorun_test.php b/vendors/simpletest/test/autorun_test.php
new file mode 100755
index 000000000..76c919d6c
--- /dev/null
+++ b/vendors/simpletest/test/autorun_test.php
@@ -0,0 +1,13 @@
+<?php
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/support/test1.php');
+
+class LoadIfIncludedTestCase extends UnitTestCase {
+ function test_load_if_included() {
+ $tests = new GroupTest();
+ $tests->addFile(dirname(__FILE__) . '/support/test1.php');
+ $this->assertEqual($tests->getSize(), 1);
+ }
+}
+
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/bad_test_suite.php b/vendors/simpletest/test/bad_test_suite.php
new file mode 100755
index 000000000..b426013be
--- /dev/null
+++ b/vendors/simpletest/test/bad_test_suite.php
@@ -0,0 +1,10 @@
+<?php
+require_once(dirname(__FILE__) . '/../autorun.php');
+
+class BadTestCases extends TestSuite {
+ function BadTestCases() {
+ $this->TestSuite('Two bad test cases');
+ $this->addFile(dirname(__FILE__) . '/support/empty_test_file.php');
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/browser_test.php b/vendors/simpletest/test/browser_test.php
new file mode 100755
index 000000000..18faee8f2
--- /dev/null
+++ b/vendors/simpletest/test/browser_test.php
@@ -0,0 +1,779 @@
+<?php
+// $Id: browser_test.php 1624 2008-01-01 15:00:43Z pp11 $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../browser.php');
+require_once(dirname(__FILE__) . '/../user_agent.php');
+require_once(dirname(__FILE__) . '/../http.php');
+require_once(dirname(__FILE__) . '/../page.php');
+require_once(dirname(__FILE__) . '/../encoding.php');
+
+Mock::generate('SimpleHttpResponse');
+Mock::generate('SimplePage');
+Mock::generate('SimpleForm');
+Mock::generate('SimpleUserAgent');
+Mock::generatePartial(
+ 'SimpleBrowser',
+ 'MockParseSimpleBrowser',
+ array('_createUserAgent', '_parse'));
+Mock::generatePartial(
+ 'SimpleBrowser',
+ 'MockUserAgentSimpleBrowser',
+ array('_createUserAgent'));
+
+class TestOfHistory extends UnitTestCase {
+
+ function testEmptyHistoryHasFalseContents() {
+ $history = &new SimpleBrowserHistory();
+ $this->assertIdentical($history->getUrl(), false);
+ $this->assertIdentical($history->getParameters(), false);
+ }
+
+ function testCannotMoveInEmptyHistory() {
+ $history = &new SimpleBrowserHistory();
+ $this->assertFalse($history->back());
+ $this->assertFalse($history->forward());
+ }
+
+ function testCurrentTargetAccessors() {
+ $history = &new SimpleBrowserHistory();
+ $history->recordEntry(
+ new SimpleUrl('http://www.here.com/'),
+ new SimpleGetEncoding());
+ $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.here.com/'));
+ $this->assertIdentical($history->getParameters(), new SimpleGetEncoding());
+ }
+
+ function testSecondEntryAccessors() {
+ $history = &new SimpleBrowserHistory();
+ $history->recordEntry(
+ new SimpleUrl('http://www.first.com/'),
+ new SimpleGetEncoding());
+ $history->recordEntry(
+ new SimpleUrl('http://www.second.com/'),
+ new SimplePostEncoding(array('a' => 1)));
+ $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.second.com/'));
+ $this->assertIdentical(
+ $history->getParameters(),
+ new SimplePostEncoding(array('a' => 1)));
+ }
+
+ function testGoingBackwards() {
+ $history = &new SimpleBrowserHistory();
+ $history->recordEntry(
+ new SimpleUrl('http://www.first.com/'),
+ new SimpleGetEncoding());
+ $history->recordEntry(
+ new SimpleUrl('http://www.second.com/'),
+ new SimplePostEncoding(array('a' => 1)));
+ $this->assertTrue($history->back());
+ $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.first.com/'));
+ $this->assertIdentical($history->getParameters(), new SimpleGetEncoding());
+ }
+
+ function testGoingBackwardsOffBeginning() {
+ $history = &new SimpleBrowserHistory();
+ $history->recordEntry(
+ new SimpleUrl('http://www.first.com/'),
+ new SimpleGetEncoding());
+ $this->assertFalse($history->back());
+ $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.first.com/'));
+ $this->assertIdentical($history->getParameters(), new SimpleGetEncoding());
+ }
+
+ function testGoingForwardsOffEnd() {
+ $history = &new SimpleBrowserHistory();
+ $history->recordEntry(
+ new SimpleUrl('http://www.first.com/'),
+ new SimpleGetEncoding());
+ $this->assertFalse($history->forward());
+ $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.first.com/'));
+ $this->assertIdentical($history->getParameters(), new SimpleGetEncoding());
+ }
+
+ function testGoingBackwardsAndForwards() {
+ $history = &new SimpleBrowserHistory();
+ $history->recordEntry(
+ new SimpleUrl('http://www.first.com/'),
+ new SimpleGetEncoding());
+ $history->recordEntry(
+ new SimpleUrl('http://www.second.com/'),
+ new SimplePostEncoding(array('a' => 1)));
+ $this->assertTrue($history->back());
+ $this->assertTrue($history->forward());
+ $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.second.com/'));
+ $this->assertIdentical(
+ $history->getParameters(),
+ new SimplePostEncoding(array('a' => 1)));
+ }
+
+ function testNewEntryReplacesNextOne() {
+ $history = &new SimpleBrowserHistory();
+ $history->recordEntry(
+ new SimpleUrl('http://www.first.com/'),
+ new SimpleGetEncoding());
+ $history->recordEntry(
+ new SimpleUrl('http://www.second.com/'),
+ new SimplePostEncoding(array('a' => 1)));
+ $history->back();
+ $history->recordEntry(
+ new SimpleUrl('http://www.third.com/'),
+ new SimpleGetEncoding());
+ $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.third.com/'));
+ $this->assertIdentical($history->getParameters(), new SimpleGetEncoding());
+ }
+
+ function testNewEntryDropsFutureEntries() {
+ $history = &new SimpleBrowserHistory();
+ $history->recordEntry(
+ new SimpleUrl('http://www.first.com/'),
+ new SimpleGetEncoding());
+ $history->recordEntry(
+ new SimpleUrl('http://www.second.com/'),
+ new SimpleGetEncoding());
+ $history->recordEntry(
+ new SimpleUrl('http://www.third.com/'),
+ new SimpleGetEncoding());
+ $history->back();
+ $history->back();
+ $history->recordEntry(
+ new SimpleUrl('http://www.fourth.com/'),
+ new SimpleGetEncoding());
+ $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.fourth.com/'));
+ $this->assertFalse($history->forward());
+ $history->back();
+ $this->assertIdentical($history->getUrl(), new SimpleUrl('http://www.first.com/'));
+ $this->assertFalse($history->back());
+ }
+}
+
+class TestOfParsedPageAccess extends UnitTestCase {
+
+ function &loadPage(&$page) {
+ $response = &new MockSimpleHttpResponse($this);
+
+ $agent = &new MockSimpleUserAgent($this);
+ $agent->setReturnReference('fetchResponse', $response);
+
+ $browser = &new MockParseSimpleBrowser($this);
+ $browser->setReturnReference('_createUserAgent', $agent);
+ $browser->setReturnReference('_parse', $page);
+ $browser->SimpleBrowser();
+
+ $browser->get('http://this.com/page.html');
+ return $browser;
+ }
+
+ function testAccessorsWhenNoPage() {
+ $agent = &new MockSimpleUserAgent($this);
+
+ $browser = &new MockParseSimpleBrowser($this);
+ $browser->setReturnReference('_createUserAgent', $agent);
+ $browser->SimpleBrowser();
+
+ $this->assertEqual($browser->getContent(), '');
+ }
+
+ function testParse() {
+ $page = &new MockSimplePage();
+ $page->setReturnValue('getRequest', "GET here.html\r\n\r\n");
+ $page->setReturnValue('getRaw', 'Raw HTML');
+ $page->setReturnValue('getTitle', 'Here');
+ $page->setReturnValue('getFrameFocus', 'Frame');
+ $page->setReturnValue('getMimeType', 'text/html');
+ $page->setReturnValue('getResponseCode', 200);
+ $page->setReturnValue('getAuthentication', 'Basic');
+ $page->setReturnValue('getRealm', 'Somewhere');
+ $page->setReturnValue('getTransportError', 'Ouch!');
+
+ $browser = &$this->loadPage($page);
+
+ $this->assertEqual($browser->getRequest(), "GET here.html\r\n\r\n");
+ $this->assertEqual($browser->getContent(), 'Raw HTML');
+ $this->assertEqual($browser->getTitle(), 'Here');
+ $this->assertEqual($browser->getFrameFocus(), 'Frame');
+ $this->assertIdentical($browser->getResponseCode(), 200);
+ $this->assertEqual($browser->getMimeType(), 'text/html');
+ $this->assertEqual($browser->getAuthentication(), 'Basic');
+ $this->assertEqual($browser->getRealm(), 'Somewhere');
+ $this->assertEqual($browser->getTransportError(), 'Ouch!');
+ }
+
+ function testLinkAffirmationWhenPresent() {
+ $page = &new MockSimplePage();
+ $page->setReturnValue('getUrlsByLabel', array('http://www.nowhere.com'));
+ $page->expectOnce('getUrlsByLabel', array('a link label'));
+ $browser = &$this->loadPage($page);
+ $this->assertIdentical($browser->getLink('a link label'), 'http://www.nowhere.com');
+ }
+
+ function testLinkAffirmationByIdWhenPresent() {
+ $page = &new MockSimplePage();
+ $page->setReturnValue('getUrlById', 'a_page.com', array(99));
+ $page->setReturnValue('getUrlById', false, array('*'));
+ $browser = &$this->loadPage($page);
+ $this->assertIdentical($browser->getLinkById(99), 'a_page.com');
+ $this->assertFalse($browser->getLinkById(98));
+ }
+
+ function testSettingFieldIsPassedToPage() {
+ $page = &new MockSimplePage();
+ $page->expectOnce('setField', array(new SimpleByLabelOrName('key'), 'Value', false));
+ $page->setReturnValue('getField', 'Value');
+ $browser = &$this->loadPage($page);
+ $this->assertEqual($browser->getField('key'), 'Value');
+ $browser->setField('key', 'Value');
+ }
+}
+
+class TestOfBrowserNavigation extends UnitTestCase {
+
+ function &createBrowser(&$agent, &$page) {
+ $browser = &new MockParseSimpleBrowser();
+ $browser->setReturnReference('_createUserAgent', $agent);
+ $browser->setReturnReference('_parse', $page);
+ $browser->SimpleBrowser();
+ return $browser;
+ }
+
+ function testClickLinkRequestsPage() {
+ $agent = &new MockSimpleUserAgent();
+ $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
+ $agent->expectArgumentsAt(
+ 0,
+ 'fetchResponse',
+ array(new SimpleUrl('http://this.com/page.html'), new SimpleGetEncoding()));
+ $agent->expectArgumentsAt(
+ 1,
+ 'fetchResponse',
+ array(new SimpleUrl('http://this.com/new.html'), new SimpleGetEncoding()));
+ $agent->expectCallCount('fetchResponse', 2);
+
+ $page = &new MockSimplePage();
+ $page->setReturnValue('getUrlsByLabel', array(new SimpleUrl('http://this.com/new.html')));
+ $page->expectOnce('getUrlsByLabel', array('New'));
+ $page->setReturnValue('getRaw', 'A page');
+
+ $browser = &$this->createBrowser($agent, $page);
+ $browser->get('http://this.com/page.html');
+ $this->assertTrue($browser->clickLink('New'));
+ }
+
+ function testClickLinkWithUnknownFrameStillRequestsWholePage() {
+ $agent = &new MockSimpleUserAgent();
+ $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
+ $agent->expectArgumentsAt(
+ 0,
+ 'fetchResponse',
+ array(new SimpleUrl('http://this.com/page.html'), new SimpleGetEncoding()));
+ $target = new SimpleUrl('http://this.com/new.html');
+ $target->setTarget('missing');
+ $agent->expectArgumentsAt(
+ 1,
+ 'fetchResponse',
+ array($target, new SimpleGetEncoding()));
+ $agent->expectCallCount('fetchResponse', 2);
+
+ $parsed_url = new SimpleUrl('http://this.com/new.html');
+ $parsed_url->setTarget('missing');
+
+ $page = &new MockSimplePage();
+ $page->setReturnValue('getUrlsByLabel', array($parsed_url));
+ $page->setReturnValue('hasFrames', false);
+ $page->expectOnce('getUrlsByLabel', array('New'));
+ $page->setReturnValue('getRaw', 'A page');
+
+ $browser = &$this->createBrowser($agent, $page);
+ $browser->get('http://this.com/page.html');
+ $this->assertTrue($browser->clickLink('New'));
+ }
+
+ function testClickingMissingLinkFails() {
+ $agent = &new MockSimpleUserAgent($this);
+ $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
+
+ $page = &new MockSimplePage();
+ $page->setReturnValue('getUrlsByLabel', array());
+ $page->setReturnValue('getRaw', 'stuff');
+
+ $browser = &$this->createBrowser($agent, $page);
+ $this->assertTrue($browser->get('http://this.com/page.html'));
+ $this->assertFalse($browser->clickLink('New'));
+ }
+
+ function testClickIndexedLink() {
+ $agent = &new MockSimpleUserAgent();
+ $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
+ $agent->expectArgumentsAt(
+ 1,
+ 'fetchResponse',
+ array(new SimpleUrl('1.html'), new SimpleGetEncoding()));
+ $agent->expectCallCount('fetchResponse', 2);
+
+ $page = &new MockSimplePage();
+ $page->setReturnValue(
+ 'getUrlsByLabel',
+ array(new SimpleUrl('0.html'), new SimpleUrl('1.html')));
+ $page->setReturnValue('getRaw', 'A page');
+
+ $browser = &$this->createBrowser($agent, $page);
+ $browser->get('http://this.com/page.html');
+ $this->assertTrue($browser->clickLink('New', 1));
+ }
+
+ function testClinkLinkById() {
+ $agent = &new MockSimpleUserAgent();
+ $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
+ $agent->expectArgumentsAt(1, 'fetchResponse', array(
+ new SimpleUrl('http://this.com/link.html'),
+ new SimpleGetEncoding()));
+ $agent->expectCallCount('fetchResponse', 2);
+
+ $page = &new MockSimplePage();
+ $page->setReturnValue('getUrlById', new SimpleUrl('http://this.com/link.html'));
+ $page->expectOnce('getUrlById', array(2));
+ $page->setReturnValue('getRaw', 'A page');
+
+ $browser = &$this->createBrowser($agent, $page);
+ $browser->get('http://this.com/page.html');
+ $this->assertTrue($browser->clickLinkById(2));
+ }
+
+ function testClickingMissingLinkIdFails() {
+ $agent = &new MockSimpleUserAgent();
+ $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
+
+ $page = &new MockSimplePage();
+ $page->setReturnValue('getUrlById', false);
+
+ $browser = &$this->createBrowser($agent, $page);
+ $browser->get('http://this.com/page.html');
+ $this->assertFalse($browser->clickLink(0));
+ }
+
+ function testSubmitFormByLabel() {
+ $agent = &new MockSimpleUserAgent();
+ $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
+ $agent->expectArgumentsAt(1, 'fetchResponse', array(
+ new SimpleUrl('http://this.com/handler.html'),
+ new SimplePostEncoding(array('a' => 'A'))));
+ $agent->expectCallCount('fetchResponse', 2);
+
+ $form = &new MockSimpleForm();
+ $form->setReturnValue('getAction', new SimpleUrl('http://this.com/handler.html'));
+ $form->setReturnValue('getMethod', 'post');
+ $form->setReturnValue('submitButton', new SimplePostEncoding(array('a' => 'A')));
+ $form->expectOnce('submitButton', array(new SimpleByLabel('Go'), false));
+
+ $page = &new MockSimplePage();
+ $page->setReturnReference('getFormBySubmit', $form);
+ $page->expectOnce('getFormBySubmit', array(new SimpleByLabel('Go')));
+ $page->setReturnValue('getRaw', 'stuff');
+
+ $browser = &$this->createBrowser($agent, $page);
+ $browser->get('http://this.com/page.html');
+ $this->assertTrue($browser->clickSubmit('Go'));
+ }
+
+ function testDefaultSubmitFormByLabel() {
+ $agent = &new MockSimpleUserAgent();
+ $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
+ $agent->expectArgumentsAt(1, 'fetchResponse', array(
+ new SimpleUrl('http://this.com/page.html'),
+ new SimpleGetEncoding(array('a' => 'A'))));
+ $agent->expectCallCount('fetchResponse', 2);
+
+ $form = &new MockSimpleForm();
+ $form->setReturnValue('getAction', new SimpleUrl('http://this.com/page.html'));
+ $form->setReturnValue('getMethod', 'get');
+ $form->setReturnValue('submitButton', new SimpleGetEncoding(array('a' => 'A')));
+
+ $page = &new MockSimplePage();
+ $page->setReturnReference('getFormBySubmit', $form);
+ $page->expectOnce('getFormBySubmit', array(new SimpleByLabel('Submit')));
+ $page->setReturnValue('getRaw', 'stuff');
+ $page->setReturnValue('getUrl', new SimpleUrl('http://this.com/page.html'));
+
+ $browser = &$this->createBrowser($agent, $page);
+ $browser->get('http://this.com/page.html');
+ $this->assertTrue($browser->clickSubmit());
+ }
+
+ function testSubmitFormByName() {
+ $agent = &new MockSimpleUserAgent();
+ $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
+
+ $form = &new MockSimpleForm();
+ $form->setReturnValue('getAction', new SimpleUrl('http://this.com/handler.html'));
+ $form->setReturnValue('getMethod', 'post');
+ $form->setReturnValue('submitButton', new SimplePostEncoding(array('a' => 'A')));
+
+ $page = &new MockSimplePage();
+ $page->setReturnReference('getFormBySubmit', $form);
+ $page->expectOnce('getFormBySubmit', array(new SimpleByName('me')));
+ $page->setReturnValue('getRaw', 'stuff');
+
+ $browser = &$this->createBrowser($agent, $page);
+ $browser->get('http://this.com/page.html');
+ $this->assertTrue($browser->clickSubmitByName('me'));
+ }
+
+ function testSubmitFormById() {
+ $agent = &new MockSimpleUserAgent();
+ $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
+
+ $form = &new MockSimpleForm();
+ $form->setReturnValue('getAction', new SimpleUrl('http://this.com/handler.html'));
+ $form->setReturnValue('getMethod', 'post');
+ $form->setReturnValue('submitButton', new SimplePostEncoding(array('a' => 'A')));
+ $form->expectOnce('submitButton', array(new SimpleById(99), false));
+
+ $page = &new MockSimplePage();
+ $page->setReturnReference('getFormBySubmit', $form);
+ $page->expectOnce('getFormBySubmit', array(new SimpleById(99)));
+ $page->setReturnValue('getRaw', 'stuff');
+
+ $browser = &$this->createBrowser($agent, $page);
+ $browser->get('http://this.com/page.html');
+ $this->assertTrue($browser->clickSubmitById(99));
+ }
+
+ function testSubmitFormByImageLabel() {
+ $agent = &new MockSimpleUserAgent();
+ $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
+
+ $form = &new MockSimpleForm();
+ $form->setReturnValue('getAction', new SimpleUrl('http://this.com/handler.html'));
+ $form->setReturnValue('getMethod', 'post');
+ $form->setReturnValue('submitImage', new SimplePostEncoding(array('a' => 'A')));
+ $form->expectOnce('submitImage', array(new SimpleByLabel('Go!'), 10, 11, false));
+
+ $page = &new MockSimplePage();
+ $page->setReturnReference('getFormByImage', $form);
+ $page->expectOnce('getFormByImage', array(new SimpleByLabel('Go!')));
+ $page->setReturnValue('getRaw', 'stuff');
+
+ $browser = &$this->createBrowser($agent, $page);
+ $browser->get('http://this.com/page.html');
+ $this->assertTrue($browser->clickImage('Go!', 10, 11));
+ }
+
+ function testSubmitFormByImageName() {
+ $agent = &new MockSimpleUserAgent();
+ $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
+
+ $form = &new MockSimpleForm();
+ $form->setReturnValue('getAction', new SimpleUrl('http://this.com/handler.html'));
+ $form->setReturnValue('getMethod', 'post');
+ $form->setReturnValue('submitImage', new SimplePostEncoding(array('a' => 'A')));
+ $form->expectOnce('submitImage', array(new SimpleByName('a'), 10, 11, false));
+
+ $page = &new MockSimplePage();
+ $page->setReturnReference('getFormByImage', $form);
+ $page->expectOnce('getFormByImage', array(new SimpleByName('a')));
+ $page->setReturnValue('getRaw', 'stuff');
+
+ $browser = &$this->createBrowser($agent, $page);
+ $browser->get('http://this.com/page.html');
+ $this->assertTrue($browser->clickImageByName('a', 10, 11));
+ }
+
+ function testSubmitFormByImageId() {
+ $agent = &new MockSimpleUserAgent();
+ $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
+
+ $form = &new MockSimpleForm();
+ $form->setReturnValue('getAction', new SimpleUrl('http://this.com/handler.html'));
+ $form->setReturnValue('getMethod', 'post');
+ $form->setReturnValue('submitImage', new SimplePostEncoding(array('a' => 'A')));
+ $form->expectOnce('submitImage', array(new SimpleById(99), 10, 11, false));
+
+ $page = &new MockSimplePage();
+ $page->setReturnReference('getFormByImage', $form);
+ $page->expectOnce('getFormByImage', array(new SimpleById(99)));
+ $page->setReturnValue('getRaw', 'stuff');
+
+ $browser = &$this->createBrowser($agent, $page);
+ $browser->get('http://this.com/page.html');
+ $this->assertTrue($browser->clickImageById(99, 10, 11));
+ }
+
+ function testSubmitFormByFormId() {
+ $agent = &new MockSimpleUserAgent();
+ $agent->setReturnReference('fetchResponse', new MockSimpleHttpResponse());
+ $agent->expectArgumentsAt(1, 'fetchResponse', array(
+ new SimpleUrl('http://this.com/handler.html'),
+ new SimplePostEncoding(array('a' => 'A'))));
+ $agent->expectCallCount('fetchResponse', 2);
+
+ $form = &new MockSimpleForm();
+ $form->setReturnValue('getAction', new SimpleUrl('http://this.com/handler.html'));
+ $form->setReturnValue('getMethod', 'post');
+ $form->setReturnValue('submit', new SimplePostEncoding(array('a' => 'A')));
+
+ $page = &new MockSimplePage();
+ $page->setReturnReference('getFormById', $form);
+ $page->expectOnce('getFormById', array(33));
+ $page->setReturnValue('getRaw', 'stuff');
+
+ $browser = &$this->createBrowser($agent, $page);
+ $browser->get('http://this.com/page.html');
+ $this->assertTrue($browser->submitFormById(33));
+ }
+}
+
+class TestOfBrowserFrames extends UnitTestCase {
+
+ function &createBrowser(&$agent) {
+ $browser = &new MockUserAgentSimpleBrowser();
+ $browser->setReturnReference('_createUserAgent', $agent);
+ $browser->SimpleBrowser();
+ return $browser;
+ }
+
+ function &createUserAgent($pages) {
+ $agent = &new MockSimpleUserAgent();
+ foreach ($pages as $url => $raw) {
+ $url = new SimpleUrl($url);
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getUrl', $url);
+ $response->setReturnValue('getContent', $raw);
+ $agent->setReturnReference('fetchResponse', $response, array($url, '*'));
+ }
+ return $agent;
+ }
+
+ function testSimplePageHasNoFrames() {
+ $browser = &$this->createBrowser($this->createUserAgent(
+ array('http://site.with.no.frames/' => 'A non-framed page')));
+ $this->assertEqual(
+ $browser->get('http://site.with.no.frames/'),
+ 'A non-framed page');
+ $this->assertIdentical($browser->getFrames(), 'http://site.with.no.frames/');
+ }
+
+ function testFramesetWithNoFrames() {
+ $browser = &$this->createBrowser($this->createUserAgent(
+ array('http://site.with.no.frames/' => '<frameset></frameset>')));
+ $this->assertEqual($browser->get('http://site.with.no.frames/'), '');
+ $this->assertIdentical($browser->getFrames(), array());
+ }
+
+ function testFramesetWithSingleFrame() {
+ $frameset = '<frameset><frame name="a" src="frame.html"></frameset>';
+ $browser = &$this->createBrowser($this->createUserAgent(array(
+ 'http://site.with.one.frame/' => $frameset,
+ 'http://site.with.one.frame/frame.html' => 'A frame')));
+ $this->assertEqual($browser->get('http://site.with.one.frame/'), 'A frame');
+ $this->assertIdentical(
+ $browser->getFrames(),
+ array('a' => 'http://site.with.one.frame/frame.html'));
+ }
+
+ function testTitleTakenFromFramesetPage() {
+ $frameset = '<title>Frameset title</title>' .
+ '<frameset><frame name="a" src="frame.html"></frameset>';
+ $browser = &$this->createBrowser($this->createUserAgent(array(
+ 'http://site.with.one.frame/' => $frameset,
+ 'http://site.with.one.frame/frame.html' => '<title>Page title</title>')));
+ $browser->get('http://site.with.one.frame/');
+ $this->assertEqual($browser->getTitle(), 'Frameset title');
+ }
+
+ function testFramesetWithSingleUnnamedFrame() {
+ $frameset = '<frameset><frame src="frame.html"></frameset>';
+ $browser = &$this->createBrowser($this->createUserAgent(array(
+ 'http://site.with.one.frame/' => $frameset,
+ 'http://site.with.one.frame/frame.html' => 'One frame')));
+ $this->assertEqual(
+ $browser->get('http://site.with.one.frame/'),
+ 'One frame');
+ $this->assertIdentical(
+ $browser->getFrames(),
+ array(1 => 'http://site.with.one.frame/frame.html'));
+ }
+
+ function testFramesetWithMultipleFrames() {
+ $frameset = '<frameset>' .
+ '<frame name="a" src="frame_a.html">' .
+ '<frame name="b" src="frame_b.html">' .
+ '<frame name="c" src="frame_c.html">' .
+ '</frameset>';
+ $browser = &$this->createBrowser($this->createUserAgent(array(
+ 'http://site.with.frames/' => $frameset,
+ 'http://site.with.frames/frame_a.html' => 'A frame',
+ 'http://site.with.frames/frame_b.html' => 'B frame',
+ 'http://site.with.frames/frame_c.html' => 'C frame')));
+ $this->assertEqual(
+ $browser->get('http://site.with.frames/'),
+ 'A frameB frameC frame');
+ $this->assertIdentical($browser->getFrames(), array(
+ 'a' => 'http://site.with.frames/frame_a.html',
+ 'b' => 'http://site.with.frames/frame_b.html',
+ 'c' => 'http://site.with.frames/frame_c.html'));
+ }
+
+ function testFrameFocusByName() {
+ $frameset = '<frameset>' .
+ '<frame name="a" src="frame_a.html">' .
+ '<frame name="b" src="frame_b.html">' .
+ '<frame name="c" src="frame_c.html">' .
+ '</frameset>';
+ $browser = &$this->createBrowser($this->createUserAgent(array(
+ 'http://site.with.frames/' => $frameset,
+ 'http://site.with.frames/frame_a.html' => 'A frame',
+ 'http://site.with.frames/frame_b.html' => 'B frame',
+ 'http://site.with.frames/frame_c.html' => 'C frame')));
+ $browser->get('http://site.with.frames/');
+ $browser->setFrameFocus('a');
+ $this->assertEqual($browser->getContent(), 'A frame');
+ $browser->setFrameFocus('b');
+ $this->assertEqual($browser->getContent(), 'B frame');
+ $browser->setFrameFocus('c');
+ $this->assertEqual($browser->getContent(), 'C frame');
+ }
+
+ function testFramesetWithSomeNamedFrames() {
+ $frameset = '<frameset>' .
+ '<frame name="a" src="frame_a.html">' .
+ '<frame src="frame_b.html">' .
+ '<frame name="c" src="frame_c.html">' .
+ '<frame src="frame_d.html">' .
+ '</frameset>';
+ $browser = &$this->createBrowser($this->createUserAgent(array(
+ 'http://site.with.frames/' => $frameset,
+ 'http://site.with.frames/frame_a.html' => 'A frame',
+ 'http://site.with.frames/frame_b.html' => 'B frame',
+ 'http://site.with.frames/frame_c.html' => 'C frame',
+ 'http://site.with.frames/frame_d.html' => 'D frame')));
+ $this->assertEqual(
+ $browser->get('http://site.with.frames/'),
+ 'A frameB frameC frameD frame');
+ $this->assertIdentical($browser->getFrames(), array(
+ 'a' => 'http://site.with.frames/frame_a.html',
+ 2 => 'http://site.with.frames/frame_b.html',
+ 'c' => 'http://site.with.frames/frame_c.html',
+ 4 => 'http://site.with.frames/frame_d.html'));
+ }
+
+ function testFrameFocusWithMixedNamesAndIndexes() {
+ $frameset = '<frameset>' .
+ '<frame name="a" src="frame_a.html">' .
+ '<frame src="frame_b.html">' .
+ '<frame name="c" src="frame_c.html">' .
+ '<frame src="frame_d.html">' .
+ '</frameset>';
+ $browser = &$this->createBrowser($this->createUserAgent(array(
+ 'http://site.with.frames/' => $frameset,
+ 'http://site.with.frames/frame_a.html' => 'A frame',
+ 'http://site.with.frames/frame_b.html' => 'B frame',
+ 'http://site.with.frames/frame_c.html' => 'C frame',
+ 'http://site.with.frames/frame_d.html' => 'D frame')));
+ $browser->get('http://site.with.frames/');
+ $browser->setFrameFocus('a');
+ $this->assertEqual($browser->getContent(), 'A frame');
+ $browser->setFrameFocus(2);
+ $this->assertEqual($browser->getContent(), 'B frame');
+ $browser->setFrameFocus('c');
+ $this->assertEqual($browser->getContent(), 'C frame');
+ $browser->setFrameFocus(4);
+ $this->assertEqual($browser->getContent(), 'D frame');
+ $browser->clearFrameFocus();
+ $this->assertEqual($browser->getContent(), 'A frameB frameC frameD frame');
+ }
+
+ function testNestedFrameset() {
+ $inner = '<frameset>' .
+ '<frame name="page" src="page.html">' .
+ '</frameset>';
+ $outer = '<frameset>' .
+ '<frame name="inner" src="inner.html">' .
+ '</frameset>';
+ $browser = &$this->createBrowser($this->createUserAgent(array(
+ 'http://site.with.nested.frame/' => $outer,
+ 'http://site.with.nested.frame/inner.html' => $inner,
+ 'http://site.with.nested.frame/page.html' => 'The page')));
+ $this->assertEqual(
+ $browser->get('http://site.with.nested.frame/'),
+ 'The page');
+ $this->assertIdentical($browser->getFrames(), array(
+ 'inner' => array(
+ 'page' => 'http://site.with.nested.frame/page.html')));
+ }
+
+ function testCanNavigateToNestedFrame() {
+ $inner = '<frameset>' .
+ '<frame name="one" src="one.html">' .
+ '<frame name="two" src="two.html">' .
+ '</frameset>';
+ $outer = '<frameset>' .
+ '<frame name="inner" src="inner.html">' .
+ '<frame name="three" src="three.html">' .
+ '</frameset>';
+ $browser = &$this->createBrowser($this->createUserAgent(array(
+ 'http://site.with.nested.frames/' => $outer,
+ 'http://site.with.nested.frames/inner.html' => $inner,
+ 'http://site.with.nested.frames/one.html' => 'Page one',
+ 'http://site.with.nested.frames/two.html' => 'Page two',
+ 'http://site.with.nested.frames/three.html' => 'Page three')));
+
+ $browser->get('http://site.with.nested.frames/');
+ $this->assertEqual($browser->getContent(), 'Page onePage twoPage three');
+
+ $this->assertTrue($browser->setFrameFocus('inner'));
+ $this->assertEqual($browser->getFrameFocus(), array('inner'));
+ $this->assertTrue($browser->setFrameFocus('one'));
+ $this->assertEqual($browser->getFrameFocus(), array('inner', 'one'));
+ $this->assertEqual($browser->getContent(), 'Page one');
+
+ $this->assertTrue($browser->setFrameFocus('two'));
+ $this->assertEqual($browser->getFrameFocus(), array('inner', 'two'));
+ $this->assertEqual($browser->getContent(), 'Page two');
+
+ $browser->clearFrameFocus();
+ $this->assertTrue($browser->setFrameFocus('three'));
+ $this->assertEqual($browser->getFrameFocus(), array('three'));
+ $this->assertEqual($browser->getContent(), 'Page three');
+
+ $this->assertTrue($browser->setFrameFocus('inner'));
+ $this->assertEqual($browser->getContent(), 'Page onePage two');
+ }
+
+ function testCanNavigateToNestedFrameByIndex() {
+ $inner = '<frameset>' .
+ '<frame src="one.html">' .
+ '<frame src="two.html">' .
+ '</frameset>';
+ $outer = '<frameset>' .
+ '<frame src="inner.html">' .
+ '<frame src="three.html">' .
+ '</frameset>';
+ $browser = &$this->createBrowser($this->createUserAgent(array(
+ 'http://site.with.nested.frames/' => $outer,
+ 'http://site.with.nested.frames/inner.html' => $inner,
+ 'http://site.with.nested.frames/one.html' => 'Page one',
+ 'http://site.with.nested.frames/two.html' => 'Page two',
+ 'http://site.with.nested.frames/three.html' => 'Page three')));
+
+ $browser->get('http://site.with.nested.frames/');
+ $this->assertEqual($browser->getContent(), 'Page onePage twoPage three');
+
+ $this->assertTrue($browser->setFrameFocusByIndex(1));
+ $this->assertEqual($browser->getFrameFocus(), array(1));
+ $this->assertTrue($browser->setFrameFocusByIndex(1));
+ $this->assertEqual($browser->getFrameFocus(), array(1, 1));
+ $this->assertEqual($browser->getContent(), 'Page one');
+
+ $this->assertTrue($browser->setFrameFocusByIndex(2));
+ $this->assertEqual($browser->getFrameFocus(), array(1, 2));
+ $this->assertEqual($browser->getContent(), 'Page two');
+
+ $browser->clearFrameFocus();
+ $this->assertTrue($browser->setFrameFocusByIndex(2));
+ $this->assertEqual($browser->getFrameFocus(), array(2));
+ $this->assertEqual($browser->getContent(), 'Page three');
+
+ $this->assertTrue($browser->setFrameFocusByIndex(1));
+ $this->assertEqual($browser->getContent(), 'Page onePage two');
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/collector_test.php b/vendors/simpletest/test/collector_test.php
new file mode 100755
index 000000000..803974c73
--- /dev/null
+++ b/vendors/simpletest/test/collector_test.php
@@ -0,0 +1,51 @@
+<?php
+// $Id: collector_test.php 1505 2007-04-30 23:39:59Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../collector.php');
+SimpleTest::ignore('MockTestSuite');
+Mock::generate('TestSuite');
+
+class PathEqualExpectation extends EqualExpectation {
+ function PathEqualExpectation($value, $message = '%s') {
+ $this->EqualExpectation(str_replace("\\", '/', $value), $message);
+ }
+
+ function test($compare) {
+ return parent::test(str_replace("\\", '/', $compare));
+ }
+}
+
+class TestOfCollector extends UnitTestCase {
+
+ function testCollectionIsAddedToGroup() {
+ $suite = &new MockTestSuite();
+ $suite->expectMinimumCallCount('addTestFile', 2);
+ $suite->expectArguments(
+ 'addTestFile',
+ array(new PatternExpectation('/collectable\\.(1|2)$/')));
+ $collector = &new SimpleCollector();
+ $collector->collect($suite, dirname(__FILE__) . '/support/collector/');
+ }
+}
+
+class TestOfPatternCollector extends UnitTestCase {
+
+ function testAddingEverythingToGroup() {
+ $suite = &new MockTestSuite();
+ $suite->expectCallCount('addTestFile', 2);
+ $suite->expectArguments(
+ 'addTestFile',
+ array(new PatternExpectation('/collectable\\.(1|2)$/')));
+ $collector = &new SimplePatternCollector('/.*/');
+ $collector->collect($suite, dirname(__FILE__) . '/support/collector/');
+ }
+
+ function testOnlyMatchedFilesAreAddedToGroup() {
+ $suite = &new MockTestSuite();
+ $suite->expectOnce('addTestFile', array(new PathEqualExpectation(
+ dirname(__FILE__) . '/support/collector/collectable.1')));
+ $collector = &new SimplePatternCollector('/1$/');
+ $collector->collect($suite, dirname(__FILE__) . '/support/collector/');
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/command_line_test.php b/vendors/simpletest/test/command_line_test.php
new file mode 100755
index 000000000..5baabff33
--- /dev/null
+++ b/vendors/simpletest/test/command_line_test.php
@@ -0,0 +1,40 @@
+<?php
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../default_reporter.php');
+
+class TestOfCommandLineParsing extends UnitTestCase {
+
+ function testDefaultsToEmptyStringToMeanNullToTheSelectiveReporter() {
+ $parser = new SimpleCommandLineParser(array());
+ $this->assertIdentical($parser->getTest(), '');
+ $this->assertIdentical($parser->getTestCase(), '');
+ }
+
+ function testNotXmlByDefault() {
+ $parser = new SimpleCommandLineParser(array());
+ $this->assertFalse($parser->isXml());
+ }
+
+ function testCanDetectRequestForXml() {
+ $parser = new SimpleCommandLineParser(array('--xml'));
+ $this->assertTrue($parser->isXml());
+ }
+
+ function testCanReadAssignmentSyntax() {
+ $parser = new SimpleCommandLineParser(array('--test=myTest'));
+ $this->assertEqual($parser->getTest(), 'myTest');
+ }
+
+ function testCanReadFollowOnSyntax() {
+ $parser = new SimpleCommandLineParser(array('--test', 'myTest'));
+ $this->assertEqual($parser->getTest(), 'myTest');
+ }
+
+ function testCanReadShortForms() {
+ $parser = new SimpleCommandLineParser(array('-t', 'myTest', '-c', 'MyClass', '-x'));
+ $this->assertEqual($parser->getTest(), 'myTest');
+ $this->assertEqual($parser->getTestCase(), 'MyClass');
+ $this->assertTrue($parser->isXml());
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/compatibility_test.php b/vendors/simpletest/test/compatibility_test.php
new file mode 100755
index 000000000..ea48f8396
--- /dev/null
+++ b/vendors/simpletest/test/compatibility_test.php
@@ -0,0 +1,97 @@
+<?php
+// $Id: compatibility_test.php 1505 2007-04-30 23:39:59Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../compatibility.php');
+
+class ComparisonClass {
+}
+
+class ComparisonSubclass extends ComparisonClass {
+}
+
+if (version_compare(phpversion(), '5') >= 0) {
+ eval('interface ComparisonInterface { }');
+ eval('class ComparisonClassWithInterface implements ComparisonInterface { }');
+}
+
+class TestOfCompatibility extends UnitTestCase {
+
+ function testIsA() {
+ $this->assertTrue(SimpleTestCompatibility::isA(
+ new ComparisonClass(),
+ 'ComparisonClass'));
+ $this->assertFalse(SimpleTestCompatibility::isA(
+ new ComparisonClass(),
+ 'ComparisonSubclass'));
+ $this->assertTrue(SimpleTestCompatibility::isA(
+ new ComparisonSubclass(),
+ 'ComparisonClass'));
+ }
+
+ function testIdentityOfNumericStrings() {
+ $numericString1 = "123";
+ $numericString2 = "00123";
+ $this->assertNotIdentical($numericString1, $numericString2);
+ }
+
+ function testIdentityOfObjects() {
+ $object1 = new ComparisonClass();
+ $object2 = new ComparisonClass();
+ $this->assertIdentical($object1, $object2);
+ }
+
+ function testReferences () {
+ $thing = "Hello";
+ $thing_reference = &$thing;
+ $thing_copy = $thing;
+ $this->assertTrue(SimpleTestCompatibility::isReference(
+ $thing,
+ $thing));
+ $this->assertTrue(SimpleTestCompatibility::isReference(
+ $thing,
+ $thing_reference));
+ $this->assertFalse(SimpleTestCompatibility::isReference(
+ $thing,
+ $thing_copy));
+ }
+
+ function testObjectReferences () {
+ $object = &new ComparisonClass();
+ $object_reference = &$object;
+ $object_copy = new ComparisonClass();
+ $object_assignment = $object;
+ $this->assertTrue(SimpleTestCompatibility::isReference(
+ $object,
+ $object));
+ $this->assertTrue(SimpleTestCompatibility::isReference(
+ $object,
+ $object_reference));
+ $this->assertFalse(SimpleTestCompatibility::isReference(
+ $object,
+ $object_copy));
+ if (version_compare(phpversion(), '5', '>=')) {
+ $this->assertTrue(SimpleTestCompatibility::isReference(
+ $object,
+ $object_assignment));
+ } else {
+ $this->assertFalse(SimpleTestCompatibility::isReference(
+ $object,
+ $object_assignment));
+ }
+ }
+
+ function testInteraceComparison() {
+ if (version_compare(phpversion(), '5', '<')) {
+ return;
+ }
+
+ $object = new ComparisonClassWithInterface();
+ $this->assertFalse(SimpleTestCompatibility::isA(
+ new ComparisonClass(),
+ 'ComparisonInterface'));
+ $this->assertTrue(SimpleTestCompatibility::isA(
+ new ComparisonClassWithInterface(),
+ 'ComparisonInterface'));
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/cookies_test.php b/vendors/simpletest/test/cookies_test.php
new file mode 100755
index 000000000..0b49e43bf
--- /dev/null
+++ b/vendors/simpletest/test/cookies_test.php
@@ -0,0 +1,227 @@
+<?php
+// $Id: cookies_test.php 1506 2007-05-07 00:58:03Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../cookies.php');
+
+class TestOfCookie extends UnitTestCase {
+
+ function testCookieDefaults() {
+ $cookie = new SimpleCookie("name");
+ $this->assertFalse($cookie->getValue());
+ $this->assertEqual($cookie->getPath(), "/");
+ $this->assertIdentical($cookie->getHost(), false);
+ $this->assertFalse($cookie->getExpiry());
+ $this->assertFalse($cookie->isSecure());
+ }
+
+ function testCookieAccessors() {
+ $cookie = new SimpleCookie(
+ "name",
+ "value",
+ "/path",
+ "Mon, 18 Nov 2002 15:50:29 GMT",
+ true);
+ $this->assertEqual($cookie->getName(), "name");
+ $this->assertEqual($cookie->getValue(), "value");
+ $this->assertEqual($cookie->getPath(), "/path/");
+ $this->assertEqual($cookie->getExpiry(), "Mon, 18 Nov 2002 15:50:29 GMT");
+ $this->assertTrue($cookie->isSecure());
+ }
+
+ function testFullHostname() {
+ $cookie = new SimpleCookie("name");
+ $this->assertTrue($cookie->setHost("host.name.here"));
+ $this->assertEqual($cookie->getHost(), "host.name.here");
+ $this->assertTrue($cookie->setHost("host.com"));
+ $this->assertEqual($cookie->getHost(), "host.com");
+ }
+
+ function testHostTruncation() {
+ $cookie = new SimpleCookie("name");
+ $cookie->setHost("this.host.name.here");
+ $this->assertEqual($cookie->getHost(), "host.name.here");
+ $cookie->setHost("this.host.com");
+ $this->assertEqual($cookie->getHost(), "host.com");
+ $this->assertTrue($cookie->setHost("dashes.in-host.com"));
+ $this->assertEqual($cookie->getHost(), "in-host.com");
+ }
+
+ function testBadHosts() {
+ $cookie = new SimpleCookie("name");
+ $this->assertFalse($cookie->setHost("gibberish"));
+ $this->assertFalse($cookie->setHost("host.here"));
+ $this->assertFalse($cookie->setHost("host..com"));
+ $this->assertFalse($cookie->setHost("..."));
+ $this->assertFalse($cookie->setHost("host.com."));
+ }
+
+ function testHostValidity() {
+ $cookie = new SimpleCookie("name");
+ $cookie->setHost("this.host.name.here");
+ $this->assertTrue($cookie->isValidHost("host.name.here"));
+ $this->assertTrue($cookie->isValidHost("that.host.name.here"));
+ $this->assertFalse($cookie->isValidHost("bad.host"));
+ $this->assertFalse($cookie->isValidHost("nearly.name.here"));
+ }
+
+ function testPathValidity() {
+ $cookie = new SimpleCookie("name", "value", "/path");
+ $this->assertFalse($cookie->isValidPath("/"));
+ $this->assertTrue($cookie->isValidPath("/path/"));
+ $this->assertTrue($cookie->isValidPath("/path/more"));
+ }
+
+ function testSessionExpiring() {
+ $cookie = new SimpleCookie("name", "value", "/path");
+ $this->assertTrue($cookie->isExpired(0));
+ }
+
+ function testTimestampExpiry() {
+ $cookie = new SimpleCookie("name", "value", "/path", 456);
+ $this->assertFalse($cookie->isExpired(0));
+ $this->assertTrue($cookie->isExpired(457));
+ $this->assertFalse($cookie->isExpired(455));
+ }
+
+ function testDateExpiry() {
+ $cookie = new SimpleCookie(
+ "name",
+ "value",
+ "/path",
+ "Mon, 18 Nov 2002 15:50:29 GMT");
+ $this->assertTrue($cookie->isExpired("Mon, 18 Nov 2002 15:50:30 GMT"));
+ $this->assertFalse($cookie->isExpired("Mon, 18 Nov 2002 15:50:28 GMT"));
+ }
+
+ function testAging() {
+ $cookie = new SimpleCookie("name", "value", "/path", 200);
+ $cookie->agePrematurely(199);
+ $this->assertFalse($cookie->isExpired(0));
+ $cookie->agePrematurely(2);
+ $this->assertTrue($cookie->isExpired(0));
+ }
+}
+
+class TestOfCookieJar extends UnitTestCase {
+
+ function testAddCookie() {
+ $jar = new SimpleCookieJar();
+ $jar->setCookie("a", "A");
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/')), array('a=A'));
+ }
+
+ function testHostFilter() {
+ $jar = new SimpleCookieJar();
+ $jar->setCookie('a', 'A', 'my-host.com');
+ $jar->setCookie('b', 'B', 'another-host.com');
+ $jar->setCookie('c', 'C');
+ $this->assertEqual(
+ $jar->selectAsPairs(new SimpleUrl('my-host.com')),
+ array('a=A', 'c=C'));
+ $this->assertEqual(
+ $jar->selectAsPairs(new SimpleUrl('another-host.com')),
+ array('b=B', 'c=C'));
+ $this->assertEqual(
+ $jar->selectAsPairs(new SimpleUrl('www.another-host.com')),
+ array('b=B', 'c=C'));
+ $this->assertEqual(
+ $jar->selectAsPairs(new SimpleUrl('new-host.org')),
+ array('c=C'));
+ $this->assertEqual(
+ $jar->selectAsPairs(new SimpleUrl('/')),
+ array('a=A', 'b=B', 'c=C'));
+ }
+
+ function testPathFilter() {
+ $jar = new SimpleCookieJar();
+ $jar->setCookie('a', 'A', false, '/path/');
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/')), array());
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/elsewhere')), array());
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/path/')), array('a=A'));
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/path')), array('a=A'));
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/pa')), array());
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/path/here')), array('a=A'));
+ }
+
+ function testPathFilterDeeply() {
+ $jar = new SimpleCookieJar();
+ $jar->setCookie('a', 'A', false, '/path/more_path/');
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/path/')), array());
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/path')), array());
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/pa')), array());
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/path/more_path/')), array('a=A'));
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/path/more_path/and_more')), array('a=A'));
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/path/not_here/')), array());
+ }
+
+ function testMultipleCookieWithDifferentPathsButSameName() {
+ $jar = new SimpleCookieJar();
+ $jar->setCookie('a', 'abc', false, '/');
+ $jar->setCookie('a', '123', false, '/path/here/');
+ $this->assertEqual(
+ $jar->selectAsPairs(new SimpleUrl('/')),
+ array('a=abc'));
+ $this->assertEqual(
+ $jar->selectAsPairs(new SimpleUrl('my-host.com/')),
+ array('a=abc'));
+ $this->assertEqual(
+ $jar->selectAsPairs(new SimpleUrl('my-host.com/path/')),
+ array('a=abc'));
+ $this->assertEqual(
+ $jar->selectAsPairs(new SimpleUrl('my-host.com/path/here')),
+ array('a=abc', 'a=123'));
+ $this->assertEqual(
+ $jar->selectAsPairs(new SimpleUrl('my-host.com/path/here/there')),
+ array('a=abc', 'a=123'));
+ }
+
+ function testOverwrite() {
+ $jar = new SimpleCookieJar();
+ $jar->setCookie('a', 'abc', false, '/');
+ $jar->setCookie('a', 'cde', false, '/');
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/')), array('a=cde'));
+ }
+
+ function testClearSessionCookies() {
+ $jar = new SimpleCookieJar();
+ $jar->setCookie('a', 'A', false, '/');
+ $jar->restartSession();
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/')), array());
+ }
+
+ function testExpiryFilterByDate() {
+ $jar = new SimpleCookieJar();
+ $jar->setCookie('a', 'A', false, '/', 'Wed, 25-Dec-02 04:24:20 GMT');
+ $jar->restartSession("Wed, 25-Dec-02 04:24:19 GMT");
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/')), array('a=A'));
+ $jar->restartSession("Wed, 25-Dec-02 04:24:21 GMT");
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/')), array());
+ }
+
+ function testExpiryFilterByAgeing() {
+ $jar = new SimpleCookieJar();
+ $jar->setCookie('a', 'A', false, '/', 'Wed, 25-Dec-02 04:24:20 GMT');
+ $jar->restartSession("Wed, 25-Dec-02 04:24:19 GMT");
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/')), array('a=A'));
+ $jar->agePrematurely(2);
+ $jar->restartSession("Wed, 25-Dec-02 04:24:19 GMT");
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/')), array());
+ }
+
+ function testCookieClearing() {
+ $jar = new SimpleCookieJar();
+ $jar->setCookie('a', 'abc', false, '/');
+ $jar->setCookie('a', '', false, '/');
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/')), array('a='));
+ }
+
+ function testCookieClearByLoweringDate() {
+ $jar = new SimpleCookieJar();
+ $jar->setCookie('a', 'abc', false, '/', 'Wed, 25-Dec-02 04:24:21 GMT');
+ $jar->setCookie('a', 'def', false, '/', 'Wed, 25-Dec-02 04:24:19 GMT');
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/')), array('a=def'));
+ $jar->restartSession('Wed, 25-Dec-02 04:24:20 GMT');
+ $this->assertEqual($jar->selectAsPairs(new SimpleUrl('/')), array());
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/detached_test.php b/vendors/simpletest/test/detached_test.php
new file mode 100755
index 000000000..06db8280b
--- /dev/null
+++ b/vendors/simpletest/test/detached_test.php
@@ -0,0 +1,15 @@
+<?php
+// $Id: detached_test.php 1505 2007-04-30 23:39:59Z lastcraft $
+require_once('../detached.php');
+require_once('../reporter.php');
+
+// The following URL will depend on your own installation.
+$command = 'php ' . dirname(__FILE__) . '/visual_test.php xml';
+
+$test = &new TestSuite('Remote tests');
+$test->addTestCase(new DetachedTestCase($command));
+if (SimpleReporter::inCli()) {
+ exit ($test->run(new TextReporter()) ? 0 : 1);
+}
+$test->run(new HtmlReporter());
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/dumper_test.php b/vendors/simpletest/test/dumper_test.php
new file mode 100755
index 000000000..789047de9
--- /dev/null
+++ b/vendors/simpletest/test/dumper_test.php
@@ -0,0 +1,88 @@
+<?php
+// $Id: dumper_test.php 1505 2007-04-30 23:39:59Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+
+class DumperDummy {
+}
+
+class TestOfTextFormatting extends UnitTestCase {
+
+ function testClipping() {
+ $dumper = new SimpleDumper();
+ $this->assertEqual(
+ $dumper->clipString("Hello", 6),
+ "Hello",
+ "Hello, 6->%s");
+ $this->assertEqual(
+ $dumper->clipString("Hello", 5),
+ "Hello",
+ "Hello, 5->%s");
+ $this->assertEqual(
+ $dumper->clipString("Hello world", 3),
+ "Hel...",
+ "Hello world, 3->%s");
+ $this->assertEqual(
+ $dumper->clipString("Hello world", 6, 3),
+ "Hello ...",
+ "Hello world, 6, 3->%s");
+ $this->assertEqual(
+ $dumper->clipString("Hello world", 3, 6),
+ "...o w...",
+ "Hello world, 3, 6->%s");
+ $this->assertEqual(
+ $dumper->clipString("Hello world", 4, 11),
+ "...orld",
+ "Hello world, 4, 11->%s");
+ $this->assertEqual(
+ $dumper->clipString("Hello world", 4, 12),
+ "...orld",
+ "Hello world, 4, 12->%s");
+ }
+
+ function testDescribeNull() {
+ $dumper = new SimpleDumper();
+ $this->assertPattern('/null/i', $dumper->describeValue(null));
+ }
+
+ function testDescribeBoolean() {
+ $dumper = new SimpleDumper();
+ $this->assertPattern('/boolean/i', $dumper->describeValue(true));
+ $this->assertPattern('/true/i', $dumper->describeValue(true));
+ $this->assertPattern('/false/i', $dumper->describeValue(false));
+ }
+
+ function testDescribeString() {
+ $dumper = new SimpleDumper();
+ $this->assertPattern('/string/i', $dumper->describeValue('Hello'));
+ $this->assertPattern('/Hello/', $dumper->describeValue('Hello'));
+ }
+
+ function testDescribeInteger() {
+ $dumper = new SimpleDumper();
+ $this->assertPattern('/integer/i', $dumper->describeValue(35));
+ $this->assertPattern('/35/', $dumper->describeValue(35));
+ }
+
+ function testDescribeFloat() {
+ $dumper = new SimpleDumper();
+ $this->assertPattern('/float/i', $dumper->describeValue(0.99));
+ $this->assertPattern('/0\.99/', $dumper->describeValue(0.99));
+ }
+
+ function testDescribeArray() {
+ $dumper = new SimpleDumper();
+ $this->assertPattern('/array/i', $dumper->describeValue(array(1, 4)));
+ $this->assertPattern('/2/i', $dumper->describeValue(array(1, 4)));
+ }
+
+ function testDescribeObject() {
+ $dumper = new SimpleDumper();
+ $this->assertPattern(
+ '/object/i',
+ $dumper->describeValue(new DumperDummy()));
+ $this->assertPattern(
+ '/DumperDummy/i',
+ $dumper->describeValue(new DumperDummy()));
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/eclipse_test.php b/vendors/simpletest/test/eclipse_test.php
new file mode 100755
index 000000000..0f1bf4bd4
--- /dev/null
+++ b/vendors/simpletest/test/eclipse_test.php
@@ -0,0 +1,32 @@
+<?php
+// $Id: eclipse_test.php 1505 2007-04-30 23:39:59Z lastcraft $
+
+//To run this from the eclipse plugin...you need to make sure that the
+//SimpleTest path in the preferences is the same as the location of the
+//eclipse.php file below otherwise you end up with two "different" eclipse.php
+//files included and that does not work...
+
+include_once(dirname(__FILE__) . '/../eclipse.php');
+Mock::generate('SimpleSocket');
+
+class TestOfEclipse extends UnitTestCase {
+
+ function testPass() {
+ $listener = &new MockSimpleSocket();
+
+ $fullpath = realpath(dirname(__FILE__).'/support/test1.php');
+ $testpath = EclipseReporter::escapeVal($fullpath);
+ $expected = "{status:\"pass\",message:\"pass1 at [$testpath line 4]\",group:\"$testpath\",case:\"test1\",method:\"test_pass\"}";
+ //this should work...but it doesn't so the next line and the last line are the hacks
+ //$listener->expectOnce('write',array($expected));
+ $listener->setReturnValue('write',-1);
+
+ $pathparts = pathinfo($fullpath);
+ $filename = $pathparts['basename'];
+ $test= &new TestSuite($filename);
+ $test->addTestFile($fullpath);
+ $test->run(new EclipseReporter(&$listener));
+ $this->assertEqual($expected,$listener->output);
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/encoding_test.php b/vendors/simpletest/test/encoding_test.php
new file mode 100755
index 000000000..95031fb0f
--- /dev/null
+++ b/vendors/simpletest/test/encoding_test.php
@@ -0,0 +1,213 @@
+<?php
+// $Id: encoding_test.php 1571 2007-09-07 17:14:32Z pp11 $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../url.php');
+require_once(dirname(__FILE__) . '/../socket.php');
+
+Mock::generate('SimpleSocket');
+
+class TestOfEncodedParts extends UnitTestCase {
+
+ function testFormEncodedAsKeyEqualsValue() {
+ $pair = new SimpleEncodedPair('a', 'A');
+ $this->assertEqual($pair->asRequest(), 'a=A');
+ }
+
+ function testMimeEncodedAsHeadersAndContent() {
+ $pair = new SimpleEncodedPair('a', 'A');
+ $this->assertEqual(
+ $pair->asMime(),
+ "Content-Disposition: form-data; name=\"a\"\r\n\r\nA");
+ }
+
+ function testAttachmentEncodedAsHeadersWithDispositionAndContent() {
+ $part = new SimpleAttachment('a', 'A', 'aaa.txt');
+ $this->assertEqual(
+ $part->asMime(),
+ "Content-Disposition: form-data; name=\"a\"; filename=\"aaa.txt\"\r\n" .
+ "Content-Type: text/plain\r\n\r\nA");
+ }
+}
+
+class TestOfEncoding extends UnitTestCase {
+ var $_content_so_far;
+
+ function write($content) {
+ $this->_content_so_far .= $content;
+ }
+
+ function clear() {
+ $this->_content_so_far = '';
+ }
+
+ function assertWritten($encoding, $content, $message = '%s') {
+ $this->clear();
+ $encoding->writeTo($this);
+ $this->assertIdentical($this->_content_so_far, $content, $message);
+ }
+
+ function testGetEmpty() {
+ $encoding = &new SimpleGetEncoding();
+ $this->assertIdentical($encoding->getValue('a'), false);
+ $this->assertIdentical($encoding->asUrlRequest(), '');
+ }
+
+ function testPostEmpty() {
+ $encoding = &new SimplePostEncoding();
+ $this->assertIdentical($encoding->getValue('a'), false);
+ $this->assertWritten($encoding, '');
+ }
+
+ function testPrefilled() {
+ $encoding = &new SimplePostEncoding(array('a' => 'aaa'));
+ $this->assertIdentical($encoding->getValue('a'), 'aaa');
+ $this->assertWritten($encoding, 'a=aaa');
+ }
+
+ function testPrefilledWithTwoLevels() {
+ $query = array('a' => array('aa' => 'aaa'));
+ $encoding = &new SimplePostEncoding($query);
+ $this->assertTrue($encoding->hasMoreThanOneLevel($query));
+ $this->assertEqual($encoding->rewriteArrayWithMultipleLevels($query), array('a[aa]' => 'aaa'));
+ $this->assertIdentical($encoding->getValue('a[aa]'), 'aaa');
+ $this->assertWritten($encoding, 'a%5Baa%5D=aaa');
+ }
+
+ function testPrefilledWithThreeLevels() {
+ $query = array('a' => array('aa' => array('aaa' => 'aaaa')));
+ $encoding = &new SimplePostEncoding($query);
+ $this->assertTrue($encoding->hasMoreThanOneLevel($query));
+ $this->assertEqual($encoding->rewriteArrayWithMultipleLevels($query), array('a[aa][aaa]' => 'aaaa'));
+ $this->assertIdentical($encoding->getValue('a[aa][aaa]'), 'aaaa');
+ $this->assertWritten($encoding, 'a%5Baa%5D%5Baaa%5D=aaaa');
+ }
+
+ function testPrefilledWithObject() {
+ $encoding = &new SimplePostEncoding(new SimpleEncoding(array('a' => 'aaa')));
+ $this->assertIdentical($encoding->getValue('a'), 'aaa');
+ $this->assertWritten($encoding, 'a=aaa');
+ }
+
+ function testMultiplePrefilled() {
+ $query = array('a' => array('a1', 'a2'));
+ $encoding = &new SimplePostEncoding($query);
+ $this->assertTrue($encoding->hasMoreThanOneLevel($query));
+ $this->assertEqual($encoding->rewriteArrayWithMultipleLevels($query), array('a[0]' => 'a1', 'a[1]' => 'a2'));
+ $this->assertIdentical($encoding->getValue('a[0]'), 'a1');
+ $this->assertIdentical($encoding->getValue('a[1]'), 'a2');
+ $this->assertWritten($encoding, 'a%5B0%5D=a1&a%5B1%5D=a2');
+ }
+
+ function testSingleParameter() {
+ $encoding = &new SimplePostEncoding();
+ $encoding->add('a', 'Hello');
+ $this->assertEqual($encoding->getValue('a'), 'Hello');
+ $this->assertWritten($encoding, 'a=Hello');
+ }
+
+ function testFalseParameter() {
+ $encoding = &new SimplePostEncoding();
+ $encoding->add('a', false);
+ $this->assertEqual($encoding->getValue('a'), false);
+ $this->assertWritten($encoding, '');
+ }
+
+ function testUrlEncoding() {
+ $encoding = &new SimplePostEncoding();
+ $encoding->add('a', 'Hello there!');
+ $this->assertWritten($encoding, 'a=Hello+there%21');
+ }
+
+ function testUrlEncodingOfKey() {
+ $encoding = &new SimplePostEncoding();
+ $encoding->add('a!', 'Hello');
+ $this->assertWritten($encoding, 'a%21=Hello');
+ }
+
+ function testMultipleParameter() {
+ $encoding = &new SimplePostEncoding();
+ $encoding->add('a', 'Hello');
+ $encoding->add('b', 'Goodbye');
+ $this->assertWritten($encoding, 'a=Hello&b=Goodbye');
+ }
+
+ function testEmptyParameters() {
+ $encoding = &new SimplePostEncoding();
+ $encoding->add('a', '');
+ $encoding->add('b', '');
+ $this->assertWritten($encoding, 'a=&b=');
+ }
+
+ function testRepeatedParameter() {
+ $encoding = &new SimplePostEncoding();
+ $encoding->add('a', 'Hello');
+ $encoding->add('a', 'Goodbye');
+ $this->assertIdentical($encoding->getValue('a'), array('Hello', 'Goodbye'));
+ $this->assertWritten($encoding, 'a=Hello&a=Goodbye');
+ }
+
+ function testAddingLists() {
+ $encoding = &new SimplePostEncoding();
+ $encoding->add('a', array('Hello', 'Goodbye'));
+ $this->assertIdentical($encoding->getValue('a'), array('Hello', 'Goodbye'));
+ $this->assertWritten($encoding, 'a=Hello&a=Goodbye');
+ }
+
+ function testMergeInHash() {
+ $encoding = &new SimpleGetEncoding(array('a' => 'A1', 'b' => 'B'));
+ $encoding->merge(array('a' => 'A2'));
+ $this->assertIdentical($encoding->getValue('a'), array('A1', 'A2'));
+ $this->assertIdentical($encoding->getValue('b'), 'B');
+ }
+
+ function testMergeInObject() {
+ $encoding = &new SimpleGetEncoding(array('a' => 'A1', 'b' => 'B'));
+ $encoding->merge(new SimpleEncoding(array('a' => 'A2')));
+ $this->assertIdentical($encoding->getValue('a'), array('A1', 'A2'));
+ $this->assertIdentical($encoding->getValue('b'), 'B');
+ }
+
+ function testPrefilledMultipart() {
+ $encoding = &new SimpleMultipartEncoding(array('a' => 'aaa'), 'boundary');
+ $this->assertIdentical($encoding->getValue('a'), 'aaa');
+ $this->assertwritten($encoding,
+ "--boundary\r\n" .
+ "Content-Disposition: form-data; name=\"a\"\r\n" .
+ "\r\n" .
+ "aaa\r\n" .
+ "--boundary--\r\n");
+ }
+
+ function testAttachment() {
+ $encoding = &new SimpleMultipartEncoding(array(), 'boundary');
+ $encoding->attach('a', 'aaa', 'aaa.txt');
+ $this->assertIdentical($encoding->getValue('a'), 'aaa.txt');
+ $this->assertwritten($encoding,
+ "--boundary\r\n" .
+ "Content-Disposition: form-data; name=\"a\"; filename=\"aaa.txt\"\r\n" .
+ "Content-Type: text/plain\r\n" .
+ "\r\n" .
+ "aaa\r\n" .
+ "--boundary--\r\n");
+ }
+}
+
+class TestOfFormHeaders extends UnitTestCase {
+
+ function testEmptyEncodingWritesZeroContentLength() {
+ $socket = &new MockSimpleSocket();
+ $socket->expectArgumentsAt(0, 'write', array("Content-Length: 0\r\n"));
+ $socket->expectArgumentsAt(1, 'write', array("Content-Type: application/x-www-form-urlencoded\r\n"));
+ $encoding = &new SimplePostEncoding();
+ $encoding->writeHeadersTo($socket);
+ }
+
+ function testEmptyMultipartEncodingWritesEndBoundaryContentLength() {
+ $socket = &new MockSimpleSocket();
+ $socket->expectArgumentsAt(0, 'write', array("Content-Length: 14\r\n"));
+ $socket->expectArgumentsAt(1, 'write', array("Content-Type: multipart/form-data, boundary=boundary\r\n"));
+ $encoding = &new SimpleMultipartEncoding(array(), 'boundary');
+ $encoding->writeHeadersTo($socket);
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/errors_test.php b/vendors/simpletest/test/errors_test.php
new file mode 100755
index 000000000..7db8769a2
--- /dev/null
+++ b/vendors/simpletest/test/errors_test.php
@@ -0,0 +1,300 @@
+<?php
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../errors.php');
+require_once(dirname(__FILE__) . '/../expectation.php');
+require_once(dirname(__FILE__) . '/../test_case.php');
+Mock::generate('SimpleTestCase');
+Mock::generate('SimpleExpectation');
+SimpleTest::ignore('MockSimpleTestCase');
+
+class TestOfErrorQueue extends UnitTestCase {
+
+ function setUp() {
+ $context = &SimpleTest::getContext();
+ $queue = &$context->get('SimpleErrorQueue');
+ $queue->clear();
+ }
+
+ function tearDown() {
+ $context = &SimpleTest::getContext();
+ $queue = &$context->get('SimpleErrorQueue');
+ $queue->clear();
+ }
+
+ function testOrder() {
+ $context = &SimpleTest::getContext();
+ $queue = &$context->get('SimpleErrorQueue');
+ $queue->add(1024, 'Ouch', 'here.php', 100);
+ $queue->add(512, 'Yuk', 'there.php', 101);
+ $this->assertEqual(
+ $queue->extract(),
+ array(1024, 'Ouch', 'here.php', 100));
+ $this->assertEqual(
+ $queue->extract(),
+ array(512, 'Yuk', 'there.php', 101));
+ $this->assertFalse($queue->extract());
+ }
+
+ function testAssertNoErrorsGivesTrueWhenNoErrors() {
+ $test = &new MockSimpleTestCase();
+ $test->expectOnce('assert', array(
+ new IdenticalExpectation(new TrueExpectation()),
+ true,
+ 'Should be no errors'));
+ $test->setReturnValue('assert', true);
+ $queue = &new SimpleErrorQueue();
+ $queue->setTestCase($test);
+ $this->assertTrue($queue->assertNoErrors('%s'));
+ }
+
+ function testAssertNoErrorsIssuesFailWhenErrors() {
+ $test = &new MockSimpleTestCase();
+ $test->expectOnce('assert', array(
+ new IdenticalExpectation(new TrueExpectation()),
+ false,
+ 'Should be no errors'));
+ $test->setReturnValue('assert', false);
+ $queue = &new SimpleErrorQueue();
+ $queue->setTestCase($test);
+ $queue->add(1024, 'Ouch', 'here.php', 100);
+ $this->assertFalse($queue->assertNoErrors('%s'));
+ }
+
+ function testAssertErrorFailsWhenNoError() {
+ $test = &new MockSimpleTestCase();
+ $test->expectOnce('fail', array('Expected error not found'));
+ $test->setReturnValue('assert', false);
+ $queue = &new SimpleErrorQueue();
+ $queue->setTestCase($test);
+ $this->assertFalse($queue->assertError(false, '%s'));
+ }
+
+ function testAssertErrorFailsWhenErrorDoesntMatchTheExpectation() {
+ $test = &new MockSimpleTestCase();
+ $test->expectOnce('assert', array(
+ new IdenticalExpectation(new FailedExpectation()),
+ 'B',
+ 'Expected PHP error [B] severity [E_USER_NOTICE] in [b.php] line [100]'));
+ $test->setReturnValue('assert', false);
+ $queue = &new SimpleErrorQueue();
+ $queue->setTestCase($test);
+ $queue->add(1024, 'B', 'b.php', 100);
+ $this->assertFalse($queue->assertError(new FailedExpectation(), '%s'));
+ }
+
+ function testExpectationMatchCancelsIncomingError() {
+ $test = &new MockSimpleTestCase();
+ $test->expectOnce('assert', array(
+ new IdenticalExpectation(new AnythingExpectation()),
+ 'B',
+ 'a message'));
+ $test->setReturnValue('assert', true);
+ $test->expectNever('error');
+ $queue = &new SimpleErrorQueue();
+ $queue->setTestCase($test);
+ $queue->expectError(new AnythingExpectation(), 'a message');
+ $queue->add(1024, 'B', 'b.php', 100);
+ }
+}
+
+class TestOfErrorTrap extends UnitTestCase {
+ var $_old;
+
+ function setUp() {
+ $this->_old = error_reporting(E_ALL);
+ set_error_handler('SimpleTestErrorHandler');
+ }
+
+ function tearDown() {
+ restore_error_handler();
+ error_reporting($this->_old);
+ }
+
+ function testQueueStartsEmpty() {
+ $context = &SimpleTest::getContext();
+ $queue = &$context->get('SimpleErrorQueue');
+ $this->assertFalse($queue->extract());
+ }
+
+ function testTrappedErrorPlacedInQueue() {
+ trigger_error('Ouch!');
+ $context = &SimpleTest::getContext();
+ $queue = &$context->get('SimpleErrorQueue');
+ list($severity, $message, $file, $line) = $queue->extract();
+ $this->assertEqual($message, 'Ouch!');
+ $this->assertEqual($file, __FILE__);
+ $this->assertFalse($queue->extract());
+ }
+
+ function testErrorsAreSwallowedByMatchingExpectation() {
+ $this->expectError('Ouch!');
+ trigger_error('Ouch!');
+ }
+
+ function testErrorsAreSwallowedInOrder() {
+ $this->expectError('a');
+ $this->expectError('b');
+ trigger_error('a');
+ trigger_error('b');
+ }
+
+ function testAnyErrorCanBeSwallowed() {
+ $this->expectError();
+ trigger_error('Ouch!');
+ }
+
+ function testErrorCanBeSwallowedByPatternMatching() {
+ $this->expectError(new PatternExpectation('/ouch/i'));
+ trigger_error('Ouch!');
+ }
+
+ function testErrorWithPercentsPassesWithNoSprintfError() {
+ $this->expectError("%");
+ trigger_error('%');
+ }
+}
+
+class TestOfErrors extends UnitTestCase {
+ var $_old;
+
+ function setUp() {
+ $this->_old = error_reporting(E_ALL);
+ }
+
+ function tearDown() {
+ error_reporting($this->_old);
+ }
+
+ function testDefaultWhenAllReported() {
+ error_reporting(E_ALL);
+ trigger_error('Ouch!');
+ $this->assertError('Ouch!');
+ }
+
+ function testNoticeWhenReported() {
+ error_reporting(E_ALL);
+ trigger_error('Ouch!', E_USER_NOTICE);
+ $this->assertError('Ouch!');
+ }
+
+ function testWarningWhenReported() {
+ error_reporting(E_ALL);
+ trigger_error('Ouch!', E_USER_WARNING);
+ $this->assertError('Ouch!');
+ }
+
+ function testErrorWhenReported() {
+ error_reporting(E_ALL);
+ trigger_error('Ouch!', E_USER_ERROR);
+ $this->assertError('Ouch!');
+ }
+
+ function testNoNoticeWhenNotReported() {
+ error_reporting(0);
+ trigger_error('Ouch!', E_USER_NOTICE);
+ }
+
+ function testNoWarningWhenNotReported() {
+ error_reporting(0);
+ trigger_error('Ouch!', E_USER_WARNING);
+ }
+
+ function testNoticeSuppressedWhenReported() {
+ error_reporting(E_ALL);
+ @trigger_error('Ouch!', E_USER_NOTICE);
+ }
+
+ function testWarningSuppressedWhenReported() {
+ error_reporting(E_ALL);
+ @trigger_error('Ouch!', E_USER_WARNING);
+ }
+
+ function testErrorWithPercentsReportedWithNoSprintfError() {
+ trigger_error('%');
+ $this->assertError('%');
+ }
+}
+
+class TestOfPHP52RecoverableErrors extends UnitTestCase {
+ function skip() {
+ $this->skipIf(
+ version_compare(phpversion(), '5.2', '<'),
+ 'E_RECOVERABLE_ERROR not tested for PHP below 5.2');
+ }
+
+ function testError() {
+ eval('
+ class RecoverableErrorTestingStub {
+ function ouch(RecoverableErrorTestingStub $obj) {
+ }
+ }
+ ');
+
+ $stub = new RecoverableErrorTestingStub();
+ $this->expectError(new PatternExpectation('/must be an instance of RecoverableErrorTestingStub/i'));
+ $stub->ouch(new stdClass());
+ }
+}
+
+class TestOfErrorsExcludingPHP52AndAbove extends UnitTestCase {
+ function skip() {
+ $this->skipIf(
+ version_compare(phpversion(), '5.2', '>='),
+ 'E_USER_ERROR not tested for PHP 5.2 and above');
+ }
+
+ function testNoErrorWhenNotReported() {
+ error_reporting(0);
+ trigger_error('Ouch!', E_USER_ERROR);
+ }
+
+ function testErrorSuppressedWhenReported() {
+ error_reporting(E_ALL);
+ @trigger_error('Ouch!', E_USER_ERROR);
+ }
+}
+
+SimpleTest::ignore('TestOfNotEnoughErrors');
+/**
+ * This test is ignored as it is used by {@link TestRunnerForLeftOverAndNotEnoughErrors}
+ * to verify that it fails as expected.
+ *
+ * @ignore
+ */
+class TestOfNotEnoughErrors extends UnitTestCase {
+ function testExpectTwoErrorsThrowOne() {
+ $this->expectError('Error 1');
+ trigger_error('Error 1');
+ $this->expectError('Error 2');
+ }
+}
+
+SimpleTest::ignore('TestOfLeftOverErrors');
+/**
+ * This test is ignored as it is used by {@link TestRunnerForLeftOverAndNotEnoughErrors}
+ * to verify that it fails as expected.
+ *
+ * @ignore
+ */
+class TestOfLeftOverErrors extends UnitTestCase {
+ function testExpectOneErrorGetTwo() {
+ $this->expectError('Error 1');
+ trigger_error('Error 1');
+ trigger_error('Error 2');
+ }
+}
+
+class TestRunnerForLeftOverAndNotEnoughErrors extends UnitTestCase {
+ function testRunLeftOverErrorsTestCase() {
+ $test = new TestOfLeftOverErrors();
+ $this->assertFalse($test->run(new SimpleReporter()));
+ }
+
+ function testRunNotEnoughErrors() {
+ $test = new TestOfNotEnoughErrors();
+ $this->assertFalse($test->run(new SimpleReporter()));
+ }
+}
+
+// TODO: Add stacked error handler test
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/exceptions_test.php b/vendors/simpletest/test/exceptions_test.php
new file mode 100755
index 000000000..9cc35c590
--- /dev/null
+++ b/vendors/simpletest/test/exceptions_test.php
@@ -0,0 +1,153 @@
+<?php
+// $Id: exceptions_test.php 1618 2007-12-29 22:52:30Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../exceptions.php');
+require_once(dirname(__FILE__) . '/../expectation.php');
+require_once(dirname(__FILE__) . '/../test_case.php');
+Mock::generate('SimpleTestCase');
+Mock::generate('SimpleExpectation');
+
+class MyTestException extends Exception {}
+class HigherTestException extends MyTestException {}
+class OtherTestException extends Exception {}
+
+class TestOfExceptionExpectation extends UnitTestCase {
+
+ function testExceptionClassAsStringWillMatchExceptionsRootedOnThatClass() {
+ $expectation = new ExceptionExpectation('MyTestException');
+ $this->assertTrue($expectation->test(new MyTestException()));
+ $this->assertTrue($expectation->test(new HigherTestException()));
+ $this->assertFalse($expectation->test(new OtherTestException()));
+ }
+
+ function testMatchesClassAndMessageWhenExceptionExpected() {
+ $expectation = new ExceptionExpectation(new MyTestException('Hello'));
+ $this->assertTrue($expectation->test(new MyTestException('Hello')));
+ $this->assertFalse($expectation->test(new HigherTestException('Hello')));
+ $this->assertFalse($expectation->test(new OtherTestException('Hello')));
+ $this->assertFalse($expectation->test(new MyTestException('Goodbye')));
+ $this->assertFalse($expectation->test(new MyTestException()));
+ }
+
+ function testMessagelessExceptionMatchesOnlyOnClass() {
+ $expectation = new ExceptionExpectation(new MyTestException());
+ $this->assertTrue($expectation->test(new MyTestException()));
+ $this->assertFalse($expectation->test(new HigherTestException()));
+ }
+}
+
+class TestOfExceptionTrap extends UnitTestCase {
+
+ function testNoExceptionsInQueueMeansNoTestMessages() {
+ $test = new MockSimpleTestCase();
+ $test->expectNever('assert');
+ $queue = new SimpleExceptionTrap();
+ $this->assertFalse($queue->isExpected($test, new Exception()));
+ }
+
+ function testMatchingExceptionGivesTrue() {
+ $expectation = new MockSimpleExpectation();
+ $expectation->setReturnValue('test', true);
+ $test = new MockSimpleTestCase();
+ $test->setReturnValue('assert', true);
+ $queue = new SimpleExceptionTrap();
+ $queue->expectException($expectation, 'message');
+ $this->assertTrue($queue->isExpected($test, new Exception()));
+ }
+
+ function testMatchingExceptionTriggersAssertion() {
+ $test = new MockSimpleTestCase();
+ $test->expectOnce('assert', array(
+ '*',
+ new ExceptionExpectation(new Exception()),
+ 'message'));
+ $queue = new SimpleExceptionTrap();
+ $queue->expectException(new ExceptionExpectation(new Exception()), 'message');
+ $queue->isExpected($test, new Exception());
+ }
+}
+
+class TestOfCatchingExceptions extends UnitTestCase {
+
+ function testCanCatchAnyExpectedException() {
+ $this->expectException();
+ throw new Exception();
+ }
+
+ function testCanMatchExceptionByClass() {
+ $this->expectException('MyTestException');
+ throw new HigherTestException();
+ }
+
+ function testCanMatchExceptionExactly() {
+ $this->expectException(new Exception('Ouch'));
+ throw new Exception('Ouch');
+ }
+
+ function testLastListedExceptionIsTheOneThatCounts() {
+ $this->expectException('OtherTestException');
+ $this->expectException('MyTestException');
+ throw new HigherTestException();
+ }
+}
+
+class TestOfCallingTearDownAfterExceptions extends UnitTestCase {
+ private $debri = 0;
+
+ function tearDown() {
+ $this->debri--;
+ }
+
+ function testLeaveSomeDebri() {
+ $this->debri++;
+ $this->expectException();
+ throw new Exception(__FUNCTION__);
+ }
+
+ function testDebriWasRemovedOnce() {
+ $this->assertEqual($this->debri, 0);
+ }
+}
+
+class TestOfExceptionThrownInSetUpDoesNotRunTestBody extends UnitTestCase {
+
+ function setUp() {
+ $this->expectException();
+ throw new Exception();
+ }
+
+ function testShouldNotBeRun() {
+ $this->fail('This test body should not be run');
+ }
+
+ function testShouldNotBeRunEither() {
+ $this->fail('This test body should not be run either');
+ }
+}
+
+class TestOfExpectExceptionWithSetUp extends UnitTestCase {
+
+ function setUp() {
+ $this->expectException();
+ }
+
+ function testThisExceptionShouldBeCaught() {
+ throw new Exception();
+ }
+
+ function testJustThrowingMyTestException() {
+ throw new MyTestException();
+ }
+}
+
+class TestOfThrowingExceptionsInTearDown extends UnitTestCase {
+
+ function tearDown() {
+ throw new Exception();
+ }
+
+ function testDoesntFatal() {
+ $this->expectException();
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/expectation_test.php b/vendors/simpletest/test/expectation_test.php
new file mode 100755
index 000000000..8f4fc3878
--- /dev/null
+++ b/vendors/simpletest/test/expectation_test.php
@@ -0,0 +1,245 @@
+<?php
+// $Id: expectation_test.php 1539 2007-06-09 08:35:54Z pachanga $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../expectation.php');
+
+class TestOfEquality extends UnitTestCase {
+
+ function testBoolean() {
+ $is_true = &new EqualExpectation(true);
+ $this->assertTrue($is_true->test(true));
+ $this->assertFalse($is_true->test(false));
+ }
+
+ function testStringMatch() {
+ $hello = &new EqualExpectation("Hello");
+ $this->assertTrue($hello->test("Hello"));
+ $this->assertFalse($hello->test("Goodbye"));
+ }
+
+ function testInteger() {
+ $fifteen = &new EqualExpectation(15);
+ $this->assertTrue($fifteen->test(15));
+ $this->assertFalse($fifteen->test(14));
+ }
+
+ function testFloat() {
+ $pi = &new EqualExpectation(3.14);
+ $this->assertTrue($pi->test(3.14));
+ $this->assertFalse($pi->test(3.15));
+ }
+
+ function testArray() {
+ $colours = &new EqualExpectation(array("r", "g", "b"));
+ $this->assertTrue($colours->test(array("r", "g", "b")));
+ $this->assertFalse($colours->test(array("g", "b", "r")));
+ }
+
+ function testHash() {
+ $is_blue = &new EqualExpectation(array("r" => 0, "g" => 0, "b" => 255));
+ $this->assertTrue($is_blue->test(array("r" => 0, "g" => 0, "b" => 255)));
+ $this->assertFalse($is_blue->test(array("r" => 0, "g" => 255, "b" => 0)));
+ }
+
+ function testHashWithOutOfOrderKeysShouldStillMatch() {
+ $any_order = &new EqualExpectation(array('a' => 1, 'b' => 2));
+ $this->assertTrue($any_order->test(array('b' => 2, 'a' => 1)));
+ }
+}
+
+class TestOfWithin extends UnitTestCase {
+
+ function testWithinFloatingPointMargin() {
+ $within = new WithinMarginExpectation(1.0, 0.2);
+ $this->assertFalse($within->test(0.7));
+ $this->assertTrue($within->test(0.8));
+ $this->assertTrue($within->test(0.9));
+ $this->assertTrue($within->test(1.1));
+ $this->assertTrue($within->test(1.2));
+ $this->assertFalse($within->test(1.3));
+ }
+
+ function testOutsideFloatingPointMargin() {
+ $within = new OutsideMarginExpectation(1.0, 0.2);
+ $this->assertTrue($within->test(0.7));
+ $this->assertFalse($within->test(0.8));
+ $this->assertFalse($within->test(1.2));
+ $this->assertTrue($within->test(1.3));
+ }
+}
+
+class TestOfInequality extends UnitTestCase {
+
+ function testStringMismatch() {
+ $not_hello = &new NotEqualExpectation("Hello");
+ $this->assertTrue($not_hello->test("Goodbye"));
+ $this->assertFalse($not_hello->test("Hello"));
+ }
+}
+
+class RecursiveNasty {
+ var $_me;
+
+ function RecursiveNasty() {
+ $this->_me = $this;
+ }
+}
+
+class TestOfIdentity extends UnitTestCase {
+
+ function testType() {
+ $string = &new IdenticalExpectation("37");
+ $this->assertTrue($string->test("37"));
+ $this->assertFalse($string->test(37));
+ $this->assertFalse($string->test("38"));
+ }
+
+ function _testNastyPhp5Bug() {
+ $this->assertFalse(new RecursiveNasty() != new RecursiveNasty());
+ }
+
+ function _testReallyHorribleRecursiveStructure() {
+ $hopeful = &new IdenticalExpectation(new RecursiveNasty());
+ $this->assertTrue($hopeful->test(new RecursiveNasty()));
+ }
+}
+
+class DummyReferencedObject{}
+
+class TestOfReference extends UnitTestCase {
+
+ function testReference() {
+ $foo = "foo";
+ $ref =& $foo;
+ $not_ref = $foo;
+ $bar = "bar";
+
+ $expect = &new ReferenceExpectation($foo);
+ $this->assertTrue($expect->test($ref));
+ $this->assertFalse($expect->test($not_ref));
+ $this->assertFalse($expect->test($bar));
+ }
+
+ function testObjectsReferencesDualityForPhp5AndPhp4() {
+ $dummy = new DummyReferencedObject();
+ $ref =& $dummy;
+ $not_ref = $dummy;
+
+ $hopeful = &new ReferenceExpectation($dummy);
+ $this->assertTrue($hopeful->test($ref));
+
+ if (version_compare(phpversion(), '5') >= 0) {
+ $this->assertTrue($hopeful->test($not_ref));
+ } else {
+ $this->assertFalse($hopeful->test($not_ref));
+ }
+ }
+
+ function testReallyHorribleRecursiveStructure() {
+ $nasty = new RecursiveNasty();
+ $ref =& $nasty;
+ $hopeful = &new ReferenceExpectation($nasty);
+ $this->assertTrue($hopeful->test($ref));
+ }
+}
+
+class TestOfNonIdentity extends UnitTestCase {
+
+ function testType() {
+ $string = &new NotIdenticalExpectation("37");
+ $this->assertTrue($string->test("38"));
+ $this->assertTrue($string->test(37));
+ $this->assertFalse($string->test("37"));
+ }
+}
+
+class TestOfPatterns extends UnitTestCase {
+
+ function testWanted() {
+ $pattern = &new PatternExpectation('/hello/i');
+ $this->assertTrue($pattern->test("Hello world"));
+ $this->assertFalse($pattern->test("Goodbye world"));
+ }
+
+ function testUnwanted() {
+ $pattern = &new NoPatternExpectation('/hello/i');
+ $this->assertFalse($pattern->test("Hello world"));
+ $this->assertTrue($pattern->test("Goodbye world"));
+ }
+}
+
+class ExpectedMethodTarget {
+ function hasThisMethod() {}
+}
+
+class TestOfMethodExistence extends UnitTestCase {
+
+ function testHasMethod() {
+ $instance = &new ExpectedMethodTarget();
+ $expectation = &new MethodExistsExpectation('hasThisMethod');
+ $this->assertTrue($expectation->test($instance));
+ $expectation = &new MethodExistsExpectation('doesNotHaveThisMethod');
+ $this->assertFalse($expectation->test($instance));
+ }
+}
+
+class TestOfIsA extends UnitTestCase {
+
+ function testString() {
+ $expectation = &new IsAExpectation('string');
+ $this->assertTrue($expectation->test('Hello'));
+ $this->assertFalse($expectation->test(5));
+ }
+
+ function testBoolean() {
+ $expectation = &new IsAExpectation('boolean');
+ $this->assertTrue($expectation->test(true));
+ $this->assertFalse($expectation->test(1));
+ }
+
+ function testBool() {
+ $expectation = &new IsAExpectation('bool');
+ $this->assertTrue($expectation->test(true));
+ $this->assertFalse($expectation->test(1));
+ }
+
+ function testDouble() {
+ $expectation = &new IsAExpectation('double');
+ $this->assertTrue($expectation->test(5.0));
+ $this->assertFalse($expectation->test(5));
+ }
+
+ function testFloat() {
+ $expectation = &new IsAExpectation('float');
+ $this->assertTrue($expectation->test(5.0));
+ $this->assertFalse($expectation->test(5));
+ }
+
+ function testReal() {
+ $expectation = &new IsAExpectation('real');
+ $this->assertTrue($expectation->test(5.0));
+ $this->assertFalse($expectation->test(5));
+ }
+
+ function testInteger() {
+ $expectation = &new IsAExpectation('integer');
+ $this->assertTrue($expectation->test(5));
+ $this->assertFalse($expectation->test(5.0));
+ }
+
+ function testInt() {
+ $expectation = &new IsAExpectation('int');
+ $this->assertTrue($expectation->test(5));
+ $this->assertFalse($expectation->test(5.0));
+ }
+}
+
+class TestOfNotA extends UnitTestCase {
+
+ function testString() {
+ $expectation = &new NotAExpectation('string');
+ $this->assertFalse($expectation->test('Hello'));
+ $this->assertTrue($expectation->test(5));
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/form_test.php b/vendors/simpletest/test/form_test.php
new file mode 100755
index 000000000..bdc6f67d2
--- /dev/null
+++ b/vendors/simpletest/test/form_test.php
@@ -0,0 +1,323 @@
+<?php
+// $Id: form_test.php 1624 2008-01-01 15:00:43Z pp11 $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../url.php');
+require_once(dirname(__FILE__) . '/../form.php');
+require_once(dirname(__FILE__) . '/../page.php');
+require_once(dirname(__FILE__) . '/../encoding.php');
+Mock::generate('SimplePage');
+
+class TestOfForm extends UnitTestCase {
+
+ function &page($url, $action = false) {
+ $page = &new MockSimplePage();
+ $page->setReturnValue('getUrl', new SimpleUrl($url));
+ $page->setReturnValue('expandUrl', new SimpleUrl($url));
+ return $page;
+ }
+
+ function testFormAttributes() {
+ $tag = &new SimpleFormTag(array('method' => 'GET', 'action' => 'here.php', 'id' => '33'));
+ $form = &new SimpleForm($tag, $this->page('http://host/a/index.html'));
+ $this->assertEqual($form->getMethod(), 'get');
+ $this->assertIdentical($form->getId(), '33');
+ $this->assertNull($form->getValue(new SimpleByName('a')));
+ }
+
+ function testAction() {
+ $page = &new MockSimplePage();
+ $page->expectOnce('expandUrl', array(new SimpleUrl('here.php')));
+ $page->setReturnValue('expandUrl', new SimpleUrl('http://host/here.php'));
+ $tag = &new SimpleFormTag(array('method' => 'GET', 'action' => 'here.php'));
+ $form = &new SimpleForm($tag, $page);
+ $this->assertEqual($form->getAction(), new SimpleUrl('http://host/here.php'));
+ }
+
+ function testEmptyAction() {
+ $tag = &new SimpleFormTag(array('method' => 'GET', 'action' => '', 'id' => '33'));
+ $form = &new SimpleForm($tag, $this->page('http://host/a/index.html'));
+ $this->assertEqual(
+ $form->getAction(),
+ new SimpleUrl('http://host/a/index.html'));
+ }
+
+ function testMissingAction() {
+ $tag = &new SimpleFormTag(array('method' => 'GET'));
+ $form = &new SimpleForm($tag, $this->page('http://host/a/index.html'));
+ $this->assertEqual(
+ $form->getAction(),
+ new SimpleUrl('http://host/a/index.html'));
+ }
+
+ function testRootAction() {
+ $page = &new MockSimplePage();
+ $page->expectOnce('expandUrl', array(new SimpleUrl('/')));
+ $page->setReturnValue('expandUrl', new SimpleUrl('http://host/'));
+ $tag = &new SimpleFormTag(array('method' => 'GET', 'action' => '/'));
+ $form = &new SimpleForm($tag, $page);
+ $this->assertEqual(
+ $form->getAction(),
+ new SimpleUrl('http://host/'));
+ }
+
+ function testDefaultFrameTargetOnForm() {
+ $page = &new MockSimplePage();
+ $page->expectOnce('expandUrl', array(new SimpleUrl('here.php')));
+ $page->setReturnValue('expandUrl', new SimpleUrl('http://host/here.php'));
+ $tag = &new SimpleFormTag(array('method' => 'GET', 'action' => 'here.php'));
+ $form = &new SimpleForm($tag, $page);
+ $form->setDefaultTarget('frame');
+ $expected = new SimpleUrl('http://host/here.php');
+ $expected->setTarget('frame');
+ $this->assertEqual($form->getAction(), $expected);
+ }
+
+ function testTextWidget() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('htp://host'));
+ $form->addWidget(new SimpleTextTag(
+ array('name' => 'me', 'type' => 'text', 'value' => 'Myself')));
+ $this->assertIdentical($form->getValue(new SimpleByName('me')), 'Myself');
+ $this->assertTrue($form->setField(new SimpleByName('me'), 'Not me'));
+ $this->assertFalse($form->setField(new SimpleByName('not_present'), 'Not me'));
+ $this->assertIdentical($form->getValue(new SimpleByName('me')), 'Not me');
+ $this->assertNull($form->getValue(new SimpleByName('not_present')));
+ }
+
+ function testTextWidgetById() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('htp://host'));
+ $form->addWidget(new SimpleTextTag(
+ array('name' => 'me', 'type' => 'text', 'value' => 'Myself', 'id' => 50)));
+ $this->assertIdentical($form->getValue(new SimpleById(50)), 'Myself');
+ $this->assertTrue($form->setField(new SimpleById(50), 'Not me'));
+ $this->assertIdentical($form->getValue(new SimpleById(50)), 'Not me');
+ }
+
+ function testTextWidgetByLabel() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('htp://host'));
+ $widget = &new SimpleTextTag(array('name' => 'me', 'type' => 'text', 'value' => 'a'));
+ $form->addWidget($widget);
+ $widget->setLabel('thing');
+ $this->assertIdentical($form->getValue(new SimpleByLabel('thing')), 'a');
+ $this->assertTrue($form->setField(new SimpleByLabel('thing'), 'b'));
+ $this->assertIdentical($form->getValue(new SimpleByLabel('thing')), 'b');
+ }
+
+ function testSubmitEmpty() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('htp://host'));
+ $this->assertIdentical($form->submit(), new SimpleGetEncoding());
+ }
+
+ function testSubmitButton() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('http://host'));
+ $form->addWidget(new SimpleSubmitTag(
+ array('type' => 'submit', 'name' => 'go', 'value' => 'Go!', 'id' => '9')));
+ $this->assertTrue($form->hasSubmit(new SimpleByName('go')));
+ $this->assertEqual($form->getValue(new SimpleByName('go')), 'Go!');
+ $this->assertEqual($form->getValue(new SimpleById(9)), 'Go!');
+ $this->assertEqual(
+ $form->submitButton(new SimpleByName('go')),
+ new SimpleGetEncoding(array('go' => 'Go!')));
+ $this->assertEqual(
+ $form->submitButton(new SimpleByLabel('Go!')),
+ new SimpleGetEncoding(array('go' => 'Go!')));
+ $this->assertEqual(
+ $form->submitButton(new SimpleById(9)),
+ new SimpleGetEncoding(array('go' => 'Go!')));
+ }
+
+ function testSubmitWithAdditionalParameters() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('http://host'));
+ $form->addWidget(new SimpleSubmitTag(
+ array('type' => 'submit', 'name' => 'go', 'value' => 'Go!')));
+ $this->assertEqual(
+ $form->submitButton(new SimpleByLabel('Go!'), array('a' => 'A')),
+ new SimpleGetEncoding(array('go' => 'Go!', 'a' => 'A')));
+ }
+
+ function testSubmitButtonWithLabelOfSubmit() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('http://host'));
+ $form->addWidget(new SimpleSubmitTag(
+ array('type' => 'submit', 'name' => 'test', 'value' => 'Submit')));
+ $this->assertEqual(
+ $form->submitButton(new SimpleByName('test')),
+ new SimpleGetEncoding(array('test' => 'Submit')));
+ $this->assertEqual(
+ $form->submitButton(new SimpleByLabel('Submit')),
+ new SimpleGetEncoding(array('test' => 'Submit')));
+ }
+
+ function testSubmitButtonWithWhitespacePaddedLabelOfSubmit() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('http://host'));
+ $form->addWidget(new SimpleSubmitTag(
+ array('type' => 'submit', 'name' => 'test', 'value' => ' Submit ')));
+ $this->assertEqual(
+ $form->submitButton(new SimpleByLabel('Submit')),
+ new SimpleGetEncoding(array('test' => ' Submit ')));
+ }
+
+ function testImageSubmitButton() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('htp://host'));
+ $form->addWidget(new SimpleImageSubmitTag(array(
+ 'type' => 'image',
+ 'src' => 'source.jpg',
+ 'name' => 'go',
+ 'alt' => 'Go!',
+ 'id' => '9')));
+ $this->assertTrue($form->hasImage(new SimpleByLabel('Go!')));
+ $this->assertEqual(
+ $form->submitImage(new SimpleByLabel('Go!'), 100, 101),
+ new SimpleGetEncoding(array('go.x' => 100, 'go.y' => 101)));
+ $this->assertTrue($form->hasImage(new SimpleByName('go')));
+ $this->assertEqual(
+ $form->submitImage(new SimpleByName('go'), 100, 101),
+ new SimpleGetEncoding(array('go.x' => 100, 'go.y' => 101)));
+ $this->assertTrue($form->hasImage(new SimpleById(9)));
+ $this->assertEqual(
+ $form->submitImage(new SimpleById(9), 100, 101),
+ new SimpleGetEncoding(array('go.x' => 100, 'go.y' => 101)));
+ }
+
+ function testImageSubmitButtonWithAdditionalData() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('htp://host'));
+ $form->addWidget(new SimpleImageSubmitTag(array(
+ 'type' => 'image',
+ 'src' => 'source.jpg',
+ 'name' => 'go',
+ 'alt' => 'Go!')));
+ $this->assertEqual(
+ $form->submitImage(new SimpleByLabel('Go!'), 100, 101, array('a' => 'A')),
+ new SimpleGetEncoding(array('go.x' => 100, 'go.y' => 101, 'a' => 'A')));
+ }
+
+ function testButtonTag() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('http://host'));
+ $widget = &new SimpleButtonTag(
+ array('type' => 'submit', 'name' => 'go', 'value' => 'Go', 'id' => '9'));
+ $widget->addContent('Go!');
+ $form->addWidget($widget);
+ $this->assertTrue($form->hasSubmit(new SimpleByName('go')));
+ $this->assertTrue($form->hasSubmit(new SimpleByLabel('Go!')));
+ $this->assertEqual(
+ $form->submitButton(new SimpleByName('go')),
+ new SimpleGetEncoding(array('go' => 'Go')));
+ $this->assertEqual(
+ $form->submitButton(new SimpleByLabel('Go!')),
+ new SimpleGetEncoding(array('go' => 'Go')));
+ $this->assertEqual(
+ $form->submitButton(new SimpleById(9)),
+ new SimpleGetEncoding(array('go' => 'Go')));
+ }
+
+ function testMultipleFieldsWithSameNameSubmitted() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('htp://host'));
+ $input = &new SimpleTextTag(array('name' => 'elements[]', 'value' => '1'));
+ $form->addWidget($input);
+ $input = &new SimpleTextTag(array('name' => 'elements[]', 'value' => '2'));
+ $form->addWidget($input);
+ $form->setField(new SimpleByLabelOrName('elements[]'), '3', 1);
+ $form->setField(new SimpleByLabelOrName('elements[]'), '4', 2);
+ $submit = $form->submit();
+ $this->assertEqual(count($submit->_request), 2);
+ $this->assertIdentical($submit->_request[0], new SimpleEncodedPair('elements[]', '3'));
+ $this->assertIdentical($submit->_request[1], new SimpleEncodedPair('elements[]', '4'));
+ }
+
+ function testSingleSelectFieldSubmitted() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('htp://host'));
+ $select = &new SimpleSelectionTag(array('name' => 'a'));
+ $select->addTag(new SimpleOptionTag(
+ array('value' => 'aaa', 'selected' => '')));
+ $form->addWidget($select);
+ $this->assertIdentical(
+ $form->submit(),
+ new SimpleGetEncoding(array('a' => 'aaa')));
+ }
+
+ function testSingleSelectFieldSubmittedWithPost() {
+ $form = &new SimpleForm(new SimpleFormTag(array('method' => 'post')), $this->page('htp://host'));
+ $select = &new SimpleSelectionTag(array('name' => 'a'));
+ $select->addTag(new SimpleOptionTag(
+ array('value' => 'aaa', 'selected' => '')));
+ $form->addWidget($select);
+ $this->assertIdentical(
+ $form->submit(),
+ new SimplePostEncoding(array('a' => 'aaa')));
+ }
+
+ function testUnchecked() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('htp://host'));
+ $form->addWidget(new SimpleCheckboxTag(
+ array('name' => 'me', 'type' => 'checkbox')));
+ $this->assertIdentical($form->getValue(new SimpleByName('me')), false);
+ $this->assertTrue($form->setField(new SimpleByName('me'), 'on'));
+ $this->assertEqual($form->getValue(new SimpleByName('me')), 'on');
+ $this->assertFalse($form->setField(new SimpleByName('me'), 'other'));
+ $this->assertEqual($form->getValue(new SimpleByName('me')), 'on');
+ }
+
+ function testChecked() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('htp://host'));
+ $form->addWidget(new SimpleCheckboxTag(
+ array('name' => 'me', 'value' => 'a', 'type' => 'checkbox', 'checked' => '')));
+ $this->assertIdentical($form->getValue(new SimpleByName('me')), 'a');
+ $this->assertTrue($form->setField(new SimpleByName('me'), 'a'));
+ $this->assertEqual($form->getValue(new SimpleByName('me')), 'a');
+ $this->assertTrue($form->setField(new SimpleByName('me'), false));
+ $this->assertEqual($form->getValue(new SimpleByName('me')), false);
+ }
+
+ function testSingleUncheckedRadioButton() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('htp://host'));
+ $form->addWidget(new SimpleRadioButtonTag(
+ array('name' => 'me', 'value' => 'a', 'type' => 'radio')));
+ $this->assertIdentical($form->getValue(new SimpleByName('me')), false);
+ $this->assertTrue($form->setField(new SimpleByName('me'), 'a'));
+ $this->assertEqual($form->getValue(new SimpleByName('me')), 'a');
+ }
+
+ function testSingleCheckedRadioButton() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('htp://host'));
+ $form->addWidget(new SimpleRadioButtonTag(
+ array('name' => 'me', 'value' => 'a', 'type' => 'radio', 'checked' => '')));
+ $this->assertIdentical($form->getValue(new SimpleByName('me')), 'a');
+ $this->assertFalse($form->setField(new SimpleByName('me'), 'other'));
+ }
+
+ function testUncheckedRadioButtons() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('htp://host'));
+ $form->addWidget(new SimpleRadioButtonTag(
+ array('name' => 'me', 'value' => 'a', 'type' => 'radio')));
+ $form->addWidget(new SimpleRadioButtonTag(
+ array('name' => 'me', 'value' => 'b', 'type' => 'radio')));
+ $this->assertIdentical($form->getValue(new SimpleByName('me')), false);
+ $this->assertTrue($form->setField(new SimpleByName('me'), 'a'));
+ $this->assertIdentical($form->getValue(new SimpleByName('me')), 'a');
+ $this->assertTrue($form->setField(new SimpleByName('me'), 'b'));
+ $this->assertIdentical($form->getValue(new SimpleByName('me')), 'b');
+ $this->assertFalse($form->setField(new SimpleByName('me'), 'c'));
+ $this->assertIdentical($form->getValue(new SimpleByName('me')), 'b');
+ }
+
+ function testCheckedRadioButtons() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('htp://host'));
+ $form->addWidget(new SimpleRadioButtonTag(
+ array('name' => 'me', 'value' => 'a', 'type' => 'radio')));
+ $form->addWidget(new SimpleRadioButtonTag(
+ array('name' => 'me', 'value' => 'b', 'type' => 'radio', 'checked' => '')));
+ $this->assertIdentical($form->getValue(new SimpleByName('me')), 'b');
+ $this->assertTrue($form->setField(new SimpleByName('me'), 'a'));
+ $this->assertIdentical($form->getValue(new SimpleByName('me')), 'a');
+ }
+
+ function testMultipleFieldsWithSameKey() {
+ $form = &new SimpleForm(new SimpleFormTag(array()), $this->page('htp://host'));
+ $form->addWidget(new SimpleCheckboxTag(
+ array('name' => 'a', 'type' => 'checkbox', 'value' => 'me')));
+ $form->addWidget(new SimpleCheckboxTag(
+ array('name' => 'a', 'type' => 'checkbox', 'value' => 'you')));
+ $this->assertIdentical($form->getValue(new SimpleByName('a')), false);
+ $this->assertTrue($form->setField(new SimpleByName('a'), 'me'));
+ $this->assertIdentical($form->getValue(new SimpleByName('a')), 'me');
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/frames_test.php b/vendors/simpletest/test/frames_test.php
new file mode 100755
index 000000000..160eebc1b
--- /dev/null
+++ b/vendors/simpletest/test/frames_test.php
@@ -0,0 +1,549 @@
+<?php
+// $Id: frames_test.php 1555 2007-07-14 02:04:34Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../tag.php');
+require_once(dirname(__FILE__) . '/../page.php');
+require_once(dirname(__FILE__) . '/../frames.php');
+Mock::generate('SimplePage');
+Mock::generate('SimpleForm');
+
+class TestOfFrameset extends UnitTestCase {
+
+ function testTitleReadFromFramesetPage() {
+ $page = &new MockSimplePage();
+ $page->setReturnValue('getTitle', 'This page');
+ $frameset = &new SimpleFrameset($page);
+ $this->assertEqual($frameset->getTitle(), 'This page');
+ }
+
+ function TestHeadersReadFromFramesetByDefault() {
+ $page = &new MockSimplePage();
+ $page->setReturnValue('getHeaders', 'Header: content');
+ $page->setReturnValue('getMimeType', 'text/xml');
+ $page->setReturnValue('getResponseCode', 401);
+ $page->setReturnValue('getTransportError', 'Could not parse headers');
+ $page->setReturnValue('getAuthentication', 'Basic');
+ $page->setReturnValue('getRealm', 'Safe place');
+
+ $frameset = &new SimpleFrameset($page);
+
+ $this->assertIdentical($frameset->getHeaders(), 'Header: content');
+ $this->assertIdentical($frameset->getMimeType(), 'text/xml');
+ $this->assertIdentical($frameset->getResponseCode(), 401);
+ $this->assertIdentical($frameset->getTransportError(), 'Could not parse headers');
+ $this->assertIdentical($frameset->getAuthentication(), 'Basic');
+ $this->assertIdentical($frameset->getRealm(), 'Safe place');
+ }
+
+ function testEmptyFramesetHasNoContent() {
+ $page = &new MockSimplePage();
+ $page->setReturnValue('getRaw', 'This content');
+ $frameset = &new SimpleFrameset($page);
+ $this->assertEqual($frameset->getRaw(), '');
+ }
+
+ function testRawContentIsFromOnlyFrame() {
+ $page = &new MockSimplePage();
+ $page->expectNever('getRaw');
+
+ $frame = &new MockSimplePage();
+ $frame->setReturnValue('getRaw', 'Stuff');
+
+ $frameset = &new SimpleFrameset($page);
+ $frameset->addFrame($frame);
+ $this->assertEqual($frameset->getRaw(), 'Stuff');
+ }
+
+ function testRawContentIsFromAllFrames() {
+ $page = &new MockSimplePage();
+ $page->expectNever('getRaw');
+
+ $frame1 = &new MockSimplePage();
+ $frame1->setReturnValue('getRaw', 'Stuff1');
+
+ $frame2 = &new MockSimplePage();
+ $frame2->setReturnValue('getRaw', 'Stuff2');
+
+ $frameset = &new SimpleFrameset($page);
+ $frameset->addFrame($frame1);
+ $frameset->addFrame($frame2);
+ $this->assertEqual($frameset->getRaw(), 'Stuff1Stuff2');
+ }
+
+ function testTextContentIsFromOnlyFrame() {
+ $page = &new MockSimplePage();
+ $page->expectNever('getText');
+
+ $frame = &new MockSimplePage();
+ $frame->setReturnValue('getText', 'Stuff');
+
+ $frameset = &new SimpleFrameset($page);
+ $frameset->addFrame($frame);
+ $this->assertEqual($frameset->getText(), 'Stuff');
+ }
+
+ function testTextContentIsFromAllFrames() {
+ $page = &new MockSimplePage();
+ $page->expectNever('getText');
+
+ $frame1 = &new MockSimplePage();
+ $frame1->setReturnValue('getText', 'Stuff1');
+
+ $frame2 = &new MockSimplePage();
+ $frame2->setReturnValue('getText', 'Stuff2');
+
+ $frameset = &new SimpleFrameset($page);
+ $frameset->addFrame($frame1);
+ $frameset->addFrame($frame2);
+ $this->assertEqual($frameset->getText(), 'Stuff1 Stuff2');
+ }
+
+ function testFieldFoundIsFirstInFramelist() {
+ $frame1 = &new MockSimplePage();
+ $frame1->setReturnValue('getField', null);
+ $frame1->expectOnce('getField', array(new SimpleByName('a')));
+
+ $frame2 = &new MockSimplePage();
+ $frame2->setReturnValue('getField', 'A');
+ $frame2->expectOnce('getField', array(new SimpleByName('a')));
+
+ $frame3 = &new MockSimplePage();
+ $frame3->expectNever('getField');
+
+ $page = &new MockSimplePage();
+ $frameset = &new SimpleFrameset($page);
+ $frameset->addFrame($frame1);
+ $frameset->addFrame($frame2);
+ $frameset->addFrame($frame3);
+ $this->assertIdentical($frameset->getField(new SimpleByName('a')), 'A');
+ }
+
+ function testFrameReplacementByIndex() {
+ $page = &new MockSimplePage();
+ $page->expectNever('getRaw');
+
+ $frame1 = &new MockSimplePage();
+ $frame1->setReturnValue('getRaw', 'Stuff1');
+
+ $frame2 = &new MockSimplePage();
+ $frame2->setReturnValue('getRaw', 'Stuff2');
+
+ $frameset = &new SimpleFrameset($page);
+ $frameset->addFrame($frame1);
+ $frameset->setFrame(array(1), $frame2);
+ $this->assertEqual($frameset->getRaw(), 'Stuff2');
+ }
+
+ function testFrameReplacementByName() {
+ $page = &new MockSimplePage();
+ $page->expectNever('getRaw');
+
+ $frame1 = &new MockSimplePage();
+ $frame1->setReturnValue('getRaw', 'Stuff1');
+
+ $frame2 = &new MockSimplePage();
+ $frame2->setReturnValue('getRaw', 'Stuff2');
+
+ $frameset = &new SimpleFrameset($page);
+ $frameset->addFrame($frame1, 'a');
+ $frameset->setFrame(array('a'), $frame2);
+ $this->assertEqual($frameset->getRaw(), 'Stuff2');
+ }
+}
+
+class TestOfFrameNavigation extends UnitTestCase {
+
+ function testStartsWithoutFrameFocus() {
+ $page = &new MockSimplePage();
+ $frameset = &new SimpleFrameset($page);
+ $frameset->addFrame($frame);
+ $this->assertFalse($frameset->getFrameFocus());
+ }
+
+ function testCanFocusOnSingleFrame() {
+ $page = &new MockSimplePage();
+ $page->expectNever('getRaw');
+
+ $frame = &new MockSimplePage();
+ $frame->setReturnValue('getFrameFocus', array());
+ $frame->setReturnValue('getRaw', 'Stuff');
+
+ $frameset = &new SimpleFrameset($page);
+ $frameset->addFrame($frame);
+
+ $this->assertFalse($frameset->setFrameFocusByIndex(0));
+ $this->assertTrue($frameset->setFrameFocusByIndex(1));
+ $this->assertEqual($frameset->getRaw(), 'Stuff');
+ $this->assertFalse($frameset->setFrameFocusByIndex(2));
+ $this->assertIdentical($frameset->getFrameFocus(), array(1));
+ }
+
+ function testContentComesFromFrameInFocus() {
+ $page = &new MockSimplePage();
+
+ $frame1 = &new MockSimplePage();
+ $frame1->setReturnValue('getRaw', 'Stuff1');
+ $frame1->setReturnValue('getFrameFocus', array());
+
+ $frame2 = &new MockSimplePage();
+ $frame2->setReturnValue('getRaw', 'Stuff2');
+ $frame2->setReturnValue('getFrameFocus', array());
+
+ $frameset = &new SimpleFrameset($page);
+ $frameset->addFrame($frame1);
+ $frameset->addFrame($frame2);
+
+ $this->assertTrue($frameset->setFrameFocusByIndex(1));
+ $this->assertEqual($frameset->getFrameFocus(), array(1));
+ $this->assertEqual($frameset->getRaw(), 'Stuff1');
+
+ $this->assertTrue($frameset->setFrameFocusByIndex(2));
+ $this->assertEqual($frameset->getFrameFocus(), array(2));
+ $this->assertEqual($frameset->getRaw(), 'Stuff2');
+
+ $this->assertFalse($frameset->setFrameFocusByIndex(3));
+ $this->assertEqual($frameset->getFrameFocus(), array(2));
+
+ $frameset->clearFrameFocus();
+ $this->assertEqual($frameset->getRaw(), 'Stuff1Stuff2');
+ }
+
+ function testCanFocusByName() {
+ $page = &new MockSimplePage();
+
+ $frame1 = &new MockSimplePage();
+ $frame1->setReturnValue('getRaw', 'Stuff1');
+ $frame1->setReturnValue('getFrameFocus', array());
+
+ $frame2 = &new MockSimplePage();
+ $frame2->setReturnValue('getRaw', 'Stuff2');
+ $frame2->setReturnValue('getFrameFocus', array());
+
+ $frameset = &new SimpleFrameset($page);
+ $frameset->addFrame($frame1, 'A');
+ $frameset->addFrame($frame2, 'B');
+
+ $this->assertTrue($frameset->setFrameFocus('A'));
+ $this->assertEqual($frameset->getFrameFocus(), array('A'));
+ $this->assertEqual($frameset->getRaw(), 'Stuff1');
+
+ $this->assertTrue($frameset->setFrameFocusByIndex(2));
+ $this->assertEqual($frameset->getFrameFocus(), array('B'));
+ $this->assertEqual($frameset->getRaw(), 'Stuff2');
+
+ $this->assertFalse($frameset->setFrameFocus('z'));
+
+ $frameset->clearFrameFocus();
+ $this->assertEqual($frameset->getRaw(), 'Stuff1Stuff2');
+ }
+}
+
+class TestOfFramesetPageInterface extends UnitTestCase {
+ var $_page_interface;
+ var $_frameset_interface;
+
+ function TestOfFramesetPageInterface() {
+ $this->UnitTestCase();
+ $this->_page_interface = $this->_getPageMethods();
+ $this->_frameset_interface = $this->_getFramesetMethods();
+ }
+
+ function assertListInAnyOrder($list, $expected) {
+ sort($list);
+ sort($expected);
+ $this->assertEqual($list, $expected);
+ }
+
+ function _getPageMethods() {
+ $methods = array();
+ foreach (get_class_methods('SimplePage') as $method) {
+ if (strtolower($method) == strtolower('SimplePage')) {
+ continue;
+ }
+ if (strtolower($method) == strtolower('getFrameset')) {
+ continue;
+ }
+ if (strncmp($method, '_', 1) == 0) {
+ continue;
+ }
+ if (strncmp($method, 'accept', 6) == 0) {
+ continue;
+ }
+ $methods[] = $method;
+ }
+ return $methods;
+ }
+
+ function _getFramesetMethods() {
+ $methods = array();
+ foreach (get_class_methods('SimpleFrameset') as $method) {
+ if (strtolower($method) == strtolower('SimpleFrameset')) {
+ continue;
+ }
+ if (strncmp($method, '_', 1) == 0) {
+ continue;
+ }
+ if (strncmp($method, 'add', 3) == 0) {
+ continue;
+ }
+ $methods[] = $method;
+ }
+ return $methods;
+ }
+
+ function testFramsetHasPageInterface() {
+ $difference = array();
+ foreach ($this->_page_interface as $method) {
+ if (! in_array($method, $this->_frameset_interface)) {
+ $this->fail("No [$method] in Frameset class");
+ return;
+ }
+ }
+ $this->pass('Frameset covers Page interface');
+ }
+
+ function testHeadersReadFromFrameIfInFocus() {
+ $frame = &new MockSimplePage();
+ $frame->setReturnValue('getUrl', new SimpleUrl('http://localhost/stuff'));
+
+ $frame->setReturnValue('getRequest', 'POST stuff');
+ $frame->setReturnValue('getMethod', 'POST');
+ $frame->setReturnValue('getRequestData', array('a' => 'A'));
+ $frame->setReturnValue('getHeaders', 'Header: content');
+ $frame->setReturnValue('getMimeType', 'text/xml');
+ $frame->setReturnValue('getResponseCode', 401);
+ $frame->setReturnValue('getTransportError', 'Could not parse headers');
+ $frame->setReturnValue('getAuthentication', 'Basic');
+ $frame->setReturnValue('getRealm', 'Safe place');
+
+ $frameset = &new SimpleFrameset(new MockSimplePage());
+ $frameset->addFrame($frame);
+ $frameset->setFrameFocusByIndex(1);
+
+ $url = new SimpleUrl('http://localhost/stuff');
+ $url->setTarget(1);
+ $this->assertIdentical($frameset->getUrl(), $url);
+
+ $this->assertIdentical($frameset->getRequest(), 'POST stuff');
+ $this->assertIdentical($frameset->getMethod(), 'POST');
+ $this->assertIdentical($frameset->getRequestData(), array('a' => 'A'));
+ $this->assertIdentical($frameset->getHeaders(), 'Header: content');
+ $this->assertIdentical($frameset->getMimeType(), 'text/xml');
+ $this->assertIdentical($frameset->getResponseCode(), 401);
+ $this->assertIdentical($frameset->getTransportError(), 'Could not parse headers');
+ $this->assertIdentical($frameset->getAuthentication(), 'Basic');
+ $this->assertIdentical($frameset->getRealm(), 'Safe place');
+ }
+
+ function testUrlsComeFromBothFrames() {
+ $page = &new MockSimplePage();
+ $page->expectNever('getUrls');
+
+ $frame1 = &new MockSimplePage();
+ $frame1->setReturnValue(
+ 'getUrls',
+ array('http://www.lastcraft.com/', 'http://myserver/'));
+
+ $frame2 = &new MockSimplePage();
+ $frame2->setReturnValue(
+ 'getUrls',
+ array('http://www.lastcraft.com/', 'http://test/'));
+
+ $frameset = &new SimpleFrameset($page);
+ $frameset->addFrame($frame1);
+ $frameset->addFrame($frame2);
+ $this->assertListInAnyOrder(
+ $frameset->getUrls(),
+ array('http://www.lastcraft.com/', 'http://myserver/', 'http://test/'));
+ }
+
+ function testLabelledUrlsComeFromBothFrames() {
+ $frame1 = &new MockSimplePage();
+ $frame1->setReturnValue(
+ 'getUrlsByLabel',
+ array(new SimpleUrl('goodbye.php')),
+ array('a'));
+
+ $frame2 = &new MockSimplePage();
+ $frame2->setReturnValue(
+ 'getUrlsByLabel',
+ array(new SimpleUrl('hello.php')),
+ array('a'));
+
+ $frameset = &new SimpleFrameset(new MockSimplePage());
+ $frameset->addFrame($frame1);
+ $frameset->addFrame($frame2, 'Two');
+
+ $expected1 = new SimpleUrl('goodbye.php');
+ $expected1->setTarget(1);
+ $expected2 = new SimpleUrl('hello.php');
+ $expected2->setTarget('Two');
+ $this->assertEqual(
+ $frameset->getUrlsByLabel('a'),
+ array($expected1, $expected2));
+ }
+
+ function testUrlByIdComesFromFirstFrameToRespond() {
+ $frame1 = &new MockSimplePage();
+ $frame1->setReturnValue('getUrlById', new SimpleUrl('four.php'), array(4));
+ $frame1->setReturnValue('getUrlById', false, array(5));
+
+ $frame2 = &new MockSimplePage();
+ $frame2->setReturnValue('getUrlById', false, array(4));
+ $frame2->setReturnValue('getUrlById', new SimpleUrl('five.php'), array(5));
+
+ $frameset = &new SimpleFrameset(new MockSimplePage());
+ $frameset->addFrame($frame1);
+ $frameset->addFrame($frame2);
+
+ $four = new SimpleUrl('four.php');
+ $four->setTarget(1);
+ $this->assertEqual($frameset->getUrlById(4), $four);
+ $five = new SimpleUrl('five.php');
+ $five->setTarget(2);
+ $this->assertEqual($frameset->getUrlById(5), $five);
+ }
+
+ function testReadUrlsFromFrameInFocus() {
+ $frame1 = &new MockSimplePage();
+ $frame1->setReturnValue('getUrls', array('a'));
+ $frame1->setReturnValue('getUrlsByLabel', array(new SimpleUrl('l')));
+ $frame1->setReturnValue('getUrlById', new SimpleUrl('i'));
+
+ $frame2 = &new MockSimplePage();
+ $frame2->expectNever('getUrls');
+ $frame2->expectNever('getUrlsByLabel');
+ $frame2->expectNever('getUrlById');
+
+ $frameset = &new SimpleFrameset(new MockSimplePage());
+ $frameset->addFrame($frame1, 'A');
+ $frameset->addFrame($frame2, 'B');
+ $frameset->setFrameFocus('A');
+
+ $this->assertIdentical($frameset->getUrls(), array('a'));
+ $expected = new SimpleUrl('l');
+ $expected->setTarget('A');
+ $this->assertIdentical($frameset->getUrlsByLabel('label'), array($expected));
+ $expected = new SimpleUrl('i');
+ $expected->setTarget('A');
+ $this->assertIdentical($frameset->getUrlById(99), $expected);
+ }
+
+ function testReadFrameTaggedUrlsFromFrameInFocus() {
+ $frame = &new MockSimplePage();
+
+ $by_label = new SimpleUrl('l');
+ $by_label->setTarget('L');
+ $frame->setReturnValue('getUrlsByLabel', array($by_label));
+
+ $by_id = new SimpleUrl('i');
+ $by_id->setTarget('I');
+ $frame->setReturnValue('getUrlById', $by_id);
+
+ $frameset = &new SimpleFrameset(new MockSimplePage());
+ $frameset->addFrame($frame, 'A');
+ $frameset->setFrameFocus('A');
+
+ $this->assertIdentical($frameset->getUrlsByLabel('label'), array($by_label));
+ $this->assertIdentical($frameset->getUrlById(99), $by_id);
+ }
+
+ function testFindingFormsById() {
+ $frame = &new MockSimplePage();
+ $form = &new MockSimpleForm();
+ $frame->setReturnReference('getFormById', $form, array('a'));
+
+ $frameset = &new SimpleFrameset(new MockSimplePage());
+ $frameset->addFrame(new MockSimplePage(), 'A');
+ $frameset->addFrame($frame, 'B');
+ $this->assertReference($frameset->getFormById('a'), $form);
+
+ $frameset->setFrameFocus('A');
+ $this->assertNull($frameset->getFormById('a'));
+
+ $frameset->setFrameFocus('B');
+ $this->assertReference($frameset->getFormById('a'), $form);
+ }
+
+ function testFindingFormsBySubmit() {
+ $frame = &new MockSimplePage();
+ $form = &new MockSimpleForm();
+ $frame->setReturnReference(
+ 'getFormBySubmit',
+ $form,
+ array(new SimpleByLabel('a')));
+
+ $frameset = &new SimpleFrameset(new MockSimplePage());
+ $frameset->addFrame(new MockSimplePage(), 'A');
+ $frameset->addFrame($frame, 'B');
+ $this->assertReference($frameset->getFormBySubmit(new SimpleByLabel('a')), $form);
+
+ $frameset->setFrameFocus('A');
+ $this->assertNull($frameset->getFormBySubmit(new SimpleByLabel('a')));
+
+ $frameset->setFrameFocus('B');
+ $this->assertReference($frameset->getFormBySubmit(new SimpleByLabel('a')), $form);
+ }
+
+ function testFindingFormsByImage() {
+ $frame = &new MockSimplePage();
+ $form = &new MockSimpleForm();
+ $frame->setReturnReference(
+ 'getFormByImage',
+ $form,
+ array(new SimpleByLabel('a')));
+
+ $frameset = &new SimpleFrameset(new MockSimplePage());
+ $frameset->addFrame(new MockSimplePage(), 'A');
+ $frameset->addFrame($frame, 'B');
+ $this->assertReference($frameset->getFormByImage(new SimpleByLabel('a')), $form);
+
+ $frameset->setFrameFocus('A');
+ $this->assertNull($frameset->getFormByImage(new SimpleByLabel('a')));
+
+ $frameset->setFrameFocus('B');
+ $this->assertReference($frameset->getFormByImage(new SimpleByLabel('a')), $form);
+ }
+
+ function testSettingAllFrameFieldsWhenNoFrameFocus() {
+ $frame1 = &new MockSimplePage();
+ $frame1->expectOnce('setField', array(new SimpleById(22), 'A'));
+
+ $frame2 = &new MockSimplePage();
+ $frame2->expectOnce('setField', array(new SimpleById(22), 'A'));
+
+ $frameset = &new SimpleFrameset(new MockSimplePage());
+ $frameset->addFrame($frame1, 'A');
+ $frameset->addFrame($frame2, 'B');
+ $frameset->setField(new SimpleById(22), 'A');
+ }
+
+ function testOnlySettingFieldFromFocusedFrame() {
+ $frame1 = &new MockSimplePage();
+ $frame1->expectOnce('setField', array(new SimpleByLabelOrName('a'), 'A'));
+
+ $frame2 = &new MockSimplePage();
+ $frame2->expectNever('setField');
+
+ $frameset = &new SimpleFrameset(new MockSimplePage());
+ $frameset->addFrame($frame1, 'A');
+ $frameset->addFrame($frame2, 'B');
+ $frameset->setFrameFocus('A');
+ $frameset->setField(new SimpleByLabelOrName('a'), 'A');
+ }
+
+ function testOnlyGettingFieldFromFocusedFrame() {
+ $frame1 = &new MockSimplePage();
+ $frame1->setReturnValue('getField', 'f', array(new SimpleByName('a')));
+
+ $frame2 = &new MockSimplePage();
+ $frame2->expectNever('getField');
+
+ $frameset = &new SimpleFrameset(new MockSimplePage());
+ $frameset->addFrame($frame1, 'A');
+ $frameset->addFrame($frame2, 'B');
+ $frameset->setFrameFocus('A');
+ $this->assertIdentical($frameset->getField(new SimpleByName('a')), 'f');
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/http_test.php b/vendors/simpletest/test/http_test.php
new file mode 100755
index 000000000..d249850c8
--- /dev/null
+++ b/vendors/simpletest/test/http_test.php
@@ -0,0 +1,427 @@
+<?php
+// $Id: http_test.php 1505 2007-04-30 23:39:59Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../encoding.php');
+require_once(dirname(__FILE__) . '/../http.php');
+require_once(dirname(__FILE__) . '/../socket.php');
+require_once(dirname(__FILE__) . '/../cookies.php');
+Mock::generate('SimpleSocket');
+Mock::generate('SimpleCookieJar');
+Mock::generate('SimpleRoute');
+Mock::generatePartial('SimpleRoute', 'PartialSimpleRoute', array('_createSocket'));
+Mock::generatePartial(
+ 'SimpleProxyRoute',
+ 'PartialSimpleProxyRoute',
+ array('_createSocket'));
+
+class TestOfDirectRoute extends UnitTestCase {
+
+ function testDefaultGetRequest() {
+ $socket = &new MockSimpleSocket();
+ $socket->expectArgumentsAt(0, 'write', array("GET /here.html HTTP/1.0\r\n"));
+ $socket->expectArgumentsAt(1, 'write', array("Host: a.valid.host\r\n"));
+ $socket->expectArgumentsAt(2, 'write', array("Connection: close\r\n"));
+ $socket->expectCallCount('write', 3);
+
+ $route = &new PartialSimpleRoute();
+ $route->setReturnReference('_createSocket', $socket);
+ $route->SimpleRoute(new SimpleUrl('http://a.valid.host/here.html'));
+
+ $this->assertReference($route->createConnection('GET', 15), $socket);
+ }
+
+ function testDefaultPostRequest() {
+ $socket = &new MockSimpleSocket();
+ $socket->expectArgumentsAt(0, 'write', array("POST /here.html HTTP/1.0\r\n"));
+ $socket->expectArgumentsAt(1, 'write', array("Host: a.valid.host\r\n"));
+ $socket->expectArgumentsAt(2, 'write', array("Connection: close\r\n"));
+ $socket->expectCallCount('write', 3);
+
+ $route = &new PartialSimpleRoute();
+ $route->setReturnReference('_createSocket', $socket);
+ $route->SimpleRoute(new SimpleUrl('http://a.valid.host/here.html'));
+
+ $route->createConnection('POST', 15);
+ }
+
+ function testGetWithPort() {
+ $socket = &new MockSimpleSocket();
+ $socket->expectArgumentsAt(0, 'write', array("GET /here.html HTTP/1.0\r\n"));
+ $socket->expectArgumentsAt(1, 'write', array("Host: a.valid.host:81\r\n"));
+ $socket->expectArgumentsAt(2, 'write', array("Connection: close\r\n"));
+ $socket->expectCallCount('write', 3);
+
+ $route = &new PartialSimpleRoute();
+ $route->setReturnReference('_createSocket', $socket);
+ $route->SimpleRoute(new SimpleUrl('http://a.valid.host:81/here.html'));
+
+ $route->createConnection('GET', 15);
+ }
+
+ function testGetWithParameters() {
+ $socket = &new MockSimpleSocket();
+ $socket->expectArgumentsAt(0, 'write', array("GET /here.html?a=1&b=2 HTTP/1.0\r\n"));
+ $socket->expectArgumentsAt(1, 'write', array("Host: a.valid.host\r\n"));
+ $socket->expectArgumentsAt(2, 'write', array("Connection: close\r\n"));
+ $socket->expectCallCount('write', 3);
+
+ $route = &new PartialSimpleRoute();
+ $route->setReturnReference('_createSocket', $socket);
+ $route->SimpleRoute(new SimpleUrl('http://a.valid.host/here.html?a=1&b=2'));
+
+ $route->createConnection('GET', 15);
+ }
+}
+
+class TestOfProxyRoute extends UnitTestCase {
+
+ function testDefaultGet() {
+ $socket = &new MockSimpleSocket();
+ $socket->expectArgumentsAt(0, 'write', array("GET http://a.valid.host/here.html HTTP/1.0\r\n"));
+ $socket->expectArgumentsAt(1, 'write', array("Host: my-proxy:8080\r\n"));
+ $socket->expectArgumentsAt(2, 'write', array("Connection: close\r\n"));
+ $socket->expectCallCount('write', 3);
+
+ $route = &new PartialSimpleProxyRoute();
+ $route->setReturnReference('_createSocket', $socket);
+ $route->SimpleProxyRoute(
+ new SimpleUrl('http://a.valid.host/here.html'),
+ new SimpleUrl('http://my-proxy'));
+ $route->createConnection('GET', 15);
+ }
+
+ function testDefaultPost() {
+ $socket = &new MockSimpleSocket();
+ $socket->expectArgumentsAt(0, 'write', array("POST http://a.valid.host/here.html HTTP/1.0\r\n"));
+ $socket->expectArgumentsAt(1, 'write', array("Host: my-proxy:8080\r\n"));
+ $socket->expectArgumentsAt(2, 'write', array("Connection: close\r\n"));
+ $socket->expectCallCount('write', 3);
+
+ $route = &new PartialSimpleProxyRoute();
+ $route->setReturnReference('_createSocket', $socket);
+ $route->SimpleProxyRoute(
+ new SimpleUrl('http://a.valid.host/here.html'),
+ new SimpleUrl('http://my-proxy'));
+ $route->createConnection('POST', 15);
+ }
+
+ function testGetWithPort() {
+ $socket = &new MockSimpleSocket();
+ $socket->expectArgumentsAt(0, 'write', array("GET http://a.valid.host:81/here.html HTTP/1.0\r\n"));
+ $socket->expectArgumentsAt(1, 'write', array("Host: my-proxy:8081\r\n"));
+ $socket->expectArgumentsAt(2, 'write', array("Connection: close\r\n"));
+ $socket->expectCallCount('write', 3);
+
+ $route = &new PartialSimpleProxyRoute();
+ $route->setReturnReference('_createSocket', $socket);
+ $route->SimpleProxyRoute(
+ new SimpleUrl('http://a.valid.host:81/here.html'),
+ new SimpleUrl('http://my-proxy:8081'));
+ $route->createConnection('GET', 15);
+ }
+
+ function testGetWithParameters() {
+ $socket = &new MockSimpleSocket();
+ $socket->expectArgumentsAt(0, 'write', array("GET http://a.valid.host/here.html?a=1&b=2 HTTP/1.0\r\n"));
+ $socket->expectArgumentsAt(1, 'write', array("Host: my-proxy:8080\r\n"));
+ $socket->expectArgumentsAt(2, 'write', array("Connection: close\r\n"));
+ $socket->expectCallCount('write', 3);
+
+ $route = &new PartialSimpleProxyRoute();
+ $route->setReturnReference('_createSocket', $socket);
+ $route->SimpleProxyRoute(
+ new SimpleUrl('http://a.valid.host/here.html?a=1&b=2'),
+ new SimpleUrl('http://my-proxy'));
+ $route->createConnection('GET', 15);
+ }
+
+ function testGetWithAuthentication() {
+ $encoded = base64_encode('Me:Secret');
+
+ $socket = &new MockSimpleSocket();
+ $socket->expectArgumentsAt(0, 'write', array("GET http://a.valid.host/here.html HTTP/1.0\r\n"));
+ $socket->expectArgumentsAt(1, 'write', array("Host: my-proxy:8080\r\n"));
+ $socket->expectArgumentsAt(2, 'write', array("Proxy-Authorization: Basic $encoded\r\n"));
+ $socket->expectArgumentsAt(3, 'write', array("Connection: close\r\n"));
+ $socket->expectCallCount('write', 4);
+
+ $route = &new PartialSimpleProxyRoute();
+ $route->setReturnReference('_createSocket', $socket);
+ $route->SimpleProxyRoute(
+ new SimpleUrl('http://a.valid.host/here.html'),
+ new SimpleUrl('http://my-proxy'),
+ 'Me',
+ 'Secret');
+ $route->createConnection('GET', 15);
+ }
+}
+
+class TestOfHttpRequest extends UnitTestCase {
+
+ function testReadingBadConnection() {
+ $socket = &new MockSimpleSocket();
+
+ $route = &new MockSimpleRoute();
+ $route->setReturnReference('createConnection', $socket);
+
+ $request = &new SimpleHttpRequest($route, new SimpleGetEncoding());
+ $reponse = &$request->fetch(15);
+ $this->assertTrue($reponse->isError());
+ }
+
+ function testReadingGoodConnection() {
+ $socket = &new MockSimpleSocket();
+ $socket->expectOnce('write', array("\r\n"));
+
+ $route = &new MockSimpleRoute();
+ $route->setReturnReference('createConnection', $socket);
+ $route->expectArguments('createConnection', array('GET', 15));
+
+ $request = &new SimpleHttpRequest($route, new SimpleGetEncoding());
+ $this->assertIsA($request->fetch(15), 'SimpleHttpResponse');
+ }
+
+ function testWritingAdditionalHeaders() {
+ $socket = &new MockSimpleSocket();
+ $socket->expectArgumentsAt(0, 'write', array("My: stuff\r\n"));
+ $socket->expectArgumentsAt(1, 'write', array("\r\n"));
+ $socket->expectCallCount('write', 2);
+
+ $route = &new MockSimpleRoute();
+ $route->setReturnReference('createConnection', $socket);
+
+ $request = &new SimpleHttpRequest($route, new SimpleGetEncoding());
+ $request->addHeaderLine('My: stuff');
+ $request->fetch(15);
+ }
+
+ function testCookieWriting() {
+ $socket = &new MockSimpleSocket();
+ $socket->expectArgumentsAt(0, 'write', array("Cookie: a=A\r\n"));
+ $socket->expectArgumentsAt(1, 'write', array("\r\n"));
+ $socket->expectCallCount('write', 2);
+
+ $route = &new MockSimpleRoute();
+ $route->setReturnReference('createConnection', $socket);
+
+ $jar = new SimpleCookieJar();
+ $jar->setCookie('a', 'A');
+
+ $request = &new SimpleHttpRequest($route, new SimpleGetEncoding());
+ $request->readCookiesFromJar($jar, new SimpleUrl('/'));
+ $this->assertIsA($request->fetch(15), 'SimpleHttpResponse');
+ }
+
+ function testMultipleCookieWriting() {
+ $socket = &new MockSimpleSocket();
+ $socket->expectArgumentsAt(0, 'write', array("Cookie: a=A;b=B\r\n"));
+
+ $route = &new MockSimpleRoute();
+ $route->setReturnReference('createConnection', $socket);
+
+ $jar = new SimpleCookieJar();
+ $jar->setCookie('a', 'A');
+ $jar->setCookie('b', 'B');
+
+ $request = &new SimpleHttpRequest($route, new SimpleGetEncoding());
+ $request->readCookiesFromJar($jar, new SimpleUrl('/'));
+ $request->fetch(15);
+ }
+}
+
+class TestOfHttpPostRequest extends UnitTestCase {
+
+ function testReadingBadConnectionCausesErrorBecauseOfDeadSocket() {
+ $socket = &new MockSimpleSocket();
+
+ $route = &new MockSimpleRoute();
+ $route->setReturnReference('createConnection', $socket);
+
+ $request = &new SimpleHttpRequest($route, new SimplePostEncoding());
+ $reponse = &$request->fetch(15);
+ $this->assertTrue($reponse->isError());
+ }
+
+ function testReadingGoodConnection() {
+ $socket = &new MockSimpleSocket();
+ $socket->expectArgumentsAt(0, 'write', array("Content-Length: 0\r\n"));
+ $socket->expectArgumentsAt(1, 'write', array("Content-Type: application/x-www-form-urlencoded\r\n"));
+ $socket->expectArgumentsAt(2, 'write', array("\r\n"));
+ $socket->expectArgumentsAt(3, 'write', array(""));
+
+ $route = &new MockSimpleRoute();
+ $route->setReturnReference('createConnection', $socket);
+ $route->expectArguments('createConnection', array('POST', 15));
+
+ $request = &new SimpleHttpRequest($route, new SimplePostEncoding());
+ $this->assertIsA($request->fetch(15), 'SimpleHttpResponse');
+ }
+
+ function testContentHeadersCalculated() {
+ $socket = &new MockSimpleSocket();
+ $socket->expectArgumentsAt(0, 'write', array("Content-Length: 3\r\n"));
+ $socket->expectArgumentsAt(1, 'write', array("Content-Type: application/x-www-form-urlencoded\r\n"));
+ $socket->expectArgumentsAt(2, 'write', array("\r\n"));
+ $socket->expectArgumentsAt(3, 'write', array("a=A"));
+
+ $route = &new MockSimpleRoute();
+ $route->setReturnReference('createConnection', $socket);
+ $route->expectArguments('createConnection', array('POST', 15));
+
+ $request = &new SimpleHttpRequest(
+ $route,
+ new SimplePostEncoding(array('a' => 'A')));
+ $this->assertIsA($request->fetch(15), 'SimpleHttpResponse');
+ }
+}
+
+class TestOfHttpHeaders extends UnitTestCase {
+
+ function testParseBasicHeaders() {
+ $headers = new SimpleHttpHeaders(
+ "HTTP/1.1 200 OK\r\n" .
+ "Date: Mon, 18 Nov 2002 15:50:29 GMT\r\n" .
+ "Content-Type: text/plain\r\n" .
+ "Server: Apache/1.3.24 (Win32) PHP/4.2.3\r\n" .
+ "Connection: close");
+ $this->assertIdentical($headers->getHttpVersion(), "1.1");
+ $this->assertIdentical($headers->getResponseCode(), 200);
+ $this->assertEqual($headers->getMimeType(), "text/plain");
+ }
+
+ function testNonStandardResponseHeader() {
+ $headers = new SimpleHttpHeaders(
+ "HTTP/1.1 302 (HTTP-Version SP Status-Code CRLF)\r\n" .
+ "Connection: close");
+ $this->assertIdentical($headers->getResponseCode(), 302);
+ }
+
+ function testCanParseMultipleCookies() {
+ $jar = &new MockSimpleCookieJar();
+ $jar->expectAt(0, 'setCookie', array('a', 'aaa', 'host', '/here/', 'Wed, 25 Dec 2002 04:24:20 GMT'));
+ $jar->expectAt(1, 'setCookie', array('b', 'bbb', 'host', '/', false));
+
+ $headers = new SimpleHttpHeaders(
+ "HTTP/1.1 200 OK\r\n" .
+ "Date: Mon, 18 Nov 2002 15:50:29 GMT\r\n" .
+ "Content-Type: text/plain\r\n" .
+ "Server: Apache/1.3.24 (Win32) PHP/4.2.3\r\n" .
+ "Set-Cookie: a=aaa; expires=Wed, 25-Dec-02 04:24:20 GMT; path=/here/\r\n" .
+ "Set-Cookie: b=bbb\r\n" .
+ "Connection: close");
+ $headers->writeCookiesToJar($jar, new SimpleUrl('http://host'));
+ }
+
+ function testCanRecogniseRedirect() {
+ $headers = new SimpleHttpHeaders("HTTP/1.1 301 OK\r\n" .
+ "Content-Type: text/plain\r\n" .
+ "Content-Length: 0\r\n" .
+ "Location: http://www.somewhere-else.com/\r\n" .
+ "Connection: close");
+ $this->assertIdentical($headers->getResponseCode(), 301);
+ $this->assertEqual($headers->getLocation(), "http://www.somewhere-else.com/");
+ $this->assertTrue($headers->isRedirect());
+ }
+
+ function testCanParseChallenge() {
+ $headers = new SimpleHttpHeaders("HTTP/1.1 401 Authorization required\r\n" .
+ "Content-Type: text/plain\r\n" .
+ "Connection: close\r\n" .
+ "WWW-Authenticate: Basic realm=\"Somewhere\"");
+ $this->assertEqual($headers->getAuthentication(), 'Basic');
+ $this->assertEqual($headers->getRealm(), 'Somewhere');
+ $this->assertTrue($headers->isChallenge());
+ }
+}
+
+class TestOfHttpResponse extends UnitTestCase {
+
+ function testBadRequest() {
+ $socket = &new MockSimpleSocket();
+ $socket->setReturnValue('getSent', '');
+
+ $response = &new SimpleHttpResponse($socket, new SimpleUrl('here'), new SimpleGetEncoding());
+ $this->assertTrue($response->isError());
+ $this->assertPattern('/Nothing fetched/', $response->getError());
+ $this->assertIdentical($response->getContent(), false);
+ $this->assertIdentical($response->getSent(), '');
+ }
+
+ function testBadSocketDuringResponse() {
+ $socket = &new MockSimpleSocket();
+ $socket->setReturnValueAt(0, "read", "HTTP/1.1 200 OK\r\n");
+ $socket->setReturnValueAt(1, "read", "Date: Mon, 18 Nov 2002 15:50:29 GMT\r\n");
+ $socket->setReturnValue("read", "");
+ $socket->setReturnValue('getSent', 'HTTP/1.1 ...');
+
+ $response = &new SimpleHttpResponse($socket, new SimpleUrl('here'), new SimpleGetEncoding());
+ $this->assertTrue($response->isError());
+ $this->assertEqual($response->getContent(), '');
+ $this->assertEqual($response->getSent(), 'HTTP/1.1 ...');
+ }
+
+ function testIncompleteHeader() {
+ $socket = &new MockSimpleSocket();
+ $socket->setReturnValueAt(0, "read", "HTTP/1.1 200 OK\r\n");
+ $socket->setReturnValueAt(1, "read", "Date: Mon, 18 Nov 2002 15:50:29 GMT\r\n");
+ $socket->setReturnValueAt(2, "read", "Content-Type: text/plain\r\n");
+ $socket->setReturnValue("read", "");
+
+ $response = &new SimpleHttpResponse($socket, new SimpleUrl('here'), new SimpleGetEncoding());
+ $this->assertTrue($response->isError());
+ $this->assertEqual($response->getContent(), "");
+ }
+
+ function testParseOfResponseHeadersWhenChunked() {
+ $socket = &new MockSimpleSocket();
+ $socket->setReturnValueAt(0, "read", "HTTP/1.1 200 OK\r\nDate: Mon, 18 Nov 2002 15:50:29 GMT\r\n");
+ $socket->setReturnValueAt(1, "read", "Content-Type: text/plain\r\n");
+ $socket->setReturnValueAt(2, "read", "Server: Apache/1.3.24 (Win32) PHP/4.2.3\r\nConne");
+ $socket->setReturnValueAt(3, "read", "ction: close\r\n\r\nthis is a test file\n");
+ $socket->setReturnValueAt(4, "read", "with two lines in it\n");
+ $socket->setReturnValue("read", "");
+
+ $response = &new SimpleHttpResponse($socket, new SimpleUrl('here'), new SimpleGetEncoding());
+ $this->assertFalse($response->isError());
+ $this->assertEqual(
+ $response->getContent(),
+ "this is a test file\nwith two lines in it\n");
+ $headers = $response->getHeaders();
+ $this->assertIdentical($headers->getHttpVersion(), "1.1");
+ $this->assertIdentical($headers->getResponseCode(), 200);
+ $this->assertEqual($headers->getMimeType(), "text/plain");
+ $this->assertFalse($headers->isRedirect());
+ $this->assertFalse($headers->getLocation());
+ }
+
+ function testRedirect() {
+ $socket = &new MockSimpleSocket();
+ $socket->setReturnValueAt(0, "read", "HTTP/1.1 301 OK\r\n");
+ $socket->setReturnValueAt(1, "read", "Content-Type: text/plain\r\n");
+ $socket->setReturnValueAt(2, "read", "Location: http://www.somewhere-else.com/\r\n");
+ $socket->setReturnValueAt(3, "read", "Connection: close\r\n");
+ $socket->setReturnValueAt(4, "read", "\r\n");
+ $socket->setReturnValue("read", "");
+
+ $response = &new SimpleHttpResponse($socket, new SimpleUrl('here'), new SimpleGetEncoding());
+ $headers = $response->getHeaders();
+ $this->assertTrue($headers->isRedirect());
+ $this->assertEqual($headers->getLocation(), "http://www.somewhere-else.com/");
+ }
+
+ function testRedirectWithPort() {
+ $socket = &new MockSimpleSocket();
+ $socket->setReturnValueAt(0, "read", "HTTP/1.1 301 OK\r\n");
+ $socket->setReturnValueAt(1, "read", "Content-Type: text/plain\r\n");
+ $socket->setReturnValueAt(2, "read", "Location: http://www.somewhere-else.com:80/\r\n");
+ $socket->setReturnValueAt(3, "read", "Connection: close\r\n");
+ $socket->setReturnValueAt(4, "read", "\r\n");
+ $socket->setReturnValue("read", "");
+
+ $response = &new SimpleHttpResponse($socket, new SimpleUrl('here'), new SimpleGetEncoding());
+ $headers = $response->getHeaders();
+ $this->assertTrue($headers->isRedirect());
+ $this->assertEqual($headers->getLocation(), "http://www.somewhere-else.com:80/");
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/interfaces_test.php b/vendors/simpletest/test/interfaces_test.php
new file mode 100755
index 000000000..b6980edb1
--- /dev/null
+++ b/vendors/simpletest/test/interfaces_test.php
@@ -0,0 +1,137 @@
+<?php
+// $Id: interfaces_test.php 1699 2008-03-24 16:01:29Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+if (function_exists('spl_classes')) {
+ include(dirname(__FILE__) . '/support/spl_examples.php');
+}
+
+interface DummyInterface {
+ function aMethod();
+ function anotherMethod($a);
+ function &referenceMethod(&$a);
+}
+
+Mock::generate('DummyInterface');
+Mock::generatePartial('DummyInterface', 'PartialDummyInterface', array());
+
+class TestOfMockInterfaces extends UnitTestCase {
+
+ function testCanMockAnInterface() {
+ $mock = new MockDummyInterface();
+ $this->assertIsA($mock, 'SimpleMock');
+ $this->assertIsA($mock, 'MockDummyInterface');
+ $this->assertTrue(method_exists($mock, 'aMethod'));
+ $this->assertTrue(method_exists($mock, 'anotherMethod'));
+ $this->assertNull($mock->aMethod());
+ }
+
+ function testMockedInterfaceExpectsParameters() {
+ $mock = new MockDummyInterface();
+ $mock->anotherMethod();
+ $this->assertError();
+ }
+
+ function testCannotPartiallyMockAnInterface() {
+ $this->assertFalse(class_exists('PartialDummyInterface'));
+ }
+}
+
+class TestOfSpl extends UnitTestCase {
+
+ function skip() {
+ $this->skipUnless(function_exists('spl_classes'), 'No SPL module loaded');
+ }
+
+ function testCanMockAllSplClasses() {
+ if (! function_exists('spl_classes')) {
+ return;
+ }
+ foreach(spl_classes() as $class) {
+ if ($class == 'SplHeap') {
+ continue;
+ }
+ $mock_class = "Mock$class";
+ Mock::generate($class);
+ $this->assertIsA(new $mock_class(), $mock_class);
+ }
+ }
+
+ function testExtensionOfCommonSplClasses() {
+ Mock::generate('IteratorImplementation');
+ $this->assertIsA(
+ new IteratorImplementation(),
+ 'IteratorImplementation');
+ Mock::generate('IteratorAggregateImplementation');
+ $this->assertIsA(
+ new IteratorAggregateImplementation(),
+ 'IteratorAggregateImplementation');
+ }
+}
+
+class WithHint {
+ function hinted(DummyInterface $object) { }
+}
+
+class ImplementsDummy implements DummyInterface {
+ function aMethod() { }
+ function anotherMethod($a) { }
+ function &referenceMethod(&$a) { }
+ function extraMethod($a = false) { }
+}
+Mock::generate('ImplementsDummy');
+
+class TestOfImplementations extends UnitTestCase {
+
+ function testMockedInterfaceCanPassThroughTypeHint() {
+ $mock = new MockDummyInterface();
+ $hinter = new WithHint();
+ $hinter->hinted($mock);
+ }
+
+ function testImplementedInterfacesAreCarried() {
+ $mock = new MockImplementsDummy();
+ $hinter = new WithHint();
+ $hinter->hinted($mock);
+ }
+
+ function testNoSpuriousWarningsWhenSkippingDefaultedParameter() {
+ $mock = new MockImplementsDummy();
+ $mock->extraMethod();
+ }
+}
+
+interface SampleClassWithConstruct {
+ function __construct($something);
+}
+
+class TestOfInterfaceMocksWithConstruct extends UnitTestCase {
+ function testBasicConstructOfAnInterface() {
+ Mock::generate('SampleClassWithConstruct');
+ $this->assertNoErrors();
+ }
+}
+
+interface SampleInterfaceWithHintInSignature {
+ function method(array $hinted);
+}
+
+class TestOfInterfaceMocksWithHintInSignature extends UnitTestCase {
+ function testBasicConstructOfAnInterfaceWithHintInSignature() {
+ Mock::generate('SampleInterfaceWithHintInSignature');
+ $this->assertNoErrors();
+ $mock = new MockSampleInterfaceWithHintInSignature();
+ $this->assertIsA($mock, 'SampleInterfaceWithHintInSignature');
+ }
+}
+
+interface SampleInterfaceWithClone {
+ function __clone();
+}
+
+class TestOfSampleInterfaceWithClone extends UnitTestCase {
+ function testCanMockWithoutErrors() {
+ Mock::generate('SampleInterfaceWithClone');
+ $this->assertNoErrors();
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/live_test.php b/vendors/simpletest/test/live_test.php
new file mode 100755
index 000000000..b294030e1
--- /dev/null
+++ b/vendors/simpletest/test/live_test.php
@@ -0,0 +1,47 @@
+<?php
+// $Id: live_test.php 1505 2007-04-30 23:39:59Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../socket.php');
+require_once(dirname(__FILE__) . '/../http.php');
+require_once(dirname(__FILE__) . '/../compatibility.php');
+
+if (SimpleTest::getDefaultProxy()) {
+ SimpleTest::ignore('LiveHttpTestCase');
+}
+
+class LiveHttpTestCase extends UnitTestCase {
+
+ function testBadSocket() {
+ $socket = &new SimpleSocket('bad_url', 111, 5);
+ $this->assertTrue($socket->isError());
+ $this->assertPattern(
+ '/Cannot open \\[bad_url:111\\] with \\[/',
+ $socket->getError());
+ $this->assertFalse($socket->isOpen());
+ $this->assertFalse($socket->write('A message'));
+ }
+
+ function testSocketClosure() {
+ $socket = &new SimpleSocket('www.lastcraft.com', 80, 15, 8);
+ $this->assertTrue($socket->isOpen());
+ $this->assertTrue($socket->write("GET /test/network_confirm.php HTTP/1.0\r\n"));
+ $socket->write("Host: www.lastcraft.com\r\n");
+ $socket->write("Connection: close\r\n\r\n");
+ $this->assertEqual($socket->read(), "HTTP/1.1");
+ $socket->close();
+ $this->assertIdentical($socket->read(), false);
+ }
+
+ function testRecordOfSentCharacters() {
+ $socket = &new SimpleSocket('www.lastcraft.com', 80, 15);
+ $this->assertTrue($socket->write("GET /test/network_confirm.php HTTP/1.0\r\n"));
+ $socket->write("Host: www.lastcraft.com\r\n");
+ $socket->write("Connection: close\r\n\r\n");
+ $socket->close();
+ $this->assertEqual($socket->getSent(),
+ "GET /test/network_confirm.php HTTP/1.0\r\n" .
+ "Host: www.lastcraft.com\r\n" .
+ "Connection: close\r\n\r\n");
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/mock_objects_test.php b/vendors/simpletest/test/mock_objects_test.php
new file mode 100755
index 000000000..a208ff727
--- /dev/null
+++ b/vendors/simpletest/test/mock_objects_test.php
@@ -0,0 +1,994 @@
+<?php
+// $Id: mock_objects_test.php 1700 2008-03-24 16:17:48Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../expectation.php');
+require_once(dirname(__FILE__) . '/../mock_objects.php');
+
+class TestOfAnythingExpectation extends UnitTestCase {
+
+ function testSimpleInteger() {
+ $expectation = new AnythingExpectation();
+ $this->assertTrue($expectation->test(33));
+ $this->assertTrue($expectation->test(false));
+ $this->assertTrue($expectation->test(null));
+ }
+}
+
+class TestOfParametersExpectation extends UnitTestCase {
+
+ function testEmptyMatch() {
+ $expectation = new ParametersExpectation(array());
+ $this->assertTrue($expectation->test(array()));
+ $this->assertFalse($expectation->test(array(33)));
+ }
+
+ function testSingleMatch() {
+ $expectation = new ParametersExpectation(array(0));
+ $this->assertFalse($expectation->test(array(1)));
+ $this->assertTrue($expectation->test(array(0)));
+ }
+
+ function testAnyMatch() {
+ $expectation = new ParametersExpectation(false);
+ $this->assertTrue($expectation->test(array()));
+ $this->assertTrue($expectation->test(array(1, 2)));
+ }
+
+ function testMissingParameter() {
+ $expectation = new ParametersExpectation(array(0));
+ $this->assertFalse($expectation->test(array()));
+ }
+
+ function testNullParameter() {
+ $expectation = new ParametersExpectation(array(null));
+ $this->assertTrue($expectation->test(array(null)));
+ $this->assertFalse($expectation->test(array()));
+ }
+
+ function testAnythingExpectations() {
+ $expectation = new ParametersExpectation(array(new AnythingExpectation()));
+ $this->assertFalse($expectation->test(array()));
+ $this->assertIdentical($expectation->test(array(null)), true);
+ $this->assertIdentical($expectation->test(array(13)), true);
+ }
+
+ function testOtherExpectations() {
+ $expectation = new ParametersExpectation(
+ array(new PatternExpectation('/hello/i')));
+ $this->assertFalse($expectation->test(array('Goodbye')));
+ $this->assertTrue($expectation->test(array('hello')));
+ $this->assertTrue($expectation->test(array('Hello')));
+ }
+
+ function testIdentityOnly() {
+ $expectation = new ParametersExpectation(array("0"));
+ $this->assertFalse($expectation->test(array(0)));
+ $this->assertTrue($expectation->test(array("0")));
+ }
+
+ function testLongList() {
+ $expectation = new ParametersExpectation(
+ array("0", 0, new AnythingExpectation(), false));
+ $this->assertTrue($expectation->test(array("0", 0, 37, false)));
+ $this->assertFalse($expectation->test(array("0", 0, 37, true)));
+ $this->assertFalse($expectation->test(array("0", 0, 37)));
+ }
+}
+
+class TestOfSimpleSignatureMap extends UnitTestCase {
+
+ function testEmpty() {
+ $map = new SimpleSignatureMap();
+ $this->assertFalse($map->isMatch("any", array()));
+ $this->assertNull($map->findFirstAction("any", array()));
+ }
+
+ function testExactReference() {
+ $map = new SimpleSignatureMap();
+ $ref = "Fred";
+ $map->add(array(0), $ref);
+ $this->assertEqual($map->findFirstAction(array(0)), "Fred");
+ $ref2 = &$map->findFirstAction(array(0));
+ $this->assertReference($ref2, $ref);
+ }
+
+ function testDifferentCallSignaturesCanHaveDifferentReferences() {
+ $map = new SimpleSignatureMap();
+ $fred = 'Fred';
+ $jim = 'jim';
+ $map->add(array(0), $fred);
+ $map->add(array('0'), $jim);
+ $this->assertReference($fred, $map->findFirstAction(array(0)));
+ $this->assertReference($jim, $map->findFirstAction(array('0')));
+ }
+
+ function testWildcard() {
+ $fred = 'Fred';
+ $map = new SimpleSignatureMap();
+ $map->add(array(new AnythingExpectation(), 1, 3), $fred);
+ $this->assertTrue($map->isMatch(array(2, 1, 3)));
+ $this->assertReference($map->findFirstAction(array(2, 1, 3)), $fred);
+ }
+
+ function testAllWildcard() {
+ $fred = 'Fred';
+ $map = new SimpleSignatureMap();
+ $this->assertFalse($map->isMatch(array(2, 1, 3)));
+ $map->add('', $fred);
+ $this->assertTrue($map->isMatch(array(2, 1, 3)));
+ $this->assertReference($map->findFirstAction(array(2, 1, 3)), $fred);
+ }
+
+ function testOrdering() {
+ $map = new SimpleSignatureMap();
+ $map->add(array(1, 2), new SimpleByValue("1, 2"));
+ $map->add(array(1, 3), new SimpleByValue("1, 3"));
+ $map->add(array(1), new SimpleByValue("1"));
+ $map->add(array(1, 4), new SimpleByValue("1, 4"));
+ $map->add(array(new AnythingExpectation()), new SimpleByValue("Any"));
+ $map->add(array(2), new SimpleByValue("2"));
+ $map->add("", new SimpleByValue("Default"));
+ $map->add(array(), new SimpleByValue("None"));
+ $this->assertEqual($map->findFirstAction(array(1, 2)), new SimpleByValue("1, 2"));
+ $this->assertEqual($map->findFirstAction(array(1, 3)), new SimpleByValue("1, 3"));
+ $this->assertEqual($map->findFirstAction(array(1, 4)), new SimpleByValue("1, 4"));
+ $this->assertEqual($map->findFirstAction(array(1)), new SimpleByValue("1"));
+ $this->assertEqual($map->findFirstAction(array(2)), new SimpleByValue("Any"));
+ $this->assertEqual($map->findFirstAction(array(3)), new SimpleByValue("Any"));
+ $this->assertEqual($map->findFirstAction(array()), new SimpleByValue("Default"));
+ }
+}
+
+class TestOfCallSchedule extends UnitTestCase {
+ function testCanBeSetToAlwaysReturnTheSameReference() {
+ $a = 5;
+ $schedule = &new SimpleCallSchedule();
+ $schedule->register('aMethod', false, new SimpleByReference($a));
+ $this->assertReference($schedule->respond(0, 'aMethod', array()), $a);
+ $this->assertReference($schedule->respond(1, 'aMethod', array()), $a);
+ }
+
+ function testSpecificSignaturesOverrideTheAlwaysCase() {
+ $any = 'any';
+ $one = 'two';
+ $schedule = &new SimpleCallSchedule();
+ $schedule->register('aMethod', array(1), new SimpleByReference($one));
+ $schedule->register('aMethod', false, new SimpleByReference($any));
+ $this->assertReference($schedule->respond(0, 'aMethod', array(2)), $any);
+ $this->assertReference($schedule->respond(0, 'aMethod', array(1)), $one);
+ }
+
+ function testReturnsCanBeSetOverTime() {
+ $one = 'one';
+ $two = 'two';
+ $schedule = &new SimpleCallSchedule();
+ $schedule->registerAt(0, 'aMethod', false, new SimpleByReference($one));
+ $schedule->registerAt(1, 'aMethod', false, new SimpleByReference($two));
+ $this->assertReference($schedule->respond(0, 'aMethod', array()), $one);
+ $this->assertReference($schedule->respond(1, 'aMethod', array()), $two);
+ }
+
+ function testReturnsOverTimecanBeAlteredByTheArguments() {
+ $one = '1';
+ $two = '2';
+ $two_a = '2a';
+ $schedule = &new SimpleCallSchedule();
+ $schedule->registerAt(0, 'aMethod', false, new SimpleByReference($one));
+ $schedule->registerAt(1, 'aMethod', array('a'), new SimpleByReference($two_a));
+ $schedule->registerAt(1, 'aMethod', false, new SimpleByReference($two));
+ $this->assertReference($schedule->respond(0, 'aMethod', array()), $one);
+ $this->assertReference($schedule->respond(1, 'aMethod', array()), $two);
+ $this->assertReference($schedule->respond(1, 'aMethod', array('a')), $two_a);
+ }
+
+ function testCanReturnByValue() {
+ $a = 5;
+ $schedule = &new SimpleCallSchedule();
+ $schedule->register('aMethod', false, new SimpleByValue($a));
+ $this->assertClone($schedule->respond(0, 'aMethod', array()), $a);
+ }
+
+ function testCanThrowException() {
+ if (version_compare(phpversion(), '5', '>=')) {
+ $schedule = &new SimpleCallSchedule();
+ $schedule->register('aMethod', false, new SimpleThrower(new Exception('Ouch')));
+ $this->expectException(new Exception('Ouch'));
+ $schedule->respond(0, 'aMethod', array());
+ }
+ }
+
+ function testCanEmitError() {
+ $schedule = &new SimpleCallSchedule();
+ $schedule->register('aMethod', false, new SimpleErrorThrower('Ouch', E_USER_WARNING));
+ $this->expectError('Ouch');
+ $schedule->respond(0, 'aMethod', array());
+ }
+}
+
+class Dummy {
+ function Dummy() {
+ }
+
+ function aMethod() {
+ return true;
+ }
+
+ function anotherMethod() {
+ return true;
+ }
+}
+Mock::generate('Dummy');
+Mock::generate('Dummy', 'AnotherMockDummy');
+Mock::generate('Dummy', 'MockDummyWithExtraMethods', array('extraMethod'));
+
+class TestOfMockGeneration extends UnitTestCase {
+
+ function testCloning() {
+ $mock = &new MockDummy();
+ $this->assertTrue(method_exists($mock, "aMethod"));
+ $this->assertNull($mock->aMethod());
+ }
+
+ function testCloningWithExtraMethod() {
+ $mock = &new MockDummyWithExtraMethods();
+ $this->assertTrue(method_exists($mock, "extraMethod"));
+ }
+
+ function testCloningWithChosenClassName() {
+ $mock = &new AnotherMockDummy();
+ $this->assertTrue(method_exists($mock, "aMethod"));
+ }
+}
+
+class TestOfMockReturns extends UnitTestCase {
+
+ function testDefaultReturn() {
+ $mock = &new MockDummy();
+ $mock->setReturnValue("aMethod", "aaa");
+ $this->assertIdentical($mock->aMethod(), "aaa");
+ $this->assertIdentical($mock->aMethod(), "aaa");
+ }
+
+ function testParameteredReturn() {
+ $mock = &new MockDummy();
+ $mock->setReturnValue('aMethod', 'aaa', array(1, 2, 3));
+ $this->assertNull($mock->aMethod());
+ $this->assertIdentical($mock->aMethod(1, 2, 3), 'aaa');
+ }
+
+ function testReferenceReturned() {
+ $mock = &new MockDummy();
+ $object = new Dummy();
+ $mock->setReturnReference('aMethod', $object, array(1, 2, 3));
+ $this->assertReference($zref = &$mock->aMethod(1, 2, 3), $object);
+ }
+
+ function testPatternMatchReturn() {
+ $mock = &new MockDummy();
+ $mock->setReturnValue(
+ "aMethod",
+ "aaa",
+ array(new PatternExpectation('/hello/i')));
+ $this->assertIdentical($mock->aMethod('Hello'), "aaa");
+ $this->assertNull($mock->aMethod('Goodbye'));
+ }
+
+ function testMultipleMethods() {
+ $mock = &new MockDummy();
+ $mock->setReturnValue("aMethod", 100, array(1));
+ $mock->setReturnValue("aMethod", 200, array(2));
+ $mock->setReturnValue("anotherMethod", 10, array(1));
+ $mock->setReturnValue("anotherMethod", 20, array(2));
+ $this->assertIdentical($mock->aMethod(1), 100);
+ $this->assertIdentical($mock->anotherMethod(1), 10);
+ $this->assertIdentical($mock->aMethod(2), 200);
+ $this->assertIdentical($mock->anotherMethod(2), 20);
+ }
+
+ function testReturnSequence() {
+ $mock = &new MockDummy();
+ $mock->setReturnValueAt(0, "aMethod", "aaa");
+ $mock->setReturnValueAt(1, "aMethod", "bbb");
+ $mock->setReturnValueAt(3, "aMethod", "ddd");
+ $this->assertIdentical($mock->aMethod(), "aaa");
+ $this->assertIdentical($mock->aMethod(), "bbb");
+ $this->assertNull($mock->aMethod());
+ $this->assertIdentical($mock->aMethod(), "ddd");
+ }
+
+ function testReturnReferenceSequence() {
+ $mock = &new MockDummy();
+ $object = new Dummy();
+ $mock->setReturnReferenceAt(1, "aMethod", $object);
+ $this->assertNull($mock->aMethod());
+ $this->assertReference($zref =& $mock->aMethod(), $object);
+ $this->assertNull($mock->aMethod());
+ }
+
+ function testComplicatedReturnSequence() {
+ $mock = &new MockDummy();
+ $object = new Dummy();
+ $mock->setReturnValueAt(1, "aMethod", "aaa", array("a"));
+ $mock->setReturnValueAt(1, "aMethod", "bbb");
+ $mock->setReturnReferenceAt(2, "aMethod", $object, array('*', 2));
+ $mock->setReturnValueAt(2, "aMethod", "value", array('*', 3));
+ $mock->setReturnValue("aMethod", 3, array(3));
+ $this->assertNull($mock->aMethod());
+ $this->assertEqual($mock->aMethod("a"), "aaa");
+ $this->assertReference($zref =& $mock->aMethod(1, 2), $object);
+ $this->assertEqual($mock->aMethod(3), 3);
+ $this->assertNull($mock->aMethod());
+ }
+
+ function testMultipleMethodSequences() {
+ $mock = &new MockDummy();
+ $mock->setReturnValueAt(0, "aMethod", "aaa");
+ $mock->setReturnValueAt(1, "aMethod", "bbb");
+ $mock->setReturnValueAt(0, "anotherMethod", "ccc");
+ $mock->setReturnValueAt(1, "anotherMethod", "ddd");
+ $this->assertIdentical($mock->aMethod(), "aaa");
+ $this->assertIdentical($mock->anotherMethod(), "ccc");
+ $this->assertIdentical($mock->aMethod(), "bbb");
+ $this->assertIdentical($mock->anotherMethod(), "ddd");
+ }
+
+ function testSequenceFallback() {
+ $mock = &new MockDummy();
+ $mock->setReturnValueAt(0, "aMethod", "aaa", array('a'));
+ $mock->setReturnValueAt(1, "aMethod", "bbb", array('a'));
+ $mock->setReturnValue("aMethod", "AAA");
+ $this->assertIdentical($mock->aMethod('a'), "aaa");
+ $this->assertIdentical($mock->aMethod('b'), "AAA");
+ }
+
+ function testMethodInterference() {
+ $mock = &new MockDummy();
+ $mock->setReturnValueAt(0, "anotherMethod", "aaa");
+ $mock->setReturnValue("aMethod", "AAA");
+ $this->assertIdentical($mock->aMethod(), "AAA");
+ $this->assertIdentical($mock->anotherMethod(), "aaa");
+ }
+}
+
+class TestOfMockExpectationsThatPass extends UnitTestCase {
+
+ function testAnyArgument() {
+ $mock = &new MockDummy();
+ $mock->expect('aMethod', array('*'));
+ $mock->aMethod(1);
+ $mock->aMethod('hello');
+ }
+
+ function testAnyTwoArguments() {
+ $mock = &new MockDummy();
+ $mock->expect('aMethod', array('*', '*'));
+ $mock->aMethod(1, 2);
+ }
+
+ function testSpecificArgument() {
+ $mock = &new MockDummy();
+ $mock->expect('aMethod', array(1));
+ $mock->aMethod(1);
+ }
+
+ function testExpectation() {
+ $mock = &new MockDummy();
+ $mock->expect('aMethod', array(new IsAExpectation('Dummy')));
+ $mock->aMethod(new Dummy());
+ }
+
+ function testArgumentsInSequence() {
+ $mock = &new MockDummy();
+ $mock->expectAt(0, 'aMethod', array(1, 2));
+ $mock->expectAt(1, 'aMethod', array(3, 4));
+ $mock->aMethod(1, 2);
+ $mock->aMethod(3, 4);
+ }
+
+ function testAtLeastOnceSatisfiedByOneCall() {
+ $mock = &new MockDummy();
+ $mock->expectAtLeastOnce('aMethod');
+ $mock->aMethod();
+ }
+
+ function testAtLeastOnceSatisfiedByTwoCalls() {
+ $mock = &new MockDummy();
+ $mock->expectAtLeastOnce('aMethod');
+ $mock->aMethod();
+ $mock->aMethod();
+ }
+
+ function testOnceSatisfiedByOneCall() {
+ $mock = &new MockDummy();
+ $mock->expectOnce('aMethod');
+ $mock->aMethod();
+ }
+
+ function testMinimumCallsSatisfiedByEnoughCalls() {
+ $mock = &new MockDummy();
+ $mock->expectMinimumCallCount('aMethod', 1);
+ $mock->aMethod();
+ }
+
+ function testMinimumCallsSatisfiedByTooManyCalls() {
+ $mock = &new MockDummy();
+ $mock->expectMinimumCallCount('aMethod', 3);
+ $mock->aMethod();
+ $mock->aMethod();
+ $mock->aMethod();
+ $mock->aMethod();
+ }
+
+ function testMaximumCallsSatisfiedByEnoughCalls() {
+ $mock = &new MockDummy();
+ $mock->expectMaximumCallCount('aMethod', 1);
+ $mock->aMethod();
+ }
+
+ function testMaximumCallsSatisfiedByNoCalls() {
+ $mock = &new MockDummy();
+ $mock->expectMaximumCallCount('aMethod', 1);
+ }
+}
+
+class MockWithInjectedTestCase extends SimpleMock {
+ function &_getCurrentTestCase() {
+ $context = &SimpleTest::getContext();
+ $test = &$context->getTest();
+ return $test->getMockedTest();
+ }
+}
+SimpleTest::setMockBaseClass('MockWithInjectedTestCase');
+Mock::generate('Dummy', 'MockDummyWithInjectedTestCase');
+SimpleTest::setMockBaseClass('SimpleMock');
+Mock::generate('SimpleTestCase');
+
+class LikeExpectation extends IdenticalExpectation {
+ function LikeExpectation($expectation) {
+ $expectation->_message = '';
+ $this->IdenticalExpectation($expectation);
+ }
+
+ function test($compare) {
+ $compare->_message = '';
+ return parent::test($compare);
+ }
+
+ function testMessage($compare) {
+ $compare->_message = '';
+ return parent::testMessage($compare);
+ }
+}
+
+class TestOfMockExpectations extends UnitTestCase {
+ var $test;
+
+ function setUp() {
+ $this->test = &new MockSimpleTestCase();
+ }
+
+ function &getMockedTest() {
+ return $this->test;
+ }
+
+ function testSettingExpectationOnNonMethodThrowsError() {
+ $mock = &new MockDummyWithInjectedTestCase();
+ $mock->expectMaximumCallCount('aMissingMethod', 2);
+ $this->assertError();
+ }
+
+ function testMaxCallsDetectsOverrun() {
+ $this->test->expectOnce('assert', array(
+ new LikeExpectation(new MaximumCallCountExpectation('aMethod', 2)),
+ 3));
+ $mock = &new MockDummyWithInjectedTestCase();
+ $mock->expectMaximumCallCount('aMethod', 2);
+ $mock->aMethod();
+ $mock->aMethod();
+ $mock->aMethod();
+ $mock->_mock->atTestEnd('testSomething', $this->test);
+ }
+
+ function testTallyOnMaxCallsSendsPassOnUnderrun() {
+ $this->test->expectOnce('assert', array(
+ new LikeExpectation(new MaximumCallCountExpectation('aMethod', 2)),
+ 2));
+ $mock = &new MockDummyWithInjectedTestCase();
+ $mock->expectMaximumCallCount("aMethod", 2);
+ $mock->aMethod();
+ $mock->aMethod();
+ $mock->_mock->atTestEnd('testSomething', $this->test);
+ }
+
+ function testExpectNeverDetectsOverrun() {
+ $this->test->expectOnce('assert', array(
+ new LikeExpectation(new MaximumCallCountExpectation('aMethod', 0)),
+ 1));
+ $mock = &new MockDummyWithInjectedTestCase();
+ $mock->expectNever('aMethod');
+ $mock->aMethod();
+ $mock->_mock->atTestEnd('testSomething', $this->test);
+ }
+
+ function testTallyOnExpectNeverStillSendsPassOnUnderrun() {
+ $this->test->expectOnce('assert', array(
+ new LikeExpectation(new MaximumCallCountExpectation('aMethod', 0)),
+ 0));
+ $mock = &new MockDummyWithInjectedTestCase();
+ $mock->expectNever('aMethod');
+ $mock->_mock->atTestEnd('testSomething', $this->test);
+ }
+
+ function testMinCalls() {
+ $this->test->expectOnce('assert', array(
+ new LikeExpectation(new MinimumCallCountExpectation('aMethod', 2)),
+ 2));
+ $mock = &new MockDummyWithInjectedTestCase();
+ $mock->expectMinimumCallCount('aMethod', 2);
+ $mock->aMethod();
+ $mock->aMethod();
+ $mock->_mock->atTestEnd('testSomething', $this->test);
+ }
+
+ function testFailedNever() {
+ $this->test->expectOnce('assert', array(
+ new LikeExpectation(new MaximumCallCountExpectation('aMethod', 0)),
+ 1));
+ $mock = &new MockDummyWithInjectedTestCase();
+ $mock->expectNever('aMethod');
+ $mock->aMethod();
+ $mock->_mock->atTestEnd('testSomething', $this->test);
+ }
+
+ function testUnderOnce() {
+ $this->test->expectOnce('assert', array(
+ new LikeExpectation(new CallCountExpectation('aMethod', 1)),
+ 0));
+ $mock = &new MockDummyWithInjectedTestCase();
+ $mock->expectOnce('aMethod');
+ $mock->_mock->atTestEnd('testSomething', $this->test);
+ }
+
+ function testOverOnce() {
+ $this->test->expectOnce('assert', array(
+ new LikeExpectation(new CallCountExpectation('aMethod', 1)),
+ 2));
+ $mock = &new MockDummyWithInjectedTestCase();
+ $mock->expectOnce('aMethod');
+ $mock->aMethod();
+ $mock->aMethod();
+ $mock->_mock->atTestEnd('testSomething', $this->test);
+ }
+
+ function testUnderAtLeastOnce() {
+ $this->test->expectOnce('assert', array(
+ new LikeExpectation(new MinimumCallCountExpectation('aMethod', 1)),
+ 0));
+ $mock = &new MockDummyWithInjectedTestCase();
+ $mock->expectAtLeastOnce("aMethod");
+ $mock->_mock->atTestEnd('testSomething', $this->test);
+ }
+
+ function testZeroArguments() {
+ $this->test->expectOnce('assert', array(
+ new LikeExpectation(new ParametersExpectation(array())),
+ array(),
+ '*'));
+ $mock = &new MockDummyWithInjectedTestCase();
+ $mock->expect("aMethod", array());
+ $mock->aMethod();
+ $mock->_mock->atTestEnd('testSomething', $this->test);
+ }
+
+ function testExpectedArguments() {
+ $this->test->expectOnce('assert', array(
+ new LikeExpectation(new ParametersExpectation(array(1, 2, 3))),
+ array(1, 2, 3),
+ '*'));
+ $mock = &new MockDummyWithInjectedTestCase();
+ $mock->expect('aMethod', array(1, 2, 3));
+ $mock->aMethod(1, 2, 3);
+ $mock->_mock->atTestEnd('testSomething', $this->test);
+ }
+
+ function testFailedArguments() {
+ $this->test->expectOnce('assert', array(
+ new LikeExpectation(new ParametersExpectation(array('this'))),
+ array('that'),
+ '*'));
+ $mock = &new MockDummyWithInjectedTestCase();
+ $mock->expect('aMethod', array('this'));
+ $mock->aMethod('that');
+ $mock->_mock->atTestEnd('testSomething', $this->test);
+ }
+
+ function testWildcardsAreTranslatedToAnythingExpectations() {
+ $this->test->expectOnce('assert', array(
+ new LikeExpectation(new ParametersExpectation(array(
+ new AnythingExpectation(), 123, new AnythingExpectation()))),
+ array(100, 123, 101),
+ '*'));
+ $mock = &new MockDummyWithInjectedTestCase($this);
+ $mock->expect("aMethod", array('*', 123, '*'));
+ $mock->aMethod(100, 123, 101);
+ $mock->_mock->atTestEnd('testSomething', $this->test);
+ }
+
+ function testSpecificPassingSequence() {
+ $this->test->expectAt(0, 'assert', array(
+ new LikeExpectation(new ParametersExpectation(array(1, 2, 3))),
+ array(1, 2, 3),
+ '*'));
+ $this->test->expectAt(1, 'assert', array(
+ new LikeExpectation(new ParametersExpectation(array('Hello'))),
+ array('Hello'),
+ '*'));
+ $mock = &new MockDummyWithInjectedTestCase();
+ $mock->expectAt(1, 'aMethod', array(1, 2, 3));
+ $mock->expectAt(2, 'aMethod', array('Hello'));
+ $mock->aMethod();
+ $mock->aMethod(1, 2, 3);
+ $mock->aMethod('Hello');
+ $mock->aMethod();
+ $mock->_mock->atTestEnd('testSomething', $this->test);
+ }
+
+ function testNonArrayForExpectedParametersGivesError() {
+ $mock = &new MockDummyWithInjectedTestCase();
+ $mock->expect("aMethod", "foo");
+ $this->assertErrorPattern('/\$args.*not an array/i');
+ $mock->aMethod();
+ $mock->tally();
+ $mock->_mock->atTestEnd('testSomething', $this->test);
+ }
+}
+
+class TestOfMockComparisons extends UnitTestCase {
+
+ function testEqualComparisonOfMocksDoesNotCrash() {
+ $expectation = &new EqualExpectation(new MockDummy());
+ $this->assertTrue($expectation->test(new MockDummy(), true));
+ }
+
+ function testIdenticalComparisonOfMocksDoesNotCrash() {
+ $expectation = &new IdenticalExpectation(new MockDummy());
+ $this->assertTrue($expectation->test(new MockDummy()));
+ }
+}
+
+class ClassWithSpecialMethods {
+ function __get($name) { }
+ function __set($name, $value) { }
+ function __isset($name) { }
+ function __unset($name) { }
+ function __call($method, $arguments) { }
+ function __toString() { }
+}
+Mock::generate('ClassWithSpecialMethods');
+
+class TestOfSpecialMethods extends UnitTestCase {
+ function skip() {
+ $this->skipIf(version_compare(phpversion(), '5', '<='), 'Overloading not tested unless PHP 5+');
+ }
+
+ function testCanMockTheThingAtAll() {
+ $mock = new MockClassWithSpecialMethods();
+ }
+
+ function testReturnFromSpecialAccessor() {
+ $mock = &new MockClassWithSpecialMethods();
+ $mock->setReturnValue('__get', '1st Return', array('first'));
+ $mock->setReturnValue('__get', '2nd Return', array('second'));
+ $this->assertEqual($mock->first, '1st Return');
+ $this->assertEqual($mock->second, '2nd Return');
+ }
+
+ function testcanExpectTheSettingOfValue() {
+ $mock = &new MockClassWithSpecialMethods();
+ $mock->expectOnce('__set', array('a', 'A'));
+ $mock->a = 'A';
+ }
+
+ function testCanSimulateAnOverloadmethod() {
+ $mock = &new MockClassWithSpecialMethods();
+ $mock->expectOnce('__call', array('amOverloaded', array('A')));
+ $mock->setReturnValue('__call', 'aaa');
+ $this->assertIdentical($mock->amOverloaded('A'), 'aaa');
+ }
+
+ function testCanEmulateIsset() {
+ $mock = &new MockClassWithSpecialMethods();
+ $mock->setReturnValue('__isset', true);
+ $this->assertIdentical(isset($mock->a), true);
+ }
+
+ function testCanExpectUnset() {
+ $mock = &new MockClassWithSpecialMethods();
+ $mock->expectOnce('__unset', array('a'));
+ unset($mock->a);
+ }
+
+ function testToStringMagic() {
+ $mock = &new MockClassWithSpecialMethods();
+ $mock->expectOnce('__toString');
+ $mock->setReturnValue('__toString', 'AAA');
+ ob_start();
+ print $mock;
+ $output = ob_get_contents();
+ ob_end_clean();
+ $this->assertEqual($output, 'AAA');
+ }
+}
+
+if (version_compare(phpversion(), '5', '>=')) {
+ $class = 'class WithStaticMethod { ';
+ $class .= ' static function aStaticMethod() { } ';
+ $class .= '}';
+ eval($class);
+}
+Mock::generate('WithStaticMethod');
+
+class TestOfMockingClassesWithStaticMethods extends UnitTestCase {
+ function skip() {
+ $this->skipUnless(version_compare(phpversion(), '5', '>='), 'Static methods not tested unless PHP 5+');
+ }
+
+ function testStaticMethodIsMockedAsStatic() {
+ $mock = new WithStaticMethod();
+ $reflection = new ReflectionClass($mock);
+ $method = $reflection->getMethod('aStaticMethod');
+ $this->assertTrue($method->isStatic());
+ }
+}
+
+if (version_compare(phpversion(), '5', '>=')) {
+ class MockTestException extends Exception { }
+}
+
+class TestOfThrowingExceptionsFromMocks extends UnitTestCase {
+ function skip() {
+ $this->skipUnless(version_compare(phpversion(), '5', '>='), 'Exception throwing not tested unless PHP 5+');
+ }
+
+ function testCanThrowOnMethodCall() {
+ $mock = new MockDummy();
+ $mock->throwOn('aMethod');
+ $this->expectException();
+ $mock->aMethod();
+ }
+
+ function testCanThrowSpecificExceptionOnMethodCall() {
+ $mock = new MockDummy();
+ $mock->throwOn('aMethod', new MockTestException());
+ $this->expectException();
+ $mock->aMethod();
+ }
+
+ function testThrowsOnlyWhenCallSignatureMatches() {
+ $mock = new MockDummy();
+ $mock->throwOn('aMethod', new MockTestException(), array(3));
+ $mock->aMethod(1);
+ $mock->aMethod(2);
+ $this->expectException();
+ $mock->aMethod(3);
+ }
+
+ function testCanThrowOnParticularInvocation() {
+ $mock = new MockDummy();
+ $mock->throwAt(2, 'aMethod', new MockTestException());
+ $mock->aMethod();
+ $mock->aMethod();
+ $this->expectException();
+ $mock->aMethod();
+ }
+}
+
+class TestOfThrowingErrorsFromMocks extends UnitTestCase {
+
+ function testCanGenerateErrorFromMethodCall() {
+ $mock = new MockDummy();
+ $mock->errorOn('aMethod', 'Ouch!');
+ $this->expectError('Ouch!');
+ $mock->aMethod();
+ }
+
+ function testGeneratesErrorOnlyWhenCallSignatureMatches() {
+ $mock = new MockDummy();
+ $mock->errorOn('aMethod', 'Ouch!', array(3));
+ $mock->aMethod(1);
+ $mock->aMethod(2);
+ $this->expectError();
+ $mock->aMethod(3);
+ }
+
+ function testCanGenerateErrorOnParticularInvocation() {
+ $mock = new MockDummy();
+ $mock->errorAt(2, 'aMethod', 'Ouch!');
+ $mock->aMethod();
+ $mock->aMethod();
+ $this->expectError();
+ $mock->aMethod();
+ }
+}
+
+Mock::generatePartial('Dummy', 'TestDummy', array('anotherMethod'));
+
+class TestOfPartialMocks extends UnitTestCase {
+
+ function testMethodReplacementWithNoBehaviourReturnsNull() {
+ $mock = &new TestDummy();
+ $this->assertEqual($mock->aMethod(99), 99);
+ $this->assertNull($mock->anotherMethod());
+ }
+
+ function testSettingReturns() {
+ $mock = &new TestDummy();
+ $mock->setReturnValue('anotherMethod', 33, array(3));
+ $mock->setReturnValue('anotherMethod', 22);
+ $mock->setReturnValueAt(2, 'anotherMethod', 44, array(3));
+ $this->assertEqual($mock->anotherMethod(), 22);
+ $this->assertEqual($mock->anotherMethod(3), 33);
+ $this->assertEqual($mock->anotherMethod(3), 44);
+ }
+
+ function testReferences() {
+ $mock = &new TestDummy();
+ $object = new Dummy();
+ $mock->setReturnReferenceAt(0, 'anotherMethod', $object, array(3));
+ $this->assertReference($zref =& $mock->anotherMethod(3), $object);
+ }
+
+ function testExpectations() {
+ $mock = &new TestDummy();
+ $mock->expectCallCount('anotherMethod', 2);
+ $mock->expect('anotherMethod', array(77));
+ $mock->expectAt(1, 'anotherMethod', array(66));
+ $mock->anotherMethod(77);
+ $mock->anotherMethod(66);
+ }
+
+ function testSettingExpectationOnMissingMethodThrowsError() {
+ $mock = &new TestDummy();
+ $mock->expectCallCount('aMissingMethod', 2);
+ $this->assertError();
+ }
+}
+
+class ConstructorSuperClass {
+ function ConstructorSuperClass() { }
+}
+
+class ConstructorSubClass extends ConstructorSuperClass {
+}
+
+class TestOfPHP4StyleSuperClassConstruct extends UnitTestCase {
+ /*
+ * This addresses issue #1231401. Without the fix in place, this will
+ * generate a fatal PHP error.
+ */
+ function testBasicConstruct() {
+ Mock::generate('ConstructorSubClass');
+ $mock = &new MockConstructorSubClass();
+ $this->assertIsA($mock, 'ConstructorSubClass');
+ $this->assertTrue(method_exists($mock, 'ConstructorSuperClass'));
+ }
+}
+
+class TestOfPHP5StaticMethodMocking extends UnitTestCase {
+ function skip() {
+ $this->skipIf(version_compare(phpversion(), '5', '<='), 'Static methods not tested unless PHP 5+');
+ }
+
+ function testCanCreateAMockObjectWithStaticMethodsWithoutError() {
+ eval('
+ class SimpleObjectContainingStaticMethod {
+ static function someStatic() { }
+ }
+ ');
+
+ Mock::generate('SimpleObjectContainingStaticMethod');
+ $this->assertNoErrors();
+ }
+}
+
+class TestOfPHP5AbstractMethodMocking extends UnitTestCase {
+ function skip() {
+ $this->skipIf(version_compare(phpversion(), '5', '<='), 'Abstract class/methods not tested unless PHP 5+');
+ }
+
+ function testCanCreateAMockObjectFromAnAbstractWithProperFunctionDeclarations() {
+ eval('
+ abstract class SimpleAbstractClassContainingAbstractMethods {
+ abstract function anAbstract();
+ abstract function anAbstractWithParameter($foo);
+ abstract function anAbstractWithMultipleParameters($foo, $bar);
+ }
+ ');
+
+ Mock::generate('SimpleAbstractClassContainingAbstractMethods');
+ $this->assertNoErrors();
+
+ $this->assertTrue(
+ method_exists(
+ 'MockSimpleAbstractClassContainingAbstractMethods',
+ 'anAbstract'
+ )
+ );
+ $this->assertTrue(
+ method_exists(
+ 'MockSimpleAbstractClassContainingAbstractMethods',
+ 'anAbstractWithParameter'
+ )
+ );
+ $this->assertTrue(
+ method_exists(
+ 'MockSimpleAbstractClassContainingAbstractMethods',
+ 'anAbstractWithMultipleParameters'
+ )
+ );
+ }
+
+ function testMethodsDefinedAsAbstractInParentShouldHaveFullSignature() {
+ eval('
+ abstract class SimpleParentAbstractClassContainingAbstractMethods {
+ abstract function anAbstract();
+ abstract function anAbstractWithParameter($foo);
+ abstract function anAbstractWithMultipleParameters($foo, $bar);
+ }
+
+ class SimpleChildAbstractClassContainingAbstractMethods extends SimpleParentAbstractClassContainingAbstractMethods {
+ function anAbstract(){}
+ function anAbstractWithParameter($foo){}
+ function anAbstractWithMultipleParameters($foo, $bar){}
+ }
+
+ class EvenDeeperEmptyChildClass extends SimpleChildAbstractClassContainingAbstractMethods {}
+ ');
+
+ Mock::generate('SimpleChildAbstractClassContainingAbstractMethods');
+ $this->assertNoErrors();
+
+ $this->assertTrue(
+ method_exists(
+ 'MockSimpleChildAbstractClassContainingAbstractMethods',
+ 'anAbstract'
+ )
+ );
+ $this->assertTrue(
+ method_exists(
+ 'MockSimpleChildAbstractClassContainingAbstractMethods',
+ 'anAbstractWithParameter'
+ )
+ );
+ $this->assertTrue(
+ method_exists(
+ 'MockSimpleChildAbstractClassContainingAbstractMethods',
+ 'anAbstractWithMultipleParameters'
+ )
+ );
+
+ Mock::generate('EvenDeeperEmptyChildClass');
+ $this->assertNoErrors();
+
+ $this->assertTrue(
+ method_exists(
+ 'MockEvenDeeperEmptyChildClass',
+ 'anAbstract'
+ )
+ );
+ $this->assertTrue(
+ method_exists(
+ 'MockEvenDeeperEmptyChildClass',
+ 'anAbstractWithParameter'
+ )
+ );
+ $this->assertTrue(
+ method_exists(
+ 'MockEvenDeeperEmptyChildClass',
+ 'anAbstractWithMultipleParameters'
+ )
+ );
+ }
+}
+
+?>
diff --git a/vendors/simpletest/test/page_test.php b/vendors/simpletest/test/page_test.php
new file mode 100755
index 000000000..76e6a515b
--- /dev/null
+++ b/vendors/simpletest/test/page_test.php
@@ -0,0 +1,903 @@
+<?php
+// $Id: page_test.php 1559 2007-07-16 18:13:24Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../expectation.php');
+require_once(dirname(__FILE__) . '/../http.php');
+require_once(dirname(__FILE__) . '/../page.php');
+require_once(dirname(__FILE__) . '/../parser.php');
+Mock::generate('SimpleHtmlSaxParser');
+Mock::generate('SimplePage');
+Mock::generate('SimpleHttpResponse');
+Mock::generate('SimpleHttpHeaders');
+Mock::generate('SimplePageBuilder');
+Mock::generatePartial(
+ 'SimplePageBuilder',
+ 'PartialSimplePageBuilder',
+ array('_createPage', '_createParser'));
+
+class TestOfPageBuilder extends UnitTestCase {
+
+ function testLink() {
+ $tag = &new SimpleAnchorTag(array('href' => 'http://somewhere'));
+ $tag->addContent('Label');
+
+ $page = &new MockSimplePage();
+ $page->expectArguments('acceptTag', array($tag));
+ $page->expectCallCount('acceptTag', 1);
+
+ $builder = &new PartialSimplePageBuilder();
+ $builder->setReturnReference('_createPage', $page);
+ $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
+ $builder->SimplePageBuilder();
+
+ $builder->parse(new MockSimpleHttpResponse());
+ $this->assertTrue($builder->startElement(
+ 'a',
+ array('href' => 'http://somewhere')));
+ $this->assertTrue($builder->addContent('Label'));
+ $this->assertTrue($builder->endElement('a'));
+ }
+
+ function testLinkWithId() {
+ $tag = &new SimpleAnchorTag(array("href" => "http://somewhere", "id" => "44"));
+ $tag->addContent("Label");
+
+ $page = &new MockSimplePage();
+ $page->expectArguments("acceptTag", array($tag));
+ $page->expectCallCount("acceptTag", 1);
+
+ $builder = &new PartialSimplePageBuilder();
+ $builder->setReturnReference('_createPage', $page);
+ $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
+ $builder->SimplePageBuilder();
+
+ $builder->parse(new MockSimpleHttpResponse());
+ $this->assertTrue($builder->startElement(
+ "a",
+ array("href" => "http://somewhere", "id" => "44")));
+ $this->assertTrue($builder->addContent("Label"));
+ $this->assertTrue($builder->endElement("a"));
+ }
+
+ function testLinkExtraction() {
+ $tag = &new SimpleAnchorTag(array("href" => "http://somewhere"));
+ $tag->addContent("Label");
+
+ $page = &new MockSimplePage();
+ $page->expectArguments("acceptTag", array($tag));
+ $page->expectCallCount("acceptTag", 1);
+
+ $builder = &new PartialSimplePageBuilder();
+ $builder->setReturnReference('_createPage', $page);
+ $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
+ $builder->SimplePageBuilder();
+
+ $builder->parse(new MockSimpleHttpResponse());
+ $this->assertTrue($builder->addContent("Starting stuff"));
+ $this->assertTrue($builder->startElement(
+ "a",
+ array("href" => "http://somewhere")));
+ $this->assertTrue($builder->addContent("Label"));
+ $this->assertTrue($builder->endElement("a"));
+ $this->assertTrue($builder->addContent("Trailing stuff"));
+ }
+
+ function testMultipleLinks() {
+ $a1 = new SimpleAnchorTag(array("href" => "http://somewhere"));
+ $a1->addContent("1");
+
+ $a2 = new SimpleAnchorTag(array("href" => "http://elsewhere"));
+ $a2->addContent("2");
+
+ $page = &new MockSimplePage();
+ $page->expectArgumentsAt(0, "acceptTag", array($a1));
+ $page->expectArgumentsAt(1, "acceptTag", array($a2));
+ $page->expectCallCount("acceptTag", 2);
+
+ $builder = &new PartialSimplePageBuilder();
+ $builder->setReturnReference('_createPage', $page);
+ $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
+ $builder->SimplePageBuilder();
+
+ $builder->parse(new MockSimpleHttpResponse());
+ $builder->startElement("a", array("href" => "http://somewhere"));
+ $builder->addContent("1");
+ $builder->endElement("a");
+ $builder->addContent("Padding");
+ $builder->startElement("a", array("href" => "http://elsewhere"));
+ $builder->addContent("2");
+ $builder->endElement("a");
+ }
+
+ function testTitle() {
+ $tag = &new SimpleTitleTag(array());
+ $tag->addContent("HereThere");
+
+ $page = &new MockSimplePage();
+ $page->expectArguments("acceptTag", array($tag));
+ $page->expectCallCount("acceptTag", 1);
+
+ $builder = &new PartialSimplePageBuilder();
+ $builder->setReturnReference('_createPage', $page);
+ $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
+ $builder->SimplePageBuilder();
+
+ $builder->parse(new MockSimpleHttpResponse());
+ $builder->startElement("title", array());
+ $builder->addContent("Here");
+ $builder->addContent("There");
+ $builder->endElement("title");
+ }
+
+ function testForm() {
+ $page = &new MockSimplePage();
+ $page->expectOnce("acceptFormStart", array(new SimpleFormTag(array())));
+ $page->expectOnce("acceptFormEnd", array());
+
+ $builder = &new PartialSimplePageBuilder();
+ $builder->setReturnReference('_createPage', $page);
+ $builder->setReturnReference('_createParser', new MockSimpleHtmlSaxParser());
+ $builder->SimplePageBuilder();
+
+ $builder->parse(new MockSimpleHttpResponse());
+ $builder->startElement("form", array());
+ $builder->addContent("Stuff");
+ $builder->endElement("form");
+ }
+}
+
+class TestOfPageParsing extends UnitTestCase {
+
+ function testParseMechanics() {
+ $parser = &new MockSimpleHtmlSaxParser();
+ $parser->expectOnce('parse', array('stuff'));
+
+ $page = &new MockSimplePage();
+ $page->expectOnce('acceptPageEnd');
+
+ $builder = &new PartialSimplePageBuilder();
+ $builder->setReturnReference('_createPage', $page);
+ $builder->setReturnReference('_createParser', $parser);
+ $builder->SimplePageBuilder();
+
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent', 'stuff');
+ $builder->parse($response);
+ }
+}
+
+class TestOfPageInterface extends UnitTestCase {
+
+ function testInterfaceOnEmptyPage() {
+ $page = &new SimplePage();
+ $this->assertEqual($page->getTransportError(), 'No page fetched yet');
+ $this->assertIdentical($page->getRaw(), false);
+ $this->assertIdentical($page->getHeaders(), false);
+ $this->assertIdentical($page->getMimeType(), false);
+ $this->assertIdentical($page->getResponseCode(), false);
+ $this->assertIdentical($page->getAuthentication(), false);
+ $this->assertIdentical($page->getRealm(), false);
+ $this->assertFalse($page->hasFrames());
+ $this->assertIdentical($page->getUrls(), array());
+ $this->assertIdentical($page->getTitle(), false);
+ }
+}
+
+class TestOfPageHeaders extends UnitTestCase {
+
+ function testUrlAccessor() {
+ $headers = &new MockSimpleHttpHeaders();
+
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getHeaders', $headers);
+ $response->setReturnValue('getMethod', 'POST');
+ $response->setReturnValue('getUrl', new SimpleUrl('here'));
+ $response->setReturnValue('getRequestData', array('a' => 'A'));
+
+ $page = &new SimplePage($response);
+ $this->assertEqual($page->getMethod(), 'POST');
+ $this->assertEqual($page->getUrl(), new SimpleUrl('here'));
+ $this->assertEqual($page->getRequestData(), array('a' => 'A'));
+ }
+
+ function testTransportError() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getError', 'Ouch');
+
+ $page = &new SimplePage($response);
+ $this->assertEqual($page->getTransportError(), 'Ouch');
+ }
+
+ function testHeadersAccessor() {
+ $headers = &new MockSimpleHttpHeaders();
+ $headers->setReturnValue('getRaw', 'My: Headers');
+
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getHeaders', $headers);
+
+ $page = &new SimplePage($response);
+ $this->assertEqual($page->getHeaders(), 'My: Headers');
+ }
+
+ function testMimeAccessor() {
+ $headers = &new MockSimpleHttpHeaders();
+ $headers->setReturnValue('getMimeType', 'text/html');
+
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getHeaders', $headers);
+
+ $page = &new SimplePage($response);
+ $this->assertEqual($page->getMimeType(), 'text/html');
+ }
+
+ function testResponseAccessor() {
+ $headers = &new MockSimpleHttpHeaders();
+ $headers->setReturnValue('getResponseCode', 301);
+
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getHeaders', $headers);
+
+ $page = &new SimplePage($response);
+ $this->assertIdentical($page->getResponseCode(), 301);
+ }
+
+ function testAuthenticationAccessors() {
+ $headers = &new MockSimpleHttpHeaders();
+ $headers->setReturnValue('getAuthentication', 'Basic');
+ $headers->setReturnValue('getRealm', 'Secret stuff');
+
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getHeaders', $headers);
+
+ $page = &new SimplePage($response);
+ $this->assertEqual($page->getAuthentication(), 'Basic');
+ $this->assertEqual($page->getRealm(), 'Secret stuff');
+ }
+}
+
+class TestOfHtmlPage extends UnitTestCase {
+
+ function testRawAccessor() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent', 'Raw HTML');
+
+ $page = &new SimplePage($response);
+ $this->assertEqual($page->getRaw(), 'Raw HTML');
+ }
+
+ function testTextAccessor() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent', '<b>Some</b> &quot;messy&quot; HTML');
+
+ $page = &new SimplePage($response);
+ $this->assertEqual($page->getText(), 'Some "messy" HTML');
+ }
+
+ function testNoLinks() {
+ $page = &new SimplePage(new MockSimpleHttpResponse());
+ $this->assertIdentical($page->getUrls(), array());
+ $this->assertIdentical($page->getUrlsByLabel('Label'), array());
+ }
+
+ function testAddAbsoluteLink() {
+ $link = &new SimpleAnchorTag(array('href' => 'http://somewhere.com'));
+ $link->addContent('Label');
+ $page = &new SimplePage(new MockSimpleHttpResponse());
+ $page->AcceptTag($link);
+ $this->assertEqual(
+ $page->getUrlsByLabel('Label'),
+ array(new SimpleUrl('http://somewhere.com')));
+ }
+
+ function testAddStrictRelativeLink() {
+ $link = &new SimpleAnchorTag(array('href' => './somewhere.php'));
+ $link->addContent('Label');
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
+ $page = &new SimplePage($response);
+ $page->AcceptTag($link);
+ $this->assertEqual(
+ $page->getUrlsByLabel('Label'),
+ array(new SimpleUrl('http://host/somewhere.php')));
+ }
+
+ function testAddBareRelativeLink() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
+ $page = &new SimplePage($response);
+ $page->AcceptTag(new SimpleAnchorTag(array('href' => 'somewhere.php')));
+ $this->assertIdentical($page->getUrls(), array('http://host/somewhere.php'));
+ }
+
+ function testAddRelativeLinkWithBaseTag() {
+ $link = &new SimpleAnchorTag(array('href' => 'somewhere.php'));
+ $link->addContent('Label');
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
+ $page = &new SimplePage($response);
+ $page->AcceptTag($link);
+ $base = &new SimpleBaseTag(array('href' => 'www.lastcraft.com/stuff/'));
+ $page->AcceptTag($base);
+ $this->assertEqual(
+ $page->getUrlsByLabel('Label'),
+ array(new SimpleUrl('www.lastcraft.com/stuff/somewhere.php')));
+ }
+
+ function testAddAbsoluteLinkWithBaseTag() {
+ $link = &new SimpleAnchorTag(array('href' => 'http://here.com/somewhere.php'));
+ $link->addContent('Label');
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
+ $page = &new SimplePage($response);
+ $page->AcceptTag($link);
+ $base = &new SimpleBaseTag(array('href' => 'www.lastcraft.com/stuff/'));
+ $page->AcceptTag($base);
+ $this->assertEqual(
+ $page->getUrlsByLabel('Label'),
+ array(new SimpleUrl('http://here.com/somewhere.php')));
+ }
+
+ function testLinkIds() {
+ $link = &new SimpleAnchorTag(array('href' => './somewhere.php', 'id' => 33));
+ $link->addContent('Label');
+
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
+
+ $page = &new SimplePage($response);
+ $page->AcceptTag($link);
+
+ $this->assertEqual(
+ $page->getUrlsByLabel('Label'),
+ array(new SimpleUrl('http://host/somewhere.php')));
+ $this->assertFalse($page->getUrlById(0));
+ $this->assertEqual(
+ $page->getUrlById(33),
+ new SimpleUrl('http://host/somewhere.php'));
+ }
+
+ function testFindLinkWithNormalisation() {
+ $link = &new SimpleAnchorTag(array('href' => './somewhere.php', 'id' => 33));
+ $link->addContent(' <em>Long &amp; thin</em> ');
+
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
+
+ $page = &new SimplePage($response);
+ $page->AcceptTag($link);
+
+ $this->assertEqual(
+ $page->getUrlsByLabel('Long & thin'),
+ array(new SimpleUrl('http://host/somewhere.php')));
+ }
+
+ function testFindLinkWithImage() {
+ $link = &new SimpleAnchorTag(array('href' => './somewhere.php', 'id' => 33));
+ $link->addContent('<img src="pic.jpg" alt="&lt;A picture&gt;">');
+
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
+
+ $page = &new SimplePage($response);
+ $page->AcceptTag($link);
+
+ $this->assertEqual(
+ $page->getUrlsByLabel('<A picture>'),
+ array(new SimpleUrl('http://host/somewhere.php')));
+ }
+
+ function testTitleSetting() {
+ $title = &new SimpleTitleTag(array());
+ $title->addContent('Title');
+ $page = &new SimplePage(new MockSimpleHttpResponse());
+ $page->AcceptTag($title);
+ $this->assertEqual($page->getTitle(), 'Title');
+ }
+
+ function testFramesetAbsence() {
+ $url = new SimpleUrl('here');
+ $response = new MockSimpleHttpResponse();
+ $response->setReturnValue('getUrl', $url);
+ $page = &new SimplePage($response);
+ $this->assertFalse($page->hasFrames());
+ $this->assertIdentical($page->getFrameset(), false);
+ }
+
+ function testHasEmptyFrameset() {
+ $page = &new SimplePage(new MockSimpleHttpResponse());
+ $page->acceptFramesetStart(new SimpleTag('frameset', array()));
+ $page->acceptFramesetEnd();
+ $this->assertTrue($page->hasFrames());
+ $this->assertIdentical($page->getFrameset(), array());
+ }
+
+ function testFramesInPage() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getUrl', new SimpleUrl('http://here'));
+
+ $page = &new SimplePage($response);
+ $page->acceptFrame(new SimpleFrameTag(array('src' => '1.html')));
+ $page->acceptFramesetStart(new SimpleTag('frameset', array()));
+ $page->acceptFrame(new SimpleFrameTag(array('src' => '2.html')));
+ $page->acceptFrame(new SimpleFrameTag(array('src' => '3.html')));
+ $page->acceptFramesetEnd();
+ $page->acceptFrame(new SimpleFrameTag(array('src' => '4.html')));
+
+ $this->assertTrue($page->hasFrames());
+ $this->assertIdentical($page->getFrameset(), array(
+ 1 => new SimpleUrl('http://here/2.html'),
+ 2 => new SimpleUrl('http://here/3.html')));
+ }
+
+ function testNamedFramesInPage() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getUrl', new SimpleUrl('http://here'));
+
+ $page = &new SimplePage($response);
+ $page->acceptFramesetStart(new SimpleTag('frameset', array()));
+ $page->acceptFrame(new SimpleFrameTag(array('src' => '1.html')));
+ $page->acceptFrame(new SimpleFrameTag(array('src' => '2.html', 'name' => 'A')));
+ $page->acceptFrame(new SimpleFrameTag(array('src' => '3.html', 'name' => 'B')));
+ $page->acceptFrame(new SimpleFrameTag(array('src' => '4.html')));
+ $page->acceptFramesetEnd();
+
+ $this->assertTrue($page->hasFrames());
+ $this->assertIdentical($page->getFrameset(), array(
+ 1 => new SimpleUrl('http://here/1.html'),
+ 'A' => new SimpleUrl('http://here/2.html'),
+ 'B' => new SimpleUrl('http://here/3.html'),
+ 4 => new SimpleUrl('http://here/4.html')));
+ }
+
+ function testRelativeFramesRespectBaseTag() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getUrl', new SimpleUrl('http://here.com/'));
+ $page = &new SimplePage($response);
+
+ $base = &new SimpleBaseTag(array('href' => 'https://there.com/stuff/'));
+ $page->AcceptTag($base);
+
+ $page->acceptFramesetStart(new SimpleTag('frameset', array()));
+ $page->acceptFrame(new SimpleFrameTag(array('src' => '1.html')));
+ $page->acceptFramesetEnd();
+ $this->assertIdentical(
+ $page->getFrameset(),
+ array(1 => new SimpleUrl('https://there.com/stuff/1.html')));
+ }
+}
+
+class TestOfFormsCreatedFromEventStream extends UnitTestCase {
+
+ function testFormCanBeSubmitted() {
+ $page = &new SimplePage(new MockSimpleHttpResponse());
+ $page->acceptFormStart(
+ new SimpleFormTag(array('method' => 'GET', 'action' => 'here.php')));
+ $page->AcceptTag(
+ new SimpleSubmitTag(array('type' => 'submit', 'name' => 's')));
+ $page->acceptFormEnd();
+ $form = &$page->getFormBySubmit(new SimpleByLabel('Submit'));
+ $this->assertEqual(
+ $form->submitButton(new SimpleByLabel('Submit')),
+ new SimpleGetEncoding(array('s' => 'Submit')));
+ }
+
+ function testInputFieldCanBeReadBack() {
+ $page = &new SimplePage(new MockSimpleHttpResponse());
+ $page->acceptFormStart(
+ new SimpleFormTag(array("method" => "GET", "action" => "here.php")));
+ $page->AcceptTag(
+ new SimpleTextTag(array("type" => "text", "name" => "a", "value" => "A")));
+ $page->AcceptTag(
+ new SimpleSubmitTag(array("type" => "submit", "name" => "s")));
+ $page->acceptFormEnd();
+ $this->assertEqual($page->getField(new SimpleByName('a')), 'A');
+ }
+
+ function testInputFieldCanBeReadBackByLabel() {
+ $label = &new SimpleLabelTag(array());
+ $page = &new SimplePage(new MockSimpleHttpResponse());
+ $page->acceptFormStart(
+ new SimpleFormTag(array("method" => "GET", "action" => "here.php")));
+ $page->acceptLabelStart($label);
+ $label->addContent('l');
+ $page->AcceptTag(
+ new SimpleTextTag(array("type" => "text", "name" => "a", "value" => "A")));
+ $page->acceptLabelEnd();
+ $page->AcceptTag(
+ new SimpleSubmitTag(array("type" => "submit", "name" => "s")));
+ $page->acceptFormEnd();
+ $this->assertEqual($page->getField(new SimpleByLabel('l')), 'A');
+ }
+}
+
+class TestOfPageScraping extends UnitTestCase {
+
+ function &parse($response) {
+ $builder = &new SimplePageBuilder();
+ $page = &$builder->parse($response);
+ return $page;
+ }
+
+ function testEmptyPage() {
+ $page = &new SimplePage(new MockSimpleHttpResponse());
+ $this->assertIdentical($page->getUrls(), array());
+ $this->assertIdentical($page->getTitle(), false);
+ }
+
+ function testUninterestingPage() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent', '<html><body><p>Stuff</p></body></html>');
+ $page = &$this->parse($response);
+ $this->assertIdentical($page->getUrls(), array());
+ }
+
+ function testLinksPage() {
+ $raw = '<html>';
+ $raw .= '<a href="there.html">There</a>';
+ $raw .= '<a href="http://there.com/that.html" id="0">That page</a>';
+ $raw .= '</html>';
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent', $raw);
+ $response->setReturnValue('getUrl', new SimpleUrl('http://www.here.com/a/index.html'));
+
+ $page = &$this->parse($response);
+ $this->assertIdentical(
+ $page->getUrls(),
+ array('http://www.here.com/a/there.html', 'http://there.com/that.html'));
+ $this->assertIdentical(
+ $page->getUrlsByLabel('There'),
+ array(new SimpleUrl('http://www.here.com/a/there.html')));
+ $this->assertEqual(
+ $page->getUrlById('0'),
+ new SimpleUrl('http://there.com/that.html'));
+ }
+
+ function testTitle() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent', '<html><head><title>Me</title></head></html>');
+ $page = &$this->parse($response);
+ $this->assertEqual($page->getTitle(), 'Me');
+ }
+
+ function testNastyTitle() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue(
+ 'getContent',
+ '<html><head><Title> <b>Me&amp;Me </TITLE></b></head></html>');
+ $page = &$this->parse($response);
+ $this->assertEqual($page->getTitle(), "Me&Me");
+ }
+
+ function testCompleteForm() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><head><form>' .
+ '<input type="text" name="here" value="Hello">' .
+ '</form></head></html>');
+ $page = &$this->parse($response);
+ $this->assertEqual($page->getField(new SimpleByName('here')), "Hello");
+ }
+
+ function testUnclosedForm() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><head><form>' .
+ '<input type="text" name="here" value="Hello">' .
+ '</head></html>');
+ $page = &$this->parse($response);
+ $this->assertEqual($page->getField(new SimpleByName('here')), "Hello");
+ }
+
+ function testEmptyFrameset() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue(
+ 'getContent',
+ '<html><frameset></frameset></html>');
+ $page = &$this->parse($response);
+ $this->assertTrue($page->hasFrames());
+ $this->assertIdentical($page->getFrameset(), array());
+ }
+
+ function testSingleFrame() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue(
+ 'getContent',
+ '<html><frameset><frame src="a.html"></frameset></html>');
+ $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
+
+ $page = &$this->parse($response);
+ $this->assertTrue($page->hasFrames());
+ $this->assertIdentical(
+ $page->getFrameset(),
+ array(1 => new SimpleUrl('http://host/a.html')));
+ }
+
+ function testSingleFrameInNestedFrameset() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><frameset><frameset>' .
+ '<frame src="a.html">' .
+ '</frameset></frameset></html>');
+ $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
+
+ $page = &$this->parse($response);
+ $this->assertTrue($page->hasFrames());
+ $this->assertIdentical(
+ $page->getFrameset(),
+ array(1 => new SimpleUrl('http://host/a.html')));
+ }
+
+ function testFrameWithNoSource() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue(
+ 'getContent',
+ '<html><frameset><frame></frameset></html>');
+ $page = &$this->parse($response);
+ $this->assertTrue($page->hasFrames());
+ $this->assertIdentical($page->getFrameset(), array());
+ }
+
+ function testFramesCollectedWithNestedFramesetTags() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><frameset>' .
+ '<frame src="a.html">' .
+ '<frameset><frame src="b.html"></frameset>' .
+ '<frame src="c.html">' .
+ '</frameset></html>');
+ $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
+
+ $page = &$this->parse($response);
+ $this->assertTrue($page->hasFrames());
+ $this->assertIdentical($page->getFrameset(), array(
+ 1 => new SimpleUrl('http://host/a.html'),
+ 2 => new SimpleUrl('http://host/b.html'),
+ 3 => new SimpleUrl('http://host/c.html')));
+ }
+
+ function testNamedFrames() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><frameset>' .
+ '<frame src="a.html">' .
+ '<frame name="_one" src="b.html">' .
+ '<frame src="c.html">' .
+ '<frame src="d.html" name="_two">' .
+ '</frameset></html>');
+ $response->setReturnValue('getUrl', new SimpleUrl('http://host/'));
+
+ $page = &$this->parse($response);
+ $this->assertTrue($page->hasFrames());
+ $this->assertIdentical($page->getFrameset(), array(
+ 1 => new SimpleUrl('http://host/a.html'),
+ '_one' => new SimpleUrl('http://host/b.html'),
+ 3 => new SimpleUrl('http://host/c.html'),
+ '_two' => new SimpleUrl('http://host/d.html')));
+ }
+
+ function testFindFormByLabel() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue(
+ 'getContent',
+ '<html><head><form><input type="submit"></form></head></html>');
+ $page = &$this->parse($response);
+ $this->assertNull($page->getFormBySubmit(new SimpleByLabel('submit')));
+ $this->assertNull($page->getFormBySubmit(new SimpleByName('submit')));
+ $this->assertIsA(
+ $page->getFormBySubmit(new SimpleByLabel('Submit')),
+ 'SimpleForm');
+ }
+
+ function testConfirmSubmitAttributesAreCaseSensitive() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue(
+ 'getContent',
+ '<html><head><FORM><INPUT TYPE="SUBMIT" NAME="S" VALUE="S"></FORM></head></html>');
+ $page = &$this->parse($response);
+ $this->assertIsA(
+ $page->getFormBySubmit(new SimpleByName('S')),
+ 'SimpleForm');
+ $this->assertIsA(
+ $page->getFormBySubmit(new SimpleByLabel('S')),
+ 'SimpleForm');
+ }
+
+ function testFindFormByImage() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><head><form>' .
+ '<input type="image" id=100 alt="Label" name="me">' .
+ '</form></head></html>');
+ $page = &$this->parse($response);
+ $this->assertIsA(
+ $page->getFormByImage(new SimpleByLabel('Label')),
+ 'SimpleForm');
+ $this->assertIsA(
+ $page->getFormByImage(new SimpleByName('me')),
+ 'SimpleForm');
+ $this->assertIsA(
+ $page->getFormByImage(new SimpleById(100)),
+ 'SimpleForm');
+ }
+
+ function testFindFormByButtonTag() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><head><form>' .
+ '<button type="submit" name="b" value="B">BBB</button>' .
+ '</form></head></html>');
+ $page = &$this->parse($response);
+ $this->assertNull($page->getFormBySubmit(new SimpleByLabel('b')));
+ $this->assertNull($page->getFormBySubmit(new SimpleByLabel('B')));
+ $this->assertIsA(
+ $page->getFormBySubmit(new SimpleByName('b')),
+ 'SimpleForm');
+ $this->assertIsA(
+ $page->getFormBySubmit(new SimpleByLabel('BBB')),
+ 'SimpleForm');
+ }
+
+ function testFindFormById() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue(
+ 'getContent',
+ '<html><head><form id="55"><input type="submit"></form></head></html>');
+ $page = &$this->parse($response);
+ $this->assertNull($page->getFormById(54));
+ $this->assertIsA($page->getFormById(55), 'SimpleForm');
+ }
+
+ function testReadingTextField() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><head><form>' .
+ '<input type="text" name="a">' .
+ '<input type="text" name="b" value="bbb" id=3>' .
+ '</form></head></html>');
+ $page = &$this->parse($response);
+ $this->assertNull($page->getField(new SimpleByName('missing')));
+ $this->assertIdentical($page->getField(new SimpleByName('a')), '');
+ $this->assertIdentical($page->getField(new SimpleByName('b')), 'bbb');
+ }
+
+ function testReadingTextFieldIsCaseInsensitive() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><head><FORM>' .
+ '<INPUT TYPE="TEXT" NAME="a">' .
+ '<INPUT TYPE="TEXT" NAME="b" VALUE="bbb" id=3>' .
+ '</FORM></head></html>');
+ $page = &$this->parse($response);
+ $this->assertNull($page->getField(new SimpleByName('missing')));
+ $this->assertIdentical($page->getField(new SimpleByName('a')), '');
+ $this->assertIdentical($page->getField(new SimpleByName('b')), 'bbb');
+ }
+
+ function testSettingTextField() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><head><form>' .
+ '<input type="text" name="a">' .
+ '<input type="text" name="b" id=3>' .
+ '<input type="submit">' .
+ '</form></head></html>');
+ $page = &$this->parse($response);
+ $this->assertTrue($page->setField(new SimpleByName('a'), 'aaa'));
+ $this->assertEqual($page->getField(new SimpleByName('a')), 'aaa');
+ $this->assertTrue($page->setField(new SimpleById(3), 'bbb'));
+ $this->assertEqual($page->getField(new SimpleBYId(3)), 'bbb');
+ $this->assertFalse($page->setField(new SimpleByName('z'), 'zzz'));
+ $this->assertNull($page->getField(new SimpleByName('z')));
+ }
+
+ function testSettingTextFieldByEnclosingLabel() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><head><form>' .
+ '<label>Stuff' .
+ '<input type="text" name="a" value="A">' .
+ '</label>' .
+ '</form></head></html>');
+ $page = &$this->parse($response);
+ $this->assertEqual($page->getField(new SimpleByName('a')), 'A');
+ $this->assertEqual($page->getField(new SimpleByLabel('Stuff')), 'A');
+ $this->assertTrue($page->setField(new SimpleByLabel('Stuff'), 'aaa'));
+ $this->assertEqual($page->getField(new SimpleByLabel('Stuff')), 'aaa');
+ }
+
+ function testGettingTextFieldByEnclosingLabelWithConflictingOtherFields() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><head><form>' .
+ '<label>Stuff' .
+ '<input type="text" name="a" value="A">' .
+ '</label>' .
+ '<input type="text" name="b" value="B">' .
+ '</form></head></html>');
+ $page = &$this->parse($response);
+ $this->assertEqual($page->getField(new SimpleByName('a')), 'A');
+ $this->assertEqual($page->getField(new SimpleByName('b')), 'B');
+ $this->assertEqual($page->getField(new SimpleByLabel('Stuff')), 'A');
+ }
+
+ function testSettingTextFieldByExternalLabel() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><head><form>' .
+ '<label for="aaa">Stuff</label>' .
+ '<input id="aaa" type="text" name="a" value="A">' .
+ '</form></head></html>');
+ $page = &$this->parse($response);
+ $this->assertEqual($page->getField(new SimpleByLabel('Stuff')), 'A');
+ $this->assertTrue($page->setField(new SimpleByLabel('Stuff'), 'aaa'));
+ $this->assertEqual($page->getField(new SimpleByLabel('Stuff')), 'aaa');
+ }
+
+ function testReadingTextArea() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><head><form>' .
+ '<textarea name="a">aaa</textarea>' .
+ '<input type="submit">' .
+ '</form></head></html>');
+ $page = &$this->parse($response);
+ $this->assertEqual($page->getField(new SimpleByName('a')), 'aaa');
+ }
+
+ function testSettingTextArea() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><head><form>' .
+ '<textarea name="a">aaa</textarea>' .
+ '<input type="submit">' .
+ '</form></head></html>');
+ $page = &$this->parse($response);
+ $this->assertTrue($page->setField(new SimpleByName('a'), 'AAA'));
+ $this->assertEqual($page->getField(new SimpleByName('a')), 'AAA');
+ }
+
+ function testSettingSelectionField() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><head><form>' .
+ '<select name="a">' .
+ '<option>aaa</option>' .
+ '<option selected>bbb</option>' .
+ '</select>' .
+ '<input type="submit">' .
+ '</form></head></html>');
+ $page = &$this->parse($response);
+ $this->assertEqual($page->getField(new SimpleByName('a')), 'bbb');
+ $this->assertFalse($page->setField(new SimpleByName('a'), 'ccc'));
+ $this->assertTrue($page->setField(new SimpleByName('a'), 'aaa'));
+ $this->assertEqual($page->getField(new SimpleByName('a')), 'aaa');
+ }
+
+ function testSettingSelectionFieldByEnclosingLabel() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><head><form>' .
+ '<label>Stuff' .
+ '<select name="a"><option selected>A</option><option>B</option></select>' .
+ '</label>' .
+ '</form></head></html>');
+ $page = &$this->parse($response);
+ $this->assertEqual($page->getField(new SimpleByLabel('Stuff')), 'A');
+ $this->assertTrue($page->setField(new SimpleByLabel('Stuff'), 'B'));
+ $this->assertEqual($page->getField(new SimpleByLabel('Stuff')), 'B');
+ }
+
+ function testSettingRadioButtonByEnclosingLabel() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent',
+ '<html><head><form>' .
+ '<label>A<input type="radio" name="r" value="a" checked></label>' .
+ '<label>B<input type="radio" name="r" value="b"></label>' .
+ '</form></head></html>');
+ $page = &$this->parse($response);
+ $this->assertEqual($page->getField(new SimpleByLabel('A')), 'a');
+ $this->assertTrue($page->setField(new SimpleBylabel('B'), 'b'));
+ $this->assertEqual($page->getField(new SimpleByLabel('B')), 'b');
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/parse_error_test.php b/vendors/simpletest/test/parse_error_test.php
new file mode 100755
index 000000000..c3ffb3d42
--- /dev/null
+++ b/vendors/simpletest/test/parse_error_test.php
@@ -0,0 +1,9 @@
+<?php
+// $Id: parse_error_test.php 1509 2007-05-08 22:11:49Z lastcraft $
+require_once('../unit_tester.php');
+require_once('../reporter.php');
+
+$test = &new TestSuite('This should fail');
+$test->addFile('test_with_parse_error.php');
+$test->run(new HtmlReporter());
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/parser_test.php b/vendors/simpletest/test/parser_test.php
new file mode 100755
index 000000000..83268d9e1
--- /dev/null
+++ b/vendors/simpletest/test/parser_test.php
@@ -0,0 +1,551 @@
+<?php
+// $Id: parser_test.php 1608 2007-12-27 09:03:07Z pp11 $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../parser.php');
+Mock::generate('SimpleHtmlSaxParser');
+Mock::generate('SimpleSaxListener');
+
+class TestOfParallelRegex extends UnitTestCase {
+
+ function testNoPatterns() {
+ $regex = &new ParallelRegex(false);
+ $this->assertFalse($regex->match("Hello", $match));
+ $this->assertEqual($match, "");
+ }
+
+ function testNoSubject() {
+ $regex = &new ParallelRegex(false);
+ $regex->addPattern(".*");
+ $this->assertTrue($regex->match("", $match));
+ $this->assertEqual($match, "");
+ }
+
+ function testMatchAll() {
+ $regex = &new ParallelRegex(false);
+ $regex->addPattern(".*");
+ $this->assertTrue($regex->match("Hello", $match));
+ $this->assertEqual($match, "Hello");
+ }
+
+ function testCaseSensitive() {
+ $regex = &new ParallelRegex(true);
+ $regex->addPattern("abc");
+ $this->assertTrue($regex->match("abcdef", $match));
+ $this->assertEqual($match, "abc");
+ $this->assertTrue($regex->match("AAABCabcdef", $match));
+ $this->assertEqual($match, "abc");
+ }
+
+ function testCaseInsensitive() {
+ $regex = &new ParallelRegex(false);
+ $regex->addPattern("abc");
+ $this->assertTrue($regex->match("abcdef", $match));
+ $this->assertEqual($match, "abc");
+ $this->assertTrue($regex->match("AAABCabcdef", $match));
+ $this->assertEqual($match, "ABC");
+ }
+
+ function testMatchMultiple() {
+ $regex = &new ParallelRegex(true);
+ $regex->addPattern("abc");
+ $regex->addPattern("ABC");
+ $this->assertTrue($regex->match("abcdef", $match));
+ $this->assertEqual($match, "abc");
+ $this->assertTrue($regex->match("AAABCabcdef", $match));
+ $this->assertEqual($match, "ABC");
+ $this->assertFalse($regex->match("Hello", $match));
+ }
+
+ function testPatternLabels() {
+ $regex = &new ParallelRegex(false);
+ $regex->addPattern("abc", "letter");
+ $regex->addPattern("123", "number");
+ $this->assertIdentical($regex->match("abcdef", $match), "letter");
+ $this->assertEqual($match, "abc");
+ $this->assertIdentical($regex->match("0123456789", $match), "number");
+ $this->assertEqual($match, "123");
+ }
+}
+
+class TestOfStateStack extends UnitTestCase {
+
+ function testStartState() {
+ $stack = &new SimpleStateStack("one");
+ $this->assertEqual($stack->getCurrent(), "one");
+ }
+
+ function testExhaustion() {
+ $stack = &new SimpleStateStack("one");
+ $this->assertFalse($stack->leave());
+ }
+
+ function testStateMoves() {
+ $stack = &new SimpleStateStack("one");
+ $stack->enter("two");
+ $this->assertEqual($stack->getCurrent(), "two");
+ $stack->enter("three");
+ $this->assertEqual($stack->getCurrent(), "three");
+ $this->assertTrue($stack->leave());
+ $this->assertEqual($stack->getCurrent(), "two");
+ $stack->enter("third");
+ $this->assertEqual($stack->getCurrent(), "third");
+ $this->assertTrue($stack->leave());
+ $this->assertTrue($stack->leave());
+ $this->assertEqual($stack->getCurrent(), "one");
+ }
+}
+
+class TestParser {
+
+ function accept() {
+ }
+
+ function a() {
+ }
+
+ function b() {
+ }
+}
+Mock::generate('TestParser');
+
+class TestOfLexer extends UnitTestCase {
+
+ function testEmptyPage() {
+ $handler = &new MockTestParser();
+ $handler->expectNever("accept");
+ $handler->setReturnValue("accept", true);
+ $handler->expectNever("accept");
+ $handler->setReturnValue("accept", true);
+ $lexer = &new SimpleLexer($handler);
+ $lexer->addPattern("a+");
+ $this->assertTrue($lexer->parse(""));
+ }
+
+ function testSinglePattern() {
+ $handler = &new MockTestParser();
+ $handler->expectArgumentsAt(0, "accept", array("aaa", LEXER_MATCHED));
+ $handler->expectArgumentsAt(1, "accept", array("x", LEXER_UNMATCHED));
+ $handler->expectArgumentsAt(2, "accept", array("a", LEXER_MATCHED));
+ $handler->expectArgumentsAt(3, "accept", array("yyy", LEXER_UNMATCHED));
+ $handler->expectArgumentsAt(4, "accept", array("a", LEXER_MATCHED));
+ $handler->expectArgumentsAt(5, "accept", array("x", LEXER_UNMATCHED));
+ $handler->expectArgumentsAt(6, "accept", array("aaa", LEXER_MATCHED));
+ $handler->expectArgumentsAt(7, "accept", array("z", LEXER_UNMATCHED));
+ $handler->expectCallCount("accept", 8);
+ $handler->setReturnValue("accept", true);
+ $lexer = &new SimpleLexer($handler);
+ $lexer->addPattern("a+");
+ $this->assertTrue($lexer->parse("aaaxayyyaxaaaz"));
+ }
+
+ function testMultiplePattern() {
+ $handler = &new MockTestParser();
+ $target = array("a", "b", "a", "bb", "x", "b", "a", "xxxxxx", "a", "x");
+ for ($i = 0; $i < count($target); $i++) {
+ $handler->expectArgumentsAt($i, "accept", array($target[$i], '*'));
+ }
+ $handler->expectCallCount("accept", count($target));
+ $handler->setReturnValue("accept", true);
+ $lexer = &new SimpleLexer($handler);
+ $lexer->addPattern("a+");
+ $lexer->addPattern("b+");
+ $this->assertTrue($lexer->parse("ababbxbaxxxxxxax"));
+ }
+}
+
+class TestOfLexerModes extends UnitTestCase {
+
+ function testIsolatedPattern() {
+ $handler = &new MockTestParser();
+ $handler->expectArgumentsAt(0, "a", array("a", LEXER_MATCHED));
+ $handler->expectArgumentsAt(1, "a", array("b", LEXER_UNMATCHED));
+ $handler->expectArgumentsAt(2, "a", array("aa", LEXER_MATCHED));
+ $handler->expectArgumentsAt(3, "a", array("bxb", LEXER_UNMATCHED));
+ $handler->expectArgumentsAt(4, "a", array("aaa", LEXER_MATCHED));
+ $handler->expectArgumentsAt(5, "a", array("x", LEXER_UNMATCHED));
+ $handler->expectArgumentsAt(6, "a", array("aaaa", LEXER_MATCHED));
+ $handler->expectArgumentsAt(7, "a", array("x", LEXER_UNMATCHED));
+ $handler->expectCallCount("a", 8);
+ $handler->setReturnValue("a", true);
+ $lexer = &new SimpleLexer($handler, "a");
+ $lexer->addPattern("a+", "a");
+ $lexer->addPattern("b+", "b");
+ $this->assertTrue($lexer->parse("abaabxbaaaxaaaax"));
+ }
+
+ function testModeChange() {
+ $handler = &new MockTestParser();
+ $handler->expectArgumentsAt(0, "a", array("a", LEXER_MATCHED));
+ $handler->expectArgumentsAt(1, "a", array("b", LEXER_UNMATCHED));
+ $handler->expectArgumentsAt(2, "a", array("aa", LEXER_MATCHED));
+ $handler->expectArgumentsAt(3, "a", array("b", LEXER_UNMATCHED));
+ $handler->expectArgumentsAt(4, "a", array("aaa", LEXER_MATCHED));
+ $handler->expectArgumentsAt(0, "b", array(":", LEXER_ENTER));
+ $handler->expectArgumentsAt(1, "b", array("a", LEXER_UNMATCHED));
+ $handler->expectArgumentsAt(2, "b", array("b", LEXER_MATCHED));
+ $handler->expectArgumentsAt(3, "b", array("a", LEXER_UNMATCHED));
+ $handler->expectArgumentsAt(4, "b", array("bb", LEXER_MATCHED));
+ $handler->expectArgumentsAt(5, "b", array("a", LEXER_UNMATCHED));
+ $handler->expectArgumentsAt(6, "b", array("bbb", LEXER_MATCHED));
+ $handler->expectArgumentsAt(7, "b", array("a", LEXER_UNMATCHED));
+ $handler->expectCallCount("a", 5);
+ $handler->expectCallCount("b", 8);
+ $handler->setReturnValue("a", true);
+ $handler->setReturnValue("b", true);
+ $lexer = &new SimpleLexer($handler, "a");
+ $lexer->addPattern("a+", "a");
+ $lexer->addEntryPattern(":", "a", "b");
+ $lexer->addPattern("b+", "b");
+ $this->assertTrue($lexer->parse("abaabaaa:ababbabbba"));
+ }
+
+ function testNesting() {
+ $handler = &new MockTestParser();
+ $handler->setReturnValue("a", true);
+ $handler->setReturnValue("b", true);
+ $handler->expectArgumentsAt(0, "a", array("aa", LEXER_MATCHED));
+ $handler->expectArgumentsAt(1, "a", array("b", LEXER_UNMATCHED));
+ $handler->expectArgumentsAt(2, "a", array("aa", LEXER_MATCHED));
+ $handler->expectArgumentsAt(3, "a", array("b", LEXER_UNMATCHED));
+ $handler->expectArgumentsAt(0, "b", array("(", LEXER_ENTER));
+ $handler->expectArgumentsAt(1, "b", array("bb", LEXER_MATCHED));
+ $handler->expectArgumentsAt(2, "b", array("a", LEXER_UNMATCHED));
+ $handler->expectArgumentsAt(3, "b", array("bb", LEXER_MATCHED));
+ $handler->expectArgumentsAt(4, "b", array(")", LEXER_EXIT));
+ $handler->expectArgumentsAt(4, "a", array("aa", LEXER_MATCHED));
+ $handler->expectArgumentsAt(5, "a", array("b", LEXER_UNMATCHED));
+ $handler->expectCallCount("a", 6);
+ $handler->expectCallCount("b", 5);
+ $lexer = &new SimpleLexer($handler, "a");
+ $lexer->addPattern("a+", "a");
+ $lexer->addEntryPattern("(", "a", "b");
+ $lexer->addPattern("b+", "b");
+ $lexer->addExitPattern(")", "b");
+ $this->assertTrue($lexer->parse("aabaab(bbabb)aab"));
+ }
+
+ function testSingular() {
+ $handler = &new MockTestParser();
+ $handler->setReturnValue("a", true);
+ $handler->setReturnValue("b", true);
+ $handler->expectArgumentsAt(0, "a", array("aa", LEXER_MATCHED));
+ $handler->expectArgumentsAt(1, "a", array("aa", LEXER_MATCHED));
+ $handler->expectArgumentsAt(2, "a", array("xx", LEXER_UNMATCHED));
+ $handler->expectArgumentsAt(3, "a", array("xx", LEXER_UNMATCHED));
+ $handler->expectArgumentsAt(0, "b", array("b", LEXER_SPECIAL));
+ $handler->expectArgumentsAt(1, "b", array("bbb", LEXER_SPECIAL));
+ $handler->expectCallCount("a", 4);
+ $handler->expectCallCount("b", 2);
+ $lexer = &new SimpleLexer($handler, "a");
+ $lexer->addPattern("a+", "a");
+ $lexer->addSpecialPattern("b+", "a", "b");
+ $this->assertTrue($lexer->parse("aabaaxxbbbxx"));
+ }
+
+ function testUnwindTooFar() {
+ $handler = &new MockTestParser();
+ $handler->setReturnValue("a", true);
+ $handler->expectArgumentsAt(0, "a", array("aa", LEXER_MATCHED));
+ $handler->expectArgumentsAt(1, "a", array(")", LEXER_EXIT));
+ $handler->expectCallCount("a", 2);
+ $lexer = &new SimpleLexer($handler, "a");
+ $lexer->addPattern("a+", "a");
+ $lexer->addExitPattern(")", "a");
+ $this->assertFalse($lexer->parse("aa)aa"));
+ }
+}
+
+class TestOfLexerHandlers extends UnitTestCase {
+
+ function testModeMapping() {
+ $handler = &new MockTestParser();
+ $handler->setReturnValue("a", true);
+ $handler->expectArgumentsAt(0, "a", array("aa", LEXER_MATCHED));
+ $handler->expectArgumentsAt(1, "a", array("(", LEXER_ENTER));
+ $handler->expectArgumentsAt(2, "a", array("bb", LEXER_MATCHED));
+ $handler->expectArgumentsAt(3, "a", array("a", LEXER_UNMATCHED));
+ $handler->expectArgumentsAt(4, "a", array("bb", LEXER_MATCHED));
+ $handler->expectArgumentsAt(5, "a", array(")", LEXER_EXIT));
+ $handler->expectArgumentsAt(6, "a", array("b", LEXER_UNMATCHED));
+ $handler->expectCallCount("a", 7);
+ $lexer = &new SimpleLexer($handler, "mode_a");
+ $lexer->addPattern("a+", "mode_a");
+ $lexer->addEntryPattern("(", "mode_a", "mode_b");
+ $lexer->addPattern("b+", "mode_b");
+ $lexer->addExitPattern(")", "mode_b");
+ $lexer->mapHandler("mode_a", "a");
+ $lexer->mapHandler("mode_b", "a");
+ $this->assertTrue($lexer->parse("aa(bbabb)b"));
+ }
+}
+
+class TestOfSimpleHtmlLexer extends UnitTestCase {
+
+ function &createParser() {
+ $parser = &new MockSimpleHtmlSaxParser();
+ $parser->setReturnValue('acceptStartToken', true);
+ $parser->setReturnValue('acceptEndToken', true);
+ $parser->setReturnValue('acceptAttributeToken', true);
+ $parser->setReturnValue('acceptEntityToken', true);
+ $parser->setReturnValue('acceptTextToken', true);
+ $parser->setReturnValue('ignore', true);
+ return $parser;
+ }
+
+ function testNoContent() {
+ $parser = &$this->createParser();
+ $parser->expectNever('acceptStartToken');
+ $parser->expectNever('acceptEndToken');
+ $parser->expectNever('acceptAttributeToken');
+ $parser->expectNever('acceptEntityToken');
+ $parser->expectNever('acceptTextToken');
+ $lexer = &new SimpleHtmlLexer($parser);
+ $this->assertTrue($lexer->parse(''));
+ }
+
+ function testUninteresting() {
+ $parser = &$this->createParser();
+ $parser->expectOnce('acceptTextToken', array('<html></html>', '*'));
+ $lexer = &new SimpleHtmlLexer($parser);
+ $this->assertTrue($lexer->parse('<html></html>'));
+ }
+
+ function testSkipCss() {
+ $parser = &$this->createParser();
+ $parser->expectNever('acceptTextToken');
+ $parser->expectAtLeastOnce('ignore');
+ $lexer = &new SimpleHtmlLexer($parser);
+ $this->assertTrue($lexer->parse("<style>Lot's of styles</style>"));
+ }
+
+ function testSkipJavaScript() {
+ $parser = &$this->createParser();
+ $parser->expectNever('acceptTextToken');
+ $parser->expectAtLeastOnce('ignore');
+ $lexer = &new SimpleHtmlLexer($parser);
+ $this->assertTrue($lexer->parse("<SCRIPT>Javascript code {';:^%^%£$'@\"*(}</SCRIPT>"));
+ }
+
+ function testSkipHtmlComments() {
+ $parser = &$this->createParser();
+ $parser->expectNever('acceptTextToken');
+ $parser->expectAtLeastOnce('ignore');
+ $lexer = &new SimpleHtmlLexer($parser);
+ $this->assertTrue($lexer->parse("<!-- <title>title</title><style>styles</style> -->"));
+ }
+
+ function testTagWithNoAttributes() {
+ $parser = &$this->createParser();
+ $parser->expectAt(0, 'acceptStartToken', array('<title', '*'));
+ $parser->expectAt(1, 'acceptStartToken', array('>', '*'));
+ $parser->expectCallCount('acceptStartToken', 2);
+ $parser->expectOnce('acceptTextToken', array('Hello', '*'));
+ $parser->expectOnce('acceptEndToken', array('</title>', '*'));
+ $lexer = &new SimpleHtmlLexer($parser);
+ $this->assertTrue($lexer->parse('<title>Hello</title>'));
+ }
+
+ function testTagWithAttributes() {
+ $parser = &$this->createParser();
+ $parser->expectOnce('acceptTextToken', array('label', '*'));
+ $parser->expectAt(0, 'acceptStartToken', array('<a', '*'));
+ $parser->expectAt(1, 'acceptStartToken', array('href', '*'));
+ $parser->expectAt(2, 'acceptStartToken', array('>', '*'));
+ $parser->expectCallCount('acceptStartToken', 3);
+ $parser->expectAt(0, 'acceptAttributeToken', array('= "', '*'));
+ $parser->expectAt(1, 'acceptAttributeToken', array('here.html', '*'));
+ $parser->expectAt(2, 'acceptAttributeToken', array('"', '*'));
+ $parser->expectCallCount('acceptAttributeToken', 3);
+ $parser->expectOnce('acceptEndToken', array('</a>', '*'));
+ $lexer = &new SimpleHtmlLexer($parser);
+ $this->assertTrue($lexer->parse('<a href = "here.html">label</a>'));
+ }
+}
+
+class TestOfHtmlSaxParser extends UnitTestCase {
+
+ function &createListener() {
+ $listener = &new MockSimpleSaxListener();
+ $listener->setReturnValue('startElement', true);
+ $listener->setReturnValue('addContent', true);
+ $listener->setReturnValue('endElement', true);
+ return $listener;
+ }
+
+ function testFramesetTag() {
+ $listener = &$this->createListener();
+ $listener->expectOnce('startElement', array('frameset', array()));
+ $listener->expectOnce('addContent', array('Frames'));
+ $listener->expectOnce('endElement', array('frameset'));
+ $parser = &new SimpleHtmlSaxParser($listener);
+ $this->assertTrue($parser->parse('<frameset>Frames</frameset>'));
+ }
+
+ function testTagWithUnquotedAttributes() {
+ $listener = &$this->createListener();
+ $listener->expectOnce(
+ 'startElement',
+ array('input', array('name' => 'a.b.c', 'value' => 'd')));
+ $parser = &new SimpleHtmlSaxParser($listener);
+ $this->assertTrue($parser->parse('<input name=a.b.c value = d>'));
+ }
+
+ function testTagInsideContent() {
+ $listener = &$this->createListener();
+ $listener->expectOnce('startElement', array('a', array()));
+ $listener->expectAt(0, 'addContent', array('<html>'));
+ $listener->expectAt(1, 'addContent', array('</html>'));
+ $parser = &new SimpleHtmlSaxParser($listener);
+ $this->assertTrue($parser->parse('<html><a></a></html>'));
+ }
+
+ function testTagWithInternalContent() {
+ $listener = &$this->createListener();
+ $listener->expectOnce('startElement', array('a', array()));
+ $listener->expectOnce('addContent', array('label'));
+ $listener->expectOnce('endElement', array('a'));
+ $parser = &new SimpleHtmlSaxParser($listener);
+ $this->assertTrue($parser->parse('<a>label</a>'));
+ }
+
+ function testLinkAddress() {
+ $listener = &$this->createListener();
+ $listener->expectOnce('startElement', array('a', array('href' => 'here.html')));
+ $listener->expectOnce('addContent', array('label'));
+ $listener->expectOnce('endElement', array('a'));
+ $parser = &new SimpleHtmlSaxParser($listener);
+ $this->assertTrue($parser->parse("<a href = 'here.html'>label</a>"));
+ }
+
+ function testEncodedAttribute() {
+ $listener = &$this->createListener();
+ $listener->expectOnce('startElement', array('a', array('href' => 'here&there.html')));
+ $listener->expectOnce('addContent', array('label'));
+ $listener->expectOnce('endElement', array('a'));
+ $parser = &new SimpleHtmlSaxParser($listener);
+ $this->assertTrue($parser->parse("<a href = 'here&amp;there.html'>label</a>"));
+ }
+
+ function testTagWithId() {
+ $listener = &$this->createListener();
+ $listener->expectOnce('startElement', array('a', array('id' => '0')));
+ $listener->expectOnce('addContent', array('label'));
+ $listener->expectOnce('endElement', array('a'));
+ $parser = &new SimpleHtmlSaxParser($listener);
+ $this->assertTrue($parser->parse('<a id="0">label</a>'));
+ }
+
+ function testTagWithEmptyAttributes() {
+ $listener = &$this->createListener();
+ $listener->expectOnce(
+ 'startElement',
+ array('option', array('value' => '', 'selected' => '')));
+ $listener->expectOnce('addContent', array('label'));
+ $listener->expectOnce('endElement', array('option'));
+ $parser = &new SimpleHtmlSaxParser($listener);
+ $this->assertTrue($parser->parse('<option value="" selected>label</option>'));
+ }
+
+ function testComplexTagWithLotsOfCaseVariations() {
+ $listener = &$this->createListener();
+ $listener->expectOnce(
+ 'startElement',
+ array('a', array('href' => 'here.html', 'style' => "'cool'")));
+ $listener->expectOnce('addContent', array('label'));
+ $listener->expectOnce('endElement', array('a'));
+ $parser = &new SimpleHtmlSaxParser($listener);
+ $this->assertTrue($parser->parse('<A HREF = \'here.html\' Style="\'cool\'">label</A>'));
+ }
+
+ function testXhtmlSelfClosingTag() {
+ $listener = &$this->createListener();
+ $listener->expectOnce(
+ 'startElement',
+ array('input', array('type' => 'submit', 'name' => 'N', 'value' => 'V')));
+ $parser = &new SimpleHtmlSaxParser($listener);
+ $this->assertTrue($parser->parse('<input type="submit" name="N" value="V" />'));
+ }
+
+ function testNestedFrameInFrameset() {
+ $listener = &$this->createListener();
+ $listener->expectAt(0, 'startElement', array('frameset', array()));
+ $listener->expectAt(1, 'startElement', array('frame', array('src' => 'frame.html')));
+ $listener->expectCallCount('startElement', 2);
+ $listener->expectOnce('addContent', array('<noframes>Hello</noframes>'));
+ $listener->expectOnce('endElement', array('frameset'));
+ $parser = &new SimpleHtmlSaxParser($listener);
+ $this->assertTrue($parser->parse(
+ '<frameset><frame src="frame.html"><noframes>Hello</noframes></frameset>'));
+ }
+}
+
+class TestOfTextExtraction extends UnitTestCase {
+
+ function testImageSuppressionWhileKeepingParagraphsAndAltText() {
+ $this->assertEqual(
+ SimpleHtmlSaxParser::normalise('<img src="foo.png" /><p>some text</p><img src="bar.png" alt="bar" />'),
+ 'some text bar');
+
+ }
+
+ function testSpaceNormalisation() {
+ $this->assertEqual(
+ SimpleHtmlSaxParser::normalise("\nOne\tTwo \nThree\t"),
+ 'One Two Three');
+ }
+
+ function testMultilinesCommentSuppression() {
+ $this->assertEqual(
+ SimpleHtmlSaxParser::normalise('<!--\n Hello \n-->'),
+ '');
+ }
+
+ function testCommentSuppression() {
+ $this->assertEqual(
+ SimpleHtmlSaxParser::normalise('<!--Hello-->'),
+ '');
+ }
+
+ function testJavascriptSuppression() {
+ $this->assertEqual(
+ SimpleHtmlSaxParser::normalise('<script attribute="test">\nHello\n</script>'),
+ '');
+ $this->assertEqual(
+ SimpleHtmlSaxParser::normalise('<script attribute="test">Hello</script>'),
+ '');
+ $this->assertEqual(
+ SimpleHtmlSaxParser::normalise('<script>Hello</script>'),
+ '');
+ }
+
+ function testTagSuppression() {
+ $this->assertEqual(
+ SimpleHtmlSaxParser::normalise('<b>Hello</b>'),
+ 'Hello');
+ }
+
+ function testAdjoiningTagSuppression() {
+ $this->assertEqual(
+ SimpleHtmlSaxParser::normalise('<b>Hello</b><em>Goodbye</em>'),
+ 'HelloGoodbye');
+ }
+
+ function testExtractImageAltTextWithDifferentQuotes() {
+ $this->assertEqual(
+ SimpleHtmlSaxParser::normalise('<img alt="One"><img alt=\'Two\'><img alt=Three>'),
+ 'One Two Three');
+ }
+
+ function testExtractImageAltTextMultipleTimes() {
+ $this->assertEqual(
+ SimpleHtmlSaxParser::normalise('<img alt="One"><img alt="Two"><img alt="Three">'),
+ 'One Two Three');
+ }
+
+ function testHtmlEntityTranslation() {
+ $this->assertEqual(
+ SimpleHtmlSaxParser::normalise('&lt;&gt;&quot;&amp;&#039;'),
+ '<>"&\'');
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/reflection_php4_test.php b/vendors/simpletest/test/reflection_php4_test.php
new file mode 100755
index 000000000..8ee211b96
--- /dev/null
+++ b/vendors/simpletest/test/reflection_php4_test.php
@@ -0,0 +1,61 @@
+<?php
+// $Id: reflection_php4_test.php 1505 2007-04-30 23:39:59Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+
+class AnyOldThing {
+ function aMethod() {
+ }
+}
+
+class AnyOldChildThing extends AnyOldThing { }
+
+class TestOfReflection extends UnitTestCase {
+
+ function testClassExistence() {
+ $reflection = new SimpleReflection('AnyOldThing');
+ $this->assertTrue($reflection->classOrInterfaceExists());
+ $this->assertTrue($reflection->classOrInterfaceExistsSansAutoload());
+ }
+
+ function testClassNonExistence() {
+ $reflection = new SimpleReflection('UnknownThing');
+ $this->assertFalse($reflection->classOrInterfaceExists());
+ $this->assertFalse($reflection->classOrInterfaceExistsSansAutoload());
+ }
+
+ function testDetectionOfInterfacesAlwaysFalse() {
+ $reflection = new SimpleReflection('AnyOldThing');
+ $this->assertFalse($reflection->isAbstract());
+ $this->assertFalse($reflection->isInterface());
+ }
+
+ function testFindingParentClass() {
+ $reflection = new SimpleReflection('AnyOldChildThing');
+ $this->assertEqual(strtolower($reflection->getParent()), 'anyoldthing');
+ }
+
+ function testMethodsListFromClass() {
+ $reflection = new SimpleReflection('AnyOldThing');
+ $methods = $reflection->getMethods();
+ $this->assertEqualIgnoringCase($methods[0], 'aMethod');
+ }
+
+ function testNoInterfacesForPHP4() {
+ $reflection = new SimpleReflection('AnyOldThing');
+ $this->assertEqual(
+ $reflection->getInterfaces(),
+ array());
+ }
+
+ function testMostGeneralPossibleSignature() {
+ $reflection = new SimpleReflection('AnyOldThing');
+ $this->assertEqualIgnoringCase(
+ $reflection->getSignature('aMethod'),
+ 'function &aMethod()');
+ }
+
+ function assertEqualIgnoringCase($a, $b) {
+ return $this->assertEqual(strtolower($a), strtolower($b));
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/reflection_php5_test.php b/vendors/simpletest/test/reflection_php5_test.php
new file mode 100755
index 000000000..3bfc6e85b
--- /dev/null
+++ b/vendors/simpletest/test/reflection_php5_test.php
@@ -0,0 +1,271 @@
+<?php
+// $Id: reflection_php5_test.php 1541 2007-06-10 02:27:59Z tswicegood $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../reflection_php5.php');
+
+class AnyOldLeafClass {
+ function aMethod() { }
+}
+
+abstract class AnyOldClass {
+ function aMethod() { }
+}
+
+class AnyOldLeafClassWithAFinal {
+ final function aMethod() { }
+}
+
+interface AnyOldInterface {
+ function aMethod();
+}
+
+interface AnyOldArgumentInterface {
+ function aMethod(AnyOldInterface $argument);
+}
+
+interface AnyDescendentInterface extends AnyOldInterface {
+}
+
+class AnyOldImplementation implements AnyOldInterface {
+ function aMethod() { }
+ function extraMethod() { }
+}
+
+abstract class AnyAbstractImplementation implements AnyOldInterface {
+}
+
+abstract class AnotherOldAbstractClass {
+ protected abstract function aMethod(AnyOldInterface $argument);
+}
+
+class AnyOldSubclass extends AnyOldImplementation { }
+
+class AnyOldArgumentClass {
+ function aMethod($argument) { }
+}
+
+class AnyOldArgumentImplementation implements AnyOldArgumentInterface {
+ function aMethod(AnyOldInterface $argument) { }
+}
+
+class AnyOldTypeHintedClass implements AnyOldArgumentInterface {
+ function aMethod(AnyOldInterface $argument) { }
+}
+
+class AnyDescendentImplementation implements AnyDescendentInterface {
+ function aMethod() { }
+}
+
+class AnyOldOverloadedClass {
+ function __isset($key) { }
+ function __unset($key) { }
+}
+
+class AnyOldClassWithStaticMethods {
+ static function aStatic() { }
+ static function aStaticWithParameters($arg1, $arg2) { }
+}
+
+abstract class AnyOldAbstractClassWithAbstractMethods {
+ abstract function anAbstract();
+ abstract function anAbstractWithParameter($foo);
+ abstract function anAbstractWithMultipleParameters($foo, $bar);
+}
+
+class TestOfReflection extends UnitTestCase {
+
+ function testClassExistence() {
+ $reflection = new SimpleReflection('AnyOldLeafClass');
+ $this->assertTrue($reflection->classOrInterfaceExists());
+ $this->assertTrue($reflection->classOrInterfaceExistsSansAutoload());
+ $this->assertFalse($reflection->isAbstract());
+ $this->assertFalse($reflection->isInterface());
+ }
+
+ function testClassNonExistence() {
+ $reflection = new SimpleReflection('UnknownThing');
+ $this->assertFalse($reflection->classOrInterfaceExists());
+ $this->assertFalse($reflection->classOrInterfaceExistsSansAutoload());
+ }
+
+ function testDetectionOfAbstractClass() {
+ $reflection = new SimpleReflection('AnyOldClass');
+ $this->assertTrue($reflection->isAbstract());
+ }
+
+ function testDetectionOfFinalMethods() {
+ $reflection = new SimpleReflection('AnyOldClass');
+ $this->assertFalse($reflection->hasFinal());
+ $reflection = new SimpleReflection('AnyOldLeafClassWithAFinal');
+ $this->assertTrue($reflection->hasFinal());
+ }
+
+ function testFindingParentClass() {
+ $reflection = new SimpleReflection('AnyOldSubclass');
+ $this->assertEqual($reflection->getParent(), 'AnyOldImplementation');
+ }
+
+ function testInterfaceExistence() {
+ $reflection = new SimpleReflection('AnyOldInterface');
+ $this->assertTrue($reflection->classOrInterfaceExists());
+ $this->assertTrue($reflection->classOrInterfaceExistsSansAutoload());
+ $this->assertTrue($reflection->isInterface());
+ }
+
+ function testMethodsListFromClass() {
+ $reflection = new SimpleReflection('AnyOldClass');
+ $this->assertIdentical($reflection->getMethods(), array('aMethod'));
+ }
+
+ function testMethodsListFromInterface() {
+ $reflection = new SimpleReflection('AnyOldInterface');
+ $this->assertIdentical($reflection->getMethods(), array('aMethod'));
+ $this->assertIdentical($reflection->getInterfaceMethods(), array('aMethod'));
+ }
+
+ function testMethodsComeFromDescendentInterfacesASWell() {
+ $reflection = new SimpleReflection('AnyDescendentInterface');
+ $this->assertIdentical($reflection->getMethods(), array('aMethod'));
+ }
+
+ function testCanSeparateInterfaceMethodsFromOthers() {
+ $reflection = new SimpleReflection('AnyOldImplementation');
+ $this->assertIdentical($reflection->getMethods(), array('aMethod', 'extraMethod'));
+ $this->assertIdentical($reflection->getInterfaceMethods(), array('aMethod'));
+ }
+
+ function testMethodsComeFromDescendentInterfacesInAbstractClass() {
+ $reflection = new SimpleReflection('AnyAbstractImplementation');
+ $this->assertIdentical($reflection->getMethods(), array('aMethod'));
+ }
+
+ function testInterfaceHasOnlyItselfToImplement() {
+ $reflection = new SimpleReflection('AnyOldInterface');
+ $this->assertEqual(
+ $reflection->getInterfaces(),
+ array('AnyOldInterface'));
+ }
+
+ function testInterfacesListedForClass() {
+ $reflection = new SimpleReflection('AnyOldImplementation');
+ $this->assertEqual(
+ $reflection->getInterfaces(),
+ array('AnyOldInterface'));
+ }
+
+ function testInterfacesListedForSubclass() {
+ $reflection = new SimpleReflection('AnyOldSubclass');
+ $this->assertEqual(
+ $reflection->getInterfaces(),
+ array('AnyOldInterface'));
+ }
+
+ function testNoParameterCreationWhenNoInterface() {
+ $reflection = new SimpleReflection('AnyOldArgumentClass');
+ $function = $reflection->getSignature('aMethod');
+ if (version_compare(phpversion(), '5.0.2', '<=')) {
+ $this->assertEqual('function amethod()', strtolower($function));
+ } else {
+ $this->assertEqual('function aMethod()', $function);
+ }
+ }
+
+ function testParameterCreationWithoutTypeHinting() {
+ $reflection = new SimpleReflection('AnyOldArgumentImplementation');
+ $function = $reflection->getSignature('aMethod');
+ if (version_compare(phpversion(), '5.0.2', '<=')) {
+ $this->assertEqual('function amethod(AnyOldInterface $argument)', $function);
+ } else {
+ $this->assertEqual('function aMethod(AnyOldInterface $argument)', $function);
+ }
+ }
+
+ function testParameterCreationForTypeHinting() {
+ $reflection = new SimpleReflection('AnyOldTypeHintedClass');
+ $function = $reflection->getSignature('aMethod');
+ if (version_compare(phpversion(), '5.0.2', '<=')) {
+ $this->assertEqual('function amethod(AnyOldInterface $argument)', $function);
+ } else {
+ $this->assertEqual('function aMethod(AnyOldInterface $argument)', $function);
+ }
+ }
+
+ function testIssetFunctionSignature() {
+ $reflection = new SimpleReflection('AnyOldOverloadedClass');
+ $function = $reflection->getSignature('__isset');
+ if (version_compare(phpversion(), '5.1.0', '>=')) {
+ $this->assertEqual('function __isset($key)', $function);
+ } else {
+ $this->assertEqual('function __isset()', $function);
+ }
+ }
+
+ function testUnsetFunctionSignature() {
+ $reflection = new SimpleReflection('AnyOldOverloadedClass');
+ $function = $reflection->getSignature('__unset');
+ if (version_compare(phpversion(), '5.1.0', '>=')) {
+ $this->assertEqual('function __unset($key)', $function);
+ } else {
+ $this->assertEqual('function __unset()', $function);
+ }
+ }
+
+ function testProperlyReflectsTheFinalInterfaceWhenObjectImplementsAnExtendedInterface() {
+ $reflection = new SimpleReflection('AnyDescendentImplementation');
+ $interfaces = $reflection->getInterfaces();
+ $this->assertEqual(1, count($interfaces));
+ $this->assertEqual('AnyDescendentInterface', array_shift($interfaces));
+ }
+
+ function testCreatingSignatureForAbstractMethod() {
+ $reflection = new SimpleReflection('AnotherOldAbstractClass');
+ $this->assertEqual($reflection->getSignature('aMethod'), 'function aMethod(AnyOldInterface $argument)');
+ }
+
+ function testCanProperlyGenerateStaticMethodSignatures() {
+ $reflection = new SimpleReflection('AnyOldClassWithStaticMethods');
+ $this->assertEqual('static function aStatic()', $reflection->getSignature('aStatic'));
+ $this->assertEqual(
+ 'static function aStaticWithParameters($arg1, $arg2)',
+ $reflection->getSignature('aStaticWithParameters')
+ );
+ }
+}
+
+class TestOfReflectionWithTypeHints extends UnitTestCase {
+ function skip() {
+ $this->skipIf(version_compare(phpversion(), '5.1.0', '<'), 'Reflection with type hints only tested for PHP 5.1.0 and above');
+ }
+
+ function testParameterCreationForTypeHintingWithArray() {
+ eval('interface AnyOldArrayTypeHintedInterface {
+ function amethod(array $argument);
+ }
+ class AnyOldArrayTypeHintedClass implements AnyOldArrayTypeHintedInterface {
+ function amethod(array $argument) {}
+ }');
+ $reflection = new SimpleReflection('AnyOldArrayTypeHintedClass');
+ $function = $reflection->getSignature('amethod');
+ $this->assertEqual('function amethod(array $argument)', $function);
+ }
+}
+
+class TestOfAbstractsWithAbstractMethods extends UnitTestCase {
+ function testCanProperlyGenerateAbstractMethods() {
+ $reflection = new SimpleReflection('AnyOldAbstractClassWithAbstractMethods');
+ $this->assertEqual(
+ 'function anAbstract()',
+ $reflection->getSignature('anAbstract')
+ );
+ $this->assertEqual(
+ 'function anAbstractWithParameter($foo)',
+ $reflection->getSignature('anAbstractWithParameter')
+ );
+ $this->assertEqual(
+ 'function anAbstractWithMultipleParameters($foo, $bar)',
+ $reflection->getSignature('anAbstractWithMultipleParameters')
+ );
+ }
+}
+
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/remote_test.php b/vendors/simpletest/test/remote_test.php
new file mode 100755
index 000000000..efcccaf05
--- /dev/null
+++ b/vendors/simpletest/test/remote_test.php
@@ -0,0 +1,20 @@
+<?php
+// $Id: remote_test.php 1505 2007-04-30 23:39:59Z lastcraft $
+require_once('../remote.php');
+require_once('../reporter.php');
+
+// The following URL will depend on your own installation.
+if (isset($_SERVER['SCRIPT_URI'])) {
+ $base_uri = $_SERVER['SCRIPT_URI'];
+} elseif (isset($_SERVER['HTTP_HOST']) && isset($_SERVER['PHP_SELF'])) {
+ $base_uri = 'http://'. $_SERVER['HTTP_HOST'] . $_SERVER['PHP_SELF'];
+};
+$test_url = str_replace('remote_test.php', 'visual_test.php', $base_uri);
+
+$test = &new TestSuite('Remote tests');
+$test->addTestCase(new RemoteTestCase($test_url . '?xml=yes', $test_url . '?xml=yes&dry=yes'));
+if (SimpleReporter::inCli()) {
+ exit ($test->run(new TextReporter()) ? 0 : 1);
+}
+$test->run(new HtmlReporter());
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/shell_test.php b/vendors/simpletest/test/shell_test.php
new file mode 100755
index 000000000..6199272a1
--- /dev/null
+++ b/vendors/simpletest/test/shell_test.php
@@ -0,0 +1,38 @@
+<?php
+// $Id: shell_test.php 1529 2007-06-04 18:33:09Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../shell_tester.php');
+
+class TestOfShell extends UnitTestCase {
+
+ function testEcho() {
+ $shell = &new SimpleShell();
+ $this->assertIdentical($shell->execute('echo Hello'), 0);
+ $this->assertPattern('/Hello/', $shell->getOutput());
+ }
+
+ function testBadCommand() {
+ $shell = &new SimpleShell();
+ $this->assertNotEqual($ret = $shell->execute('blurgh! 2>&1'), 0);
+ }
+}
+
+class TestOfShellTesterAndShell extends ShellTestCase {
+
+ function testEcho() {
+ $this->assertTrue($this->execute('echo Hello'));
+ $this->assertExitCode(0);
+ $this->assertoutput('Hello');
+ }
+
+ function testFileExistence() {
+ $this->assertFileExists(dirname(__FILE__) . '/all_tests.php');
+ $this->assertFileNotExists('wibble');
+ }
+
+ function testFilePatterns() {
+ $this->assertFilePattern('/all[_ ]tests/i', dirname(__FILE__) . '/all_tests.php');
+ $this->assertNoFilePattern('/sputnik/i', dirname(__FILE__) . '/all_tests.php');
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/shell_tester_test.php b/vendors/simpletest/test/shell_tester_test.php
new file mode 100755
index 000000000..e536dcebd
--- /dev/null
+++ b/vendors/simpletest/test/shell_tester_test.php
@@ -0,0 +1,42 @@
+<?php
+// $Id: shell_tester_test.php 1505 2007-04-30 23:39:59Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../shell_tester.php');
+Mock::generate('SimpleShell');
+
+class TestOfShellTestCase extends ShellTestCase {
+ var $_mock_shell = false;
+
+ function &_getShell() {
+ return $this->_mock_shell;
+ }
+
+ function testGenericEquality() {
+ $this->assertEqual('a', 'a');
+ $this->assertNotEqual('a', 'A');
+ }
+
+ function testExitCode() {
+ $this->_mock_shell = &new MockSimpleShell();
+ $this->_mock_shell->setReturnValue('execute', 0);
+ $this->_mock_shell->expectOnce('execute', array('ls'));
+ $this->assertTrue($this->execute('ls'));
+ $this->assertExitCode(0);
+ }
+
+ function testOutput() {
+ $this->_mock_shell = &new MockSimpleShell();
+ $this->_mock_shell->setReturnValue('execute', 0);
+ $this->_mock_shell->setReturnValue('getOutput', "Line 1\nLine 2\n");
+ $this->assertOutput("Line 1\nLine 2\n");
+ }
+
+ function testOutputPatterns() {
+ $this->_mock_shell = &new MockSimpleShell();
+ $this->_mock_shell->setReturnValue('execute', 0);
+ $this->_mock_shell->setReturnValue('getOutput', "Line 1\nLine 2\n");
+ $this->assertOutputPattern('/line/i');
+ $this->assertNoOutputPattern('/line 2/');
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/simpletest_test.php b/vendors/simpletest/test/simpletest_test.php
new file mode 100755
index 000000000..bf98d9748
--- /dev/null
+++ b/vendors/simpletest/test/simpletest_test.php
@@ -0,0 +1,58 @@
+<?php
+// $Id: simpletest_test.php 1505 2007-04-30 23:39:59Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../simpletest.php');
+
+SimpleTest::ignore('ShouldNeverBeRunEither');
+
+class ShouldNeverBeRun extends UnitTestCase {
+ function testWithNoChanceOfSuccess() {
+ $this->fail('Should be ignored');
+ }
+}
+
+class ShouldNeverBeRunEither extends ShouldNeverBeRun { }
+
+class TestOfStackTrace extends UnitTestCase {
+
+ function testCanFindAssertInTrace() {
+ $trace = new SimpleStackTrace(array('assert'));
+ $this->assertEqual(
+ $trace->traceMethod(array(array(
+ 'file' => '/my_test.php',
+ 'line' => 24,
+ 'function' => 'assertSomething'))),
+ ' at [/my_test.php line 24]');
+ }
+}
+
+class DummyResource { }
+
+class TestOfContext extends UnitTestCase {
+
+ function testCurrentContextIsUnique() {
+ $this->assertReference(
+ SimpleTest::getContext(),
+ SimpleTest::getContext());
+ }
+
+ function testContextHoldsCurrentTestCase() {
+ $context = &SimpleTest::getContext();
+ $this->assertReference($this, $context->getTest());
+ }
+
+ function testResourceIsSingleInstanceWithContext() {
+ $context = &new SimpleTestContext();
+ $this->assertReference(
+ $context->get('DummyResource'),
+ $context->get('DummyResource'));
+ }
+
+ function testClearingContextResetsResources() {
+ $context = &new SimpleTestContext();
+ $resource = &$context->get('DummyResource');
+ $context->clear();
+ $this->assertClone($resource, $context->get('DummyResource'));
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/socket_test.php b/vendors/simpletest/test/socket_test.php
new file mode 100755
index 000000000..ce25be7d3
--- /dev/null
+++ b/vendors/simpletest/test/socket_test.php
@@ -0,0 +1,25 @@
+<?php
+// $Id: socket_test.php 1509 2007-05-08 22:11:49Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../socket.php');
+Mock::generate('SimpleSocket');
+
+class TestOfSimpleStickyError extends UnitTestCase {
+
+ function testSettingError() {
+ $error = new SimpleStickyError();
+ $this->assertFalse($error->isError());
+ $error->_setError('Ouch');
+ $this->assertTrue($error->isError());
+ $this->assertEqual($error->getError(), 'Ouch');
+ }
+
+ function testClearingError() {
+ $error = new SimpleStickyError();
+ $error->_setError('Ouch');
+ $this->assertTrue($error->isError());
+ $error->_clearError();
+ $this->assertFalse($error->isError());
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/support/collector/collectable.1 b/vendors/simpletest/test/support/collector/collectable.1
new file mode 100755
index 000000000..e69de29bb
--- /dev/null
+++ b/vendors/simpletest/test/support/collector/collectable.1
diff --git a/vendors/simpletest/test/support/collector/collectable.2 b/vendors/simpletest/test/support/collector/collectable.2
new file mode 100755
index 000000000..e69de29bb
--- /dev/null
+++ b/vendors/simpletest/test/support/collector/collectable.2
diff --git a/vendors/simpletest/test/support/empty_test_file.php b/vendors/simpletest/test/support/empty_test_file.php
new file mode 100755
index 000000000..31e3f7bed
--- /dev/null
+++ b/vendors/simpletest/test/support/empty_test_file.php
@@ -0,0 +1,3 @@
+<?php
+require_once(dirname(__FILE__) . '/../../autorun.php');
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/support/latin1_sample b/vendors/simpletest/test/support/latin1_sample
new file mode 100755
index 000000000..190352577
--- /dev/null
+++ b/vendors/simpletest/test/support/latin1_sample
@@ -0,0 +1 @@
+£¹²³¼½¾@¶øþðßæ«»¢µ \ No newline at end of file
diff --git a/vendors/simpletest/test/support/spl_examples.php b/vendors/simpletest/test/support/spl_examples.php
new file mode 100755
index 000000000..45add356c
--- /dev/null
+++ b/vendors/simpletest/test/support/spl_examples.php
@@ -0,0 +1,15 @@
+<?php
+ // $Id: spl_examples.php 1262 2006-02-05 19:35:31Z lastcraft $
+
+ class IteratorImplementation implements Iterator {
+ function current() { }
+ function next() { }
+ function key() { }
+ function valid() { }
+ function rewind() { }
+ }
+
+ class IteratorAggregateImplementation implements IteratorAggregate {
+ function getIterator() { }
+ }
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/support/supplementary_upload_sample.txt b/vendors/simpletest/test/support/supplementary_upload_sample.txt
new file mode 100755
index 000000000..d8aa9e810
--- /dev/null
+++ b/vendors/simpletest/test/support/supplementary_upload_sample.txt
@@ -0,0 +1 @@
+Some more text content \ No newline at end of file
diff --git a/vendors/simpletest/test/support/test1.php b/vendors/simpletest/test/support/test1.php
new file mode 100755
index 000000000..b414586d6
--- /dev/null
+++ b/vendors/simpletest/test/support/test1.php
@@ -0,0 +1,7 @@
+<?php
+class test1 extends UnitTestCase {
+ function test_pass(){
+ $this->assertEqual(3,1+2, "pass1");
+ }
+}
+?>
diff --git a/vendors/simpletest/test/support/upload_sample.txt b/vendors/simpletest/test/support/upload_sample.txt
new file mode 100755
index 000000000..ec98d7c5e
--- /dev/null
+++ b/vendors/simpletest/test/support/upload_sample.txt
@@ -0,0 +1 @@
+Sample for testing file upload \ No newline at end of file
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
diff --git a/vendors/simpletest/test/test_with_parse_error.php b/vendors/simpletest/test/test_with_parse_error.php
new file mode 100755
index 000000000..41a5832a5
--- /dev/null
+++ b/vendors/simpletest/test/test_with_parse_error.php
@@ -0,0 +1,8 @@
+<?php
+ // $Id: test_with_parse_error.php 901 2005-01-24 00:32:14Z lastcraft $
+
+ class TestCaseWithParseError extends UnitTestCase {
+ wibble
+ }
+
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/unit_tester_test.php b/vendors/simpletest/test/unit_tester_test.php
new file mode 100755
index 000000000..5fe78fe91
--- /dev/null
+++ b/vendors/simpletest/test/unit_tester_test.php
@@ -0,0 +1,55 @@
+<?php
+// $Id: unit_tester_test.php 1509 2007-05-08 22:11:49Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+
+class ReferenceForTesting {
+}
+
+class TestOfUnitTester extends UnitTestCase {
+
+ function testAssertTrueReturnsAssertionAsBoolean() {
+ $this->assertTrue($this->assertTrue(true));
+ }
+
+ function testAssertFalseReturnsAssertionAsBoolean() {
+ $this->assertTrue($this->assertFalse(false));
+ }
+
+ function testAssertEqualReturnsAssertionAsBoolean() {
+ $this->assertTrue($this->assertEqual(5, 5));
+ }
+
+ function testAssertIdenticalReturnsAssertionAsBoolean() {
+ $this->assertTrue($this->assertIdentical(5, 5));
+ }
+
+ function testCoreAssertionsDoNotThrowErrors() {
+ $this->assertIsA($this, 'UnitTestCase');
+ $this->assertNotA($this, 'WebTestCase');
+ }
+
+ function testReferenceAssertionOnObjects() {
+ $a = &new ReferenceForTesting();
+ $b = &$a;
+ $this->assertReference($a, $b);
+ }
+
+ function testReferenceAssertionOnScalars() {
+ $a = 25;
+ $b = &$a;
+ $this->assertReference($a, $b);
+ }
+
+ function testCloneOnObjects() {
+ $a = &new ReferenceForTesting();
+ $b = &new ReferenceForTesting();
+ $this->assertClone($a, $b);
+ }
+
+ function testCloneOnScalars() {
+ $a = 25;
+ $b = 25;
+ $this->assertClone($a, $b);
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/unit_tests.php b/vendors/simpletest/test/unit_tests.php
new file mode 100755
index 000000000..04dbc46ca
--- /dev/null
+++ b/vendors/simpletest/test/unit_tests.php
@@ -0,0 +1,55 @@
+<?php
+// $Id: unit_tests.php 1661 2008-02-26 21:04:31Z pp11 $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../unit_tester.php');
+require_once(dirname(__FILE__) . '/../shell_tester.php');
+require_once(dirname(__FILE__) . '/../mock_objects.php');
+require_once(dirname(__FILE__) . '/../web_tester.php');
+require_once(dirname(__FILE__) . '/../extensions/pear_test_case.php');
+require_once(dirname(__FILE__) . '/../extensions/phpunit_test_case.php');
+
+class UnitTests extends TestSuite {
+ function UnitTests() {
+ $this->TestSuite('Unit tests');
+ $path = dirname(__FILE__);
+ $this->addFile($path . '/errors_test.php');
+ if (version_compare(phpversion(), '5') >= 0) {
+ $this->addFile($path . '/exceptions_test.php');
+ }
+ $this->addFile($path . '/autorun_test.php');
+ $this->addFile($path . '/compatibility_test.php');
+ $this->addFile($path . '/simpletest_test.php');
+ $this->addFile($path . '/dumper_test.php');
+ $this->addFile($path . '/expectation_test.php');
+ $this->addFile($path . '/unit_tester_test.php');
+ if (version_compare(phpversion(), '5', '>=')) {
+ $this->addFile($path . '/reflection_php5_test.php');
+ } else {
+ $this->addFile($path . '/reflection_php4_test.php');
+ }
+ $this->addFile($path . '/mock_objects_test.php');
+ if (version_compare(phpversion(), '5', '>=')) {
+ $this->addFile($path . '/interfaces_test.php');
+ }
+ $this->addFile($path . '/collector_test.php');
+ $this->addFile($path . '/adapter_test.php');
+ $this->addFile($path . '/socket_test.php');
+ $this->addFile($path . '/encoding_test.php');
+ $this->addFile($path . '/url_test.php');
+ $this->addFile($path . '/cookies_test.php');
+ $this->addFile($path . '/http_test.php');
+ $this->addFile($path . '/authentication_test.php');
+ $this->addFile($path . '/user_agent_test.php');
+ $this->addFile($path . '/parser_test.php');
+ $this->addFile($path . '/tag_test.php');
+ $this->addFile($path . '/form_test.php');
+ $this->addFile($path . '/page_test.php');
+ $this->addFile($path . '/frames_test.php');
+ $this->addFile($path . '/browser_test.php');
+ $this->addFile($path . '/web_tester_test.php');
+ $this->addFile($path . '/shell_tester_test.php');
+ $this->addFile($path . '/xml_test.php');
+ $this->addFile($path . '/../extensions/testdox/test.php');
+ }
+}
+?>
diff --git a/vendors/simpletest/test/url_test.php b/vendors/simpletest/test/url_test.php
new file mode 100755
index 000000000..550717038
--- /dev/null
+++ b/vendors/simpletest/test/url_test.php
@@ -0,0 +1,443 @@
+<?php
+// $Id: url_test.php 1598 2007-12-24 10:44:09Z pp11 $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../url.php');
+
+class TestOfUrl extends UnitTestCase {
+
+ function testDefaultUrl() {
+ $url = new SimpleUrl('');
+ $this->assertEqual($url->getScheme(), '');
+ $this->assertEqual($url->getHost(), '');
+ $this->assertEqual($url->getScheme('http'), 'http');
+ $this->assertEqual($url->getHost('localhost'), 'localhost');
+ $this->assertEqual($url->getPath(), '');
+ }
+
+ function testBasicParsing() {
+ $url = new SimpleUrl('https://www.lastcraft.com/test/');
+ $this->assertEqual($url->getScheme(), 'https');
+ $this->assertEqual($url->getHost(), 'www.lastcraft.com');
+ $this->assertEqual($url->getPath(), '/test/');
+ }
+
+ function testRelativeUrls() {
+ $url = new SimpleUrl('../somewhere.php');
+ $this->assertEqual($url->getScheme(), false);
+ $this->assertEqual($url->getHost(), false);
+ $this->assertEqual($url->getPath(), '../somewhere.php');
+ }
+
+ function testParseBareParameter() {
+ $url = new SimpleUrl('?a');
+ $this->assertEqual($url->getPath(), '');
+ $this->assertEqual($url->getEncodedRequest(), '?a');
+ $url->addRequestParameter('x', 'X');
+ $this->assertEqual($url->getEncodedRequest(), '?a=&x=X');
+ }
+
+ function testParseEmptyParameter() {
+ $url = new SimpleUrl('?a=');
+ $this->assertEqual($url->getPath(), '');
+ $this->assertEqual($url->getEncodedRequest(), '?a=');
+ $url->addRequestParameter('x', 'X');
+ $this->assertEqual($url->getEncodedRequest(), '?a=&x=X');
+ }
+
+ function testParseParameterPair() {
+ $url = new SimpleUrl('?a=A');
+ $this->assertEqual($url->getPath(), '');
+ $this->assertEqual($url->getEncodedRequest(), '?a=A');
+ $url->addRequestParameter('x', 'X');
+ $this->assertEqual($url->getEncodedRequest(), '?a=A&x=X');
+ }
+
+ function testParseMultipleParameters() {
+ $url = new SimpleUrl('?a=A&b=B');
+ $this->assertEqual($url->getEncodedRequest(), '?a=A&b=B');
+ $url->addRequestParameter('x', 'X');
+ $this->assertEqual($url->getEncodedRequest(), '?a=A&b=B&x=X');
+ }
+
+ function testParsingParameterMixture() {
+ $url = new SimpleUrl('?a=A&b=&c');
+ $this->assertEqual($url->getEncodedRequest(), '?a=A&b=&c');
+ $url->addRequestParameter('x', 'X');
+ $this->assertEqual($url->getEncodedRequest(), '?a=A&b=&c=&x=X');
+ }
+
+ function testAddParametersFromScratch() {
+ $url = new SimpleUrl('');
+ $url->addRequestParameter('a', 'A');
+ $this->assertEqual($url->getEncodedRequest(), '?a=A');
+ $url->addRequestParameter('b', 'B');
+ $this->assertEqual($url->getEncodedRequest(), '?a=A&b=B');
+ $url->addRequestParameter('a', 'aaa');
+ $this->assertEqual($url->getEncodedRequest(), '?a=A&b=B&a=aaa');
+ }
+
+ function testClearingParameters() {
+ $url = new SimpleUrl('');
+ $url->addRequestParameter('a', 'A');
+ $url->clearRequest();
+ $this->assertIdentical($url->getEncodedRequest(), '');
+ }
+
+ function testEncodingParameters() {
+ $url = new SimpleUrl('');
+ $url->addRequestParameter('a', '?!"\'#~@[]{}:;<>,./|£$%^&*()_+-=');
+ $this->assertIdentical(
+ $request = $url->getEncodedRequest(),
+ '?a=%3F%21%22%27%23%7E%40%5B%5D%7B%7D%3A%3B%3C%3E%2C.%2F%7C%A3%24%25%5E%26%2A%28%29_%2B-%3D');
+ }
+
+ function testDecodingParameters() {
+ $url = new SimpleUrl('?a=%3F%21%22%27%23%7E%40%5B%5D%7B%7D%3A%3B%3C%3E%2C.%2F%7C%A3%24%25%5E%26%2A%28%29_%2B-%3D');
+ $this->assertEqual(
+ $url->getEncodedRequest(),
+ '?a=' . urlencode('?!"\'#~@[]{}:;<>,./|£$%^&*()_+-='));
+ }
+
+ function testUrlInQueryDoesNotConfuseParsing() {
+ $url = new SimpleUrl('wibble/login.php?url=http://www.google.com/moo/');
+ $this->assertFalse($url->getScheme());
+ $this->assertFalse($url->getHost());
+ $this->assertEqual($url->getPath(), 'wibble/login.php');
+ $this->assertEqual($url->getEncodedRequest(), '?url=http://www.google.com/moo/');
+ }
+
+ function testSettingCordinates() {
+ $url = new SimpleUrl('');
+ $url->setCoordinates('32', '45');
+ $this->assertIdentical($url->getX(), 32);
+ $this->assertIdentical($url->getY(), 45);
+ $this->assertEqual($url->getEncodedRequest(), '');
+ }
+
+ function testParseCordinates() {
+ $url = new SimpleUrl('?32,45');
+ $this->assertIdentical($url->getX(), 32);
+ $this->assertIdentical($url->getY(), 45);
+ }
+
+ function testClearingCordinates() {
+ $url = new SimpleUrl('?32,45');
+ $url->setCoordinates();
+ $this->assertIdentical($url->getX(), false);
+ $this->assertIdentical($url->getY(), false);
+ }
+
+ function testParsingParameterCordinateMixture() {
+ $url = new SimpleUrl('?a=A&b=&c?32,45');
+ $this->assertIdentical($url->getX(), 32);
+ $this->assertIdentical($url->getY(), 45);
+ $this->assertEqual($url->getEncodedRequest(), '?a=A&b=&c');
+ }
+
+ function testParsingParameterWithBadCordinates() {
+ $url = new SimpleUrl('?a=A&b=&c?32');
+ $this->assertIdentical($url->getX(), false);
+ $this->assertIdentical($url->getY(), false);
+ $this->assertEqual($url->getEncodedRequest(), '?a=A&b=&c?32');
+ }
+
+ function testPageSplitting() {
+ $url = new SimpleUrl('./here/../there/somewhere.php');
+ $this->assertEqual($url->getPath(), './here/../there/somewhere.php');
+ $this->assertEqual($url->getPage(), 'somewhere.php');
+ $this->assertEqual($url->getBasePath(), './here/../there/');
+ }
+
+ function testAbsolutePathPageSplitting() {
+ $url = new SimpleUrl("http://host.com/here/there/somewhere.php");
+ $this->assertEqual($url->getPath(), "/here/there/somewhere.php");
+ $this->assertEqual($url->getPage(), "somewhere.php");
+ $this->assertEqual($url->getBasePath(), "/here/there/");
+ }
+
+ function testSplittingUrlWithNoPageGivesEmptyPage() {
+ $url = new SimpleUrl('/here/there/');
+ $this->assertEqual($url->getPath(), '/here/there/');
+ $this->assertEqual($url->getPage(), '');
+ $this->assertEqual($url->getBasePath(), '/here/there/');
+ }
+
+ function testPathNormalisation() {
+ $this->assertEqual(
+ SimpleUrl::normalisePath('https://host.com/I/am/here/../there/somewhere.php'),
+ 'https://host.com/I/am/there/somewhere.php');
+ }
+
+ // regression test for #1535407
+ function testPathNormalisationWithSinglePeriod() {
+ $this->assertEqual(
+ SimpleUrl::normalisePath('https://host.com/I/am/here/./../there/somewhere.php'),
+ 'https://host.com/I/am/there/somewhere.php');
+ }
+
+ // regression test for #1852413
+ function testHostnameExtractedFromUContainingAtSign() {
+ $url = new SimpleUrl("http://localhost/name@example.com");
+ $this->assertEqual($url->getScheme(), "http");
+ $this->assertEqual($url->getUsername(), "");
+ $this->assertEqual($url->getPassword(), "");
+ $this->assertEqual($url->getHost(), "localhost");
+ $this->assertEqual($url->getPath(), "/name@example.com");
+ }
+
+ function testHostnameInLocalhost() {
+ $url = new SimpleUrl("http://localhost/name/example.com");
+ $this->assertEqual($url->getScheme(), "http");
+ $this->assertEqual($url->getUsername(), "");
+ $this->assertEqual($url->getPassword(), "");
+ $this->assertEqual($url->getHost(), "localhost");
+ $this->assertEqual($url->getPath(), "/name/example.com");
+ }
+
+ function testUsernameAndPasswordAreUrlDecoded() {
+ $url = new SimpleUrl('http://' . urlencode('test@test') .
+ ':' . urlencode('$!£@*&%') . '@www.lastcraft.com');
+ $this->assertEqual($url->getUsername(), 'test@test');
+ $this->assertEqual($url->getPassword(), '$!£@*&%');
+ }
+
+ function testBlitz() {
+ $this->assertUrl(
+ "https://username:password@www.somewhere.com:243/this/that/here.php?a=1&b=2#anchor",
+ array("https", "username", "password", "www.somewhere.com", 243, "/this/that/here.php", "com", "?a=1&b=2", "anchor"),
+ array("a" => "1", "b" => "2"));
+ $this->assertUrl(
+ "username:password@www.somewhere.com/this/that/here.php?a=1",
+ array(false, "username", "password", "www.somewhere.com", false, "/this/that/here.php", "com", "?a=1", false),
+ array("a" => "1"));
+ $this->assertUrl(
+ "username:password@somewhere.com:243?1,2",
+ array(false, "username", "password", "somewhere.com", 243, "/", "com", "", false),
+ array(),
+ array(1, 2));
+ $this->assertUrl(
+ "https://www.somewhere.com",
+ array("https", false, false, "www.somewhere.com", false, "/", "com", "", false));
+ $this->assertUrl(
+ "username@www.somewhere.com:243#anchor",
+ array(false, "username", false, "www.somewhere.com", 243, "/", "com", "", "anchor"));
+ $this->assertUrl(
+ "/this/that/here.php?a=1&b=2?3,4",
+ array(false, false, false, false, false, "/this/that/here.php", false, "?a=1&b=2", false),
+ array("a" => "1", "b" => "2"),
+ array(3, 4));
+ $this->assertUrl(
+ "username@/here.php?a=1&b=2",
+ array(false, "username", false, false, false, "/here.php", false, "?a=1&b=2", false),
+ array("a" => "1", "b" => "2"));
+ }
+
+ function testAmbiguousHosts() {
+ $this->assertUrl(
+ "tigger",
+ array(false, false, false, false, false, "tigger", false, "", false));
+ $this->assertUrl(
+ "/tigger",
+ array(false, false, false, false, false, "/tigger", false, "", false));
+ $this->assertUrl(
+ "//tigger",
+ array(false, false, false, "tigger", false, "/", false, "", false));
+ $this->assertUrl(
+ "//tigger/",
+ array(false, false, false, "tigger", false, "/", false, "", false));
+ $this->assertUrl(
+ "tigger.com",
+ array(false, false, false, "tigger.com", false, "/", "com", "", false));
+ $this->assertUrl(
+ "me.net/tigger",
+ array(false, false, false, "me.net", false, "/tigger", "net", "", false));
+ }
+
+ function testAsString() {
+ $this->assertPreserved('https://www.here.com');
+ $this->assertPreserved('http://me:secret@www.here.com');
+ $this->assertPreserved('http://here/there');
+ $this->assertPreserved('http://here/there?a=A&b=B');
+ $this->assertPreserved('http://here/there?a=1&a=2');
+ $this->assertPreserved('http://here/there?a=1&a=2?9,8');
+ $this->assertPreserved('http://host?a=1&a=2');
+ $this->assertPreserved('http://host#stuff');
+ $this->assertPreserved('http://me:secret@www.here.com/a/b/c/here.html?a=A?7,6');
+ $this->assertPreserved('http://www.here.com/?a=A__b=B');
+ }
+
+ function assertUrl($raw, $parts, $params = false, $coords = false) {
+ if (! is_array($params)) {
+ $params = array();
+ }
+ $url = new SimpleUrl($raw);
+ $this->assertIdentical($url->getScheme(), $parts[0], "[$raw] scheme -> %s");
+ $this->assertIdentical($url->getUsername(), $parts[1], "[$raw] username -> %s");
+ $this->assertIdentical($url->getPassword(), $parts[2], "[$raw] password -> %s");
+ $this->assertIdentical($url->getHost(), $parts[3], "[$raw] host -> %s");
+ $this->assertIdentical($url->getPort(), $parts[4], "[$raw] port -> %s");
+ $this->assertIdentical($url->getPath(), $parts[5], "[$raw] path -> %s");
+ $this->assertIdentical($url->getTld(), $parts[6], "[$raw] tld -> %s");
+ $this->assertIdentical($url->getEncodedRequest(), $parts[7], "[$raw] encoded -> %s");
+ $this->assertIdentical($url->getFragment(), $parts[8], "[$raw] fragment -> %s");
+ if ($coords) {
+ $this->assertIdentical($url->getX(), $coords[0], "[$raw] x -> %s");
+ $this->assertIdentical($url->getY(), $coords[1], "[$raw] y -> %s");
+ }
+ }
+
+ function testUrlWithTwoSlashesInPath() {
+ $url = new SimpleUrl('/article/categoryedit/insert//');
+ $this->assertEqual($url->getPath(), '/article/categoryedit/insert//');
+ }
+
+ function assertPreserved($string) {
+ $url = new SimpleUrl($string);
+ $this->assertEqual($url->asString(), $string);
+ }
+}
+
+class TestOfAbsoluteUrls extends UnitTestCase {
+
+ function testDirectoriesAfterFilename() {
+ $string = '../../index.php/foo/bar';
+ $url = new SimpleUrl($string);
+ $this->assertEqual($url->asString(), $string);
+
+ $absolute = $url->makeAbsolute('http://www.domain.com/some/path/');
+ $this->assertEqual($absolute->asString(), 'http://www.domain.com/index.php/foo/bar');
+ }
+
+ function testMakingAbsolute() {
+ $url = new SimpleUrl('../there/somewhere.php');
+ $this->assertEqual($url->getPath(), '../there/somewhere.php');
+ $absolute = $url->makeAbsolute('https://host.com:1234/I/am/here/');
+ $this->assertEqual($absolute->getScheme(), 'https');
+ $this->assertEqual($absolute->getHost(), 'host.com');
+ $this->assertEqual($absolute->getPort(), 1234);
+ $this->assertEqual($absolute->getPath(), '/I/am/there/somewhere.php');
+ }
+
+ function testMakingAnEmptyUrlAbsolute() {
+ $url = new SimpleUrl('');
+ $this->assertEqual($url->getPath(), '');
+ $absolute = $url->makeAbsolute('http://host.com/I/am/here/page.html');
+ $this->assertEqual($absolute->getScheme(), 'http');
+ $this->assertEqual($absolute->getHost(), 'host.com');
+ $this->assertEqual($absolute->getPath(), '/I/am/here/page.html');
+ }
+
+ function testMakingAnEmptyUrlAbsoluteWithMissingPageName() {
+ $url = new SimpleUrl('');
+ $this->assertEqual($url->getPath(), '');
+ $absolute = $url->makeAbsolute('http://host.com/I/am/here/');
+ $this->assertEqual($absolute->getScheme(), 'http');
+ $this->assertEqual($absolute->getHost(), 'host.com');
+ $this->assertEqual($absolute->getPath(), '/I/am/here/');
+ }
+
+ function testMakingAShortQueryUrlAbsolute() {
+ $url = new SimpleUrl('?a#b');
+ $this->assertEqual($url->getPath(), '');
+ $absolute = $url->makeAbsolute('http://host.com/I/am/here/');
+ $this->assertEqual($absolute->getScheme(), 'http');
+ $this->assertEqual($absolute->getHost(), 'host.com');
+ $this->assertEqual($absolute->getPath(), '/I/am/here/');
+ $this->assertEqual($absolute->getEncodedRequest(), '?a');
+ $this->assertEqual($absolute->getFragment(), 'b');
+ }
+
+ function testMakingADirectoryUrlAbsolute() {
+ $url = new SimpleUrl('hello/');
+ $this->assertEqual($url->getPath(), 'hello/');
+ $this->assertEqual($url->getBasePath(), 'hello/');
+ $this->assertEqual($url->getPage(), '');
+ $absolute = $url->makeAbsolute('http://host.com/I/am/here/page.html');
+ $this->assertEqual($absolute->getPath(), '/I/am/here/hello/');
+ }
+
+ function testMakingARootUrlAbsolute() {
+ $url = new SimpleUrl('/');
+ $this->assertEqual($url->getPath(), '/');
+ $absolute = $url->makeAbsolute('http://host.com/I/am/here/page.html');
+ $this->assertEqual($absolute->getPath(), '/');
+ }
+
+ function testMakingARootPageUrlAbsolute() {
+ $url = new SimpleUrl('/here.html');
+ $absolute = $url->makeAbsolute('http://host.com/I/am/here/page.html');
+ $this->assertEqual($absolute->getPath(), '/here.html');
+ }
+
+ function testCarryAuthenticationFromRootPage() {
+ $url = new SimpleUrl('here.html');
+ $absolute = $url->makeAbsolute('http://test:secret@host.com/');
+ $this->assertEqual($absolute->getPath(), '/here.html');
+ $this->assertEqual($absolute->getUsername(), 'test');
+ $this->assertEqual($absolute->getPassword(), 'secret');
+ }
+
+ function testMakingCoordinateUrlAbsolute() {
+ $url = new SimpleUrl('?1,2');
+ $this->assertEqual($url->getPath(), '');
+ $absolute = $url->makeAbsolute('http://host.com/I/am/here/');
+ $this->assertEqual($absolute->getScheme(), 'http');
+ $this->assertEqual($absolute->getHost(), 'host.com');
+ $this->assertEqual($absolute->getPath(), '/I/am/here/');
+ $this->assertEqual($absolute->getX(), 1);
+ $this->assertEqual($absolute->getY(), 2);
+ }
+
+ function testMakingAbsoluteAppendedPath() {
+ $url = new SimpleUrl('./there/somewhere.php');
+ $absolute = $url->makeAbsolute('https://host.com/here/');
+ $this->assertEqual($absolute->getPath(), '/here/there/somewhere.php');
+ }
+
+ function testMakingAbsoluteBadlyFormedAppendedPath() {
+ $url = new SimpleUrl('there/somewhere.php');
+ $absolute = $url->makeAbsolute('https://host.com/here/');
+ $this->assertEqual($absolute->getPath(), '/here/there/somewhere.php');
+ }
+
+ function testMakingAbsoluteHasNoEffectWhenAlreadyAbsolute() {
+ $url = new SimpleUrl('https://test:secret@www.lastcraft.com:321/stuff/?a=1#f');
+ $absolute = $url->makeAbsolute('http://host.com/here/');
+ $this->assertEqual($absolute->getScheme(), 'https');
+ $this->assertEqual($absolute->getUsername(), 'test');
+ $this->assertEqual($absolute->getPassword(), 'secret');
+ $this->assertEqual($absolute->getHost(), 'www.lastcraft.com');
+ $this->assertEqual($absolute->getPort(), 321);
+ $this->assertEqual($absolute->getPath(), '/stuff/');
+ $this->assertEqual($absolute->getEncodedRequest(), '?a=1');
+ $this->assertEqual($absolute->getFragment(), 'f');
+ }
+
+ function testMakingAbsoluteCarriesAuthenticationWhenAlreadyAbsolute() {
+ $url = new SimpleUrl('https://www.lastcraft.com');
+ $absolute = $url->makeAbsolute('http://test:secret@host.com/here/');
+ $this->assertEqual($absolute->getHost(), 'www.lastcraft.com');
+ $this->assertEqual($absolute->getUsername(), 'test');
+ $this->assertEqual($absolute->getPassword(), 'secret');
+ }
+
+ function testMakingHostOnlyAbsoluteDoesNotCarryAnyOtherInformation() {
+ $url = new SimpleUrl('http://www.lastcraft.com');
+ $absolute = $url->makeAbsolute('https://host.com:81/here/');
+ $this->assertEqual($absolute->getScheme(), 'http');
+ $this->assertEqual($absolute->getHost(), 'www.lastcraft.com');
+ $this->assertIdentical($absolute->getPort(), false);
+ $this->assertEqual($absolute->getPath(), '/');
+ }
+}
+
+class TestOfFrameUrl extends UnitTestCase {
+
+ function testTargetAttachment() {
+ $url = new SimpleUrl('http://www.site.com/home.html');
+ $this->assertIdentical($url->getTarget(), false);
+ $url->setTarget('A frame');
+ $this->assertIdentical($url->getTarget(), 'A frame');
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/user_agent_test.php b/vendors/simpletest/test/user_agent_test.php
new file mode 100755
index 000000000..657c7e155
--- /dev/null
+++ b/vendors/simpletest/test/user_agent_test.php
@@ -0,0 +1,358 @@
+<?php
+// $Id: user_agent_test.php 1509 2007-05-08 22:11:49Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../user_agent.php');
+require_once(dirname(__FILE__) . '/../authentication.php');
+require_once(dirname(__FILE__) . '/../http.php');
+require_once(dirname(__FILE__) . '/../encoding.php');
+Mock::generate('SimpleHttpRequest');
+Mock::generate('SimpleHttpResponse');
+Mock::generate('SimpleHttpHeaders');
+Mock::generatePartial('SimpleUserAgent', 'MockRequestUserAgent', array('_createHttpRequest'));
+
+class TestOfFetchingUrlParameters extends UnitTestCase {
+
+ function setUp() {
+ $this->_headers = &new MockSimpleHttpHeaders();
+
+ $this->_response = &new MockSimpleHttpResponse();
+ $this->_response->setReturnValue('isError', false);
+ $this->_response->setReturnReference('getHeaders', new MockSimpleHttpHeaders());
+
+ $this->_request = &new MockSimpleHttpRequest();
+ $this->_request->setReturnReference('fetch', $this->_response);
+ }
+
+ function testGetRequestWithoutIncidentGivesNoErrors() {
+ $url = new SimpleUrl('http://test:secret@this.com/page.html');
+ $url->addRequestParameters(array('a' => 'A', 'b' => 'B'));
+
+ $agent = &new MockRequestUserAgent();
+ $agent->setReturnReference('_createHttpRequest', $this->_request);
+ $agent->SimpleUserAgent();
+
+ $response = &$agent->fetchResponse(
+ new SimpleUrl('http://test:secret@this.com/page.html'),
+ new SimpleGetEncoding(array('a' => 'A', 'b' => 'B')));
+ $this->assertFalse($response->isError());
+ }
+}
+
+class TestOfAdditionalHeaders extends UnitTestCase {
+
+ function testAdditionalHeaderAddedToRequest() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnReference('getHeaders', new MockSimpleHttpHeaders());
+
+ $request = &new MockSimpleHttpRequest();
+ $request->setReturnReference('fetch', $response);
+ $request->expectOnce(
+ 'addHeaderLine',
+ array('User-Agent: SimpleTest'));
+
+ $agent = &new MockRequestUserAgent();
+ $agent->setReturnReference('_createHttpRequest', $request);
+ $agent->SimpleUserAgent();
+ $agent->addHeader('User-Agent: SimpleTest');
+ $response = &$agent->fetchResponse(new SimpleUrl('http://this.host/'), new SimpleGetEncoding());
+ }
+}
+
+class TestOfBrowserCookies extends UnitTestCase {
+
+ function &_createStandardResponse() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue("isError", false);
+ $response->setReturnValue("getContent", "stuff");
+ $response->setReturnReference("getHeaders", new MockSimpleHttpHeaders());
+ return $response;
+ }
+
+ function &_createCookieSite($header_lines) {
+ $headers = &new SimpleHttpHeaders($header_lines);
+
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue("isError", false);
+ $response->setReturnReference("getHeaders", $headers);
+ $response->setReturnValue("getContent", "stuff");
+
+ $request = &new MockSimpleHttpRequest();
+ $request->setReturnReference("fetch", $response);
+ return $request;
+ }
+
+ function &_createMockedRequestUserAgent(&$request) {
+ $agent = &new MockRequestUserAgent();
+ $agent->setReturnReference('_createHttpRequest', $request);
+ $agent->SimpleUserAgent();
+ return $agent;
+ }
+
+ function testCookieJarIsSentToRequest() {
+ $jar = new SimpleCookieJar();
+ $jar->setCookie('a', 'A');
+
+ $request = &new MockSimpleHttpRequest();
+ $request->setReturnReference('fetch', $this->_createStandardResponse());
+ $request->expectOnce('readCookiesFromJar', array($jar, '*'));
+
+ $agent = &$this->_createMockedRequestUserAgent($request);
+ $agent->setCookie('a', 'A');
+ $agent->fetchResponse(
+ new SimpleUrl('http://this.com/this/path/page.html'),
+ new SimpleGetEncoding());
+ }
+
+ function testNoCookieJarIsSentToRequestWhenCookiesAreDisabled() {
+ $request = &new MockSimpleHttpRequest();
+ $request->setReturnReference('fetch', $this->_createStandardResponse());
+ $request->expectNever('readCookiesFromJar');
+
+ $agent = &$this->_createMockedRequestUserAgent($request);
+ $agent->setCookie('a', 'A');
+ $agent->ignoreCookies();
+ $agent->fetchResponse(
+ new SimpleUrl('http://this.com/this/path/page.html'),
+ new SimpleGetEncoding());
+ }
+
+ function testReadingNewCookie() {
+ $request = &$this->_createCookieSite('Set-cookie: a=AAAA');
+ $agent = &$this->_createMockedRequestUserAgent($request);
+ $agent->fetchResponse(
+ new SimpleUrl('http://this.com/this/path/page.html'),
+ new SimpleGetEncoding());
+ $this->assertEqual($agent->getCookieValue("this.com", "this/path/", "a"), "AAAA");
+ }
+
+ function testIgnoringNewCookieWhenCookiesDisabled() {
+ $request = &$this->_createCookieSite('Set-cookie: a=AAAA');
+ $agent = &$this->_createMockedRequestUserAgent($request);
+ $agent->ignoreCookies();
+ $agent->fetchResponse(
+ new SimpleUrl('http://this.com/this/path/page.html'),
+ new SimpleGetEncoding());
+ $this->assertIdentical($agent->getCookieValue("this.com", "this/path/", "a"), false);
+ }
+
+ function testOverwriteCookieThatAlreadyExists() {
+ $request = &$this->_createCookieSite('Set-cookie: a=AAAA');
+ $agent = &$this->_createMockedRequestUserAgent($request);
+ $agent->setCookie('a', 'A');
+ $agent->fetchResponse(
+ new SimpleUrl('http://this.com/this/path/page.html'),
+ new SimpleGetEncoding());
+ $this->assertEqual($agent->getCookieValue("this.com", "this/path/", "a"), "AAAA");
+ }
+
+ function testClearCookieBySettingExpiry() {
+ $request = &$this->_createCookieSite('Set-cookie: a=b');
+ $agent = &$this->_createMockedRequestUserAgent($request);
+
+ $agent->setCookie("a", "A", "this/path/", "Wed, 25-Dec-02 04:24:21 GMT");
+ $agent->fetchResponse(
+ new SimpleUrl('http://this.com/this/path/page.html'),
+ new SimpleGetEncoding());
+ $this->assertIdentical(
+ $agent->getCookieValue("this.com", "this/path/", "a"),
+ "b");
+ $agent->restart("Wed, 25-Dec-02 04:24:20 GMT");
+ $this->assertIdentical(
+ $agent->getCookieValue("this.com", "this/path/", "a"),
+ false);
+ }
+
+ function testAgeingAndClearing() {
+ $request = &$this->_createCookieSite('Set-cookie: a=A; expires=Wed, 25-Dec-02 04:24:21 GMT; path=/this/path');
+ $agent = &$this->_createMockedRequestUserAgent($request);
+
+ $agent->fetchResponse(
+ new SimpleUrl('http://this.com/this/path/page.html'),
+ new SimpleGetEncoding());
+ $agent->restart("Wed, 25-Dec-02 04:24:20 GMT");
+ $this->assertIdentical(
+ $agent->getCookieValue("this.com", "this/path/", "a"),
+ "A");
+ $agent->ageCookies(2);
+ $agent->restart("Wed, 25-Dec-02 04:24:20 GMT");
+ $this->assertIdentical(
+ $agent->getCookieValue("this.com", "this/path/", "a"),
+ false);
+ }
+
+ function testReadingIncomingAndSettingNewCookies() {
+ $request = &$this->_createCookieSite('Set-cookie: a=AAA');
+ $agent = &$this->_createMockedRequestUserAgent($request);
+
+ $this->assertNull($agent->getBaseCookieValue("a", false));
+ $agent->fetchResponse(
+ new SimpleUrl('http://this.com/this/path/page.html'),
+ new SimpleGetEncoding());
+ $agent->setCookie("b", "BBB", "this.com", "this/path/");
+ $this->assertEqual(
+ $agent->getBaseCookieValue("a", new SimpleUrl('http://this.com/this/path/page.html')),
+ "AAA");
+ $this->assertEqual(
+ $agent->getBaseCookieValue("b", new SimpleUrl('http://this.com/this/path/page.html')),
+ "BBB");
+ }
+}
+
+class TestOfHttpRedirects extends UnitTestCase {
+
+ function &createRedirect($content, $redirect) {
+ $headers = &new MockSimpleHttpHeaders();
+ $headers->setReturnValue('isRedirect', (boolean)$redirect);
+ $headers->setReturnValue('getLocation', $redirect);
+
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('getContent', $content);
+ $response->setReturnReference('getHeaders', $headers);
+
+ $request = &new MockSimpleHttpRequest();
+ $request->setReturnReference('fetch', $response);
+ return $request;
+ }
+
+ function testDisabledRedirects() {
+ $agent = &new MockRequestUserAgent();
+ $agent->setReturnReference(
+ '_createHttpRequest',
+ $this->createRedirect('stuff', 'there.html'));
+ $agent->expectOnce('_createHttpRequest');
+ $agent->SimpleUserAgent();
+
+ $agent->setMaximumRedirects(0);
+ $response = &$agent->fetchResponse(new SimpleUrl('here.html'), new SimpleGetEncoding());
+ $this->assertEqual($response->getContent(), 'stuff');
+ }
+
+ function testSingleRedirect() {
+ $agent = &new MockRequestUserAgent();
+ $agent->setReturnReferenceAt(
+ 0,
+ '_createHttpRequest',
+ $this->createRedirect('first', 'two.html'));
+ $agent->setReturnReferenceAt(
+ 1,
+ '_createHttpRequest',
+ $this->createRedirect('second', 'three.html'));
+ $agent->expectCallCount('_createHttpRequest', 2);
+ $agent->SimpleUserAgent();
+
+ $agent->setMaximumRedirects(1);
+ $response = &$agent->fetchResponse(new SimpleUrl('one.html'), new SimpleGetEncoding());
+ $this->assertEqual($response->getContent(), 'second');
+ }
+
+ function testDoubleRedirect() {
+ $agent = &new MockRequestUserAgent();
+ $agent->setReturnReferenceAt(
+ 0,
+ '_createHttpRequest',
+ $this->createRedirect('first', 'two.html'));
+ $agent->setReturnReferenceAt(
+ 1,
+ '_createHttpRequest',
+ $this->createRedirect('second', 'three.html'));
+ $agent->setReturnReferenceAt(
+ 2,
+ '_createHttpRequest',
+ $this->createRedirect('third', 'four.html'));
+ $agent->expectCallCount('_createHttpRequest', 3);
+ $agent->SimpleUserAgent();
+
+ $agent->setMaximumRedirects(2);
+ $response = &$agent->fetchResponse(new SimpleUrl('one.html'), new SimpleGetEncoding());
+ $this->assertEqual($response->getContent(), 'third');
+ }
+
+ function testSuccessAfterRedirect() {
+ $agent = &new MockRequestUserAgent();
+ $agent->setReturnReferenceAt(
+ 0,
+ '_createHttpRequest',
+ $this->createRedirect('first', 'two.html'));
+ $agent->setReturnReferenceAt(
+ 1,
+ '_createHttpRequest',
+ $this->createRedirect('second', false));
+ $agent->setReturnReferenceAt(
+ 2,
+ '_createHttpRequest',
+ $this->createRedirect('third', 'four.html'));
+ $agent->expectCallCount('_createHttpRequest', 2);
+ $agent->SimpleUserAgent();
+
+ $agent->setMaximumRedirects(2);
+ $response = &$agent->fetchResponse(new SimpleUrl('one.html'), new SimpleGetEncoding());
+ $this->assertEqual($response->getContent(), 'second');
+ }
+
+ function testRedirectChangesPostToGet() {
+ $agent = &new MockRequestUserAgent();
+ $agent->setReturnReferenceAt(
+ 0,
+ '_createHttpRequest',
+ $this->createRedirect('first', 'two.html'));
+ $agent->expectArgumentsAt(0, '_createHttpRequest', array('*', new IsAExpectation('SimplePostEncoding')));
+ $agent->setReturnReferenceAt(
+ 1,
+ '_createHttpRequest',
+ $this->createRedirect('second', 'three.html'));
+ $agent->expectArgumentsAt(1, '_createHttpRequest', array('*', new IsAExpectation('SimpleGetEncoding')));
+ $agent->expectCallCount('_createHttpRequest', 2);
+ $agent->SimpleUserAgent();
+ $agent->setMaximumRedirects(1);
+ $response = &$agent->fetchResponse(new SimpleUrl('one.html'), new SimplePostEncoding());
+ }
+}
+
+class TestOfBadHosts extends UnitTestCase {
+
+ function &_createSimulatedBadHost() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnValue('isError', true);
+ $response->setReturnValue('getError', 'Bad socket');
+ $response->setReturnValue('getContent', false);
+
+ $request = &new MockSimpleHttpRequest();
+ $request->setReturnReference('fetch', $response);
+ return $request;
+ }
+
+ function testUntestedHost() {
+ $request = &$this->_createSimulatedBadHost();
+
+ $agent = &new MockRequestUserAgent();
+ $agent->setReturnReference('_createHttpRequest', $request);
+ $agent->SimpleUserAgent();
+
+ $response = &$agent->fetchResponse(
+ new SimpleUrl('http://this.host/this/path/page.html'),
+ new SimpleGetEncoding());
+ $this->assertTrue($response->isError());
+ }
+}
+
+class TestOfAuthorisation extends UnitTestCase {
+
+ function testAuthenticateHeaderAdded() {
+ $response = &new MockSimpleHttpResponse();
+ $response->setReturnReference('getHeaders', new MockSimpleHttpHeaders());
+
+ $request = &new MockSimpleHttpRequest();
+ $request->setReturnReference('fetch', $response);
+ $request->expectOnce(
+ 'addHeaderLine',
+ array('Authorization: Basic ' . base64_encode('test:secret')));
+
+ $agent = &new MockRequestUserAgent();
+ $agent->setReturnReference('_createHttpRequest', $request);
+ $agent->SimpleUserAgent();
+ $response = &$agent->fetchResponse(
+ new SimpleUrl('http://test:secret@this.host'),
+ new SimpleGetEncoding());
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/visual_test.php b/vendors/simpletest/test/visual_test.php
new file mode 100755
index 000000000..13781bb65
--- /dev/null
+++ b/vendors/simpletest/test/visual_test.php
@@ -0,0 +1,495 @@
+<?php
+ // $Id: visual_test.php 1547 2007-07-04 00:42:05Z lastcraft $
+
+ // NOTE:
+ // Some of these tests are designed to fail! Do not be alarmed.
+ // ----------------
+
+ // The following tests are a bit hacky. Whilst Kent Beck tried to
+ // build a unit tester with a unit tester, I am not that brave.
+ // Instead I have just hacked together odd test scripts until
+ // I have enough of a tester to procede more formally.
+ //
+ // The proper tests start in all_tests.php
+ require_once('../unit_tester.php');
+ require_once('../shell_tester.php');
+ require_once('../mock_objects.php');
+ require_once('../reporter.php');
+ require_once('../xml.php');
+
+ class TestDisplayClass {
+ var $_a;
+
+ function TestDisplayClass($a) {
+ $this->_a = $a;
+ }
+ }
+
+ class PassingUnitTestCaseOutput extends UnitTestCase {
+
+ function testOfResults() {
+ $this->pass('Pass');
+ }
+
+ function testTrue() {
+ $this->assertTrue(true);
+ }
+
+ function testFalse() {
+ $this->assertFalse(false);
+ }
+
+ function testExpectation() {
+ $expectation = &new EqualExpectation(25, 'My expectation message: %s');
+ $this->assert($expectation, 25, 'My assert message : %s');
+ }
+
+ function testNull() {
+ $this->assertNull(null, "%s -> Pass");
+ $this->assertNotNull(false, "%s -> Pass");
+ }
+
+ function testType() {
+ $this->assertIsA("hello", "string", "%s -> Pass");
+ $this->assertIsA($this, "PassingUnitTestCaseOutput", "%s -> Pass");
+ $this->assertIsA($this, "UnitTestCase", "%s -> Pass");
+ }
+
+ function testTypeEquality() {
+ $this->assertEqual("0", 0, "%s -> Pass");
+ }
+
+ function testNullEquality() {
+ $this->assertNotEqual(null, 1, "%s -> Pass");
+ $this->assertNotEqual(1, null, "%s -> Pass");
+ }
+
+ function testIntegerEquality() {
+ $this->assertNotEqual(1, 2, "%s -> Pass");
+ }
+
+ function testStringEquality() {
+ $this->assertEqual("a", "a", "%s -> Pass");
+ $this->assertNotEqual("aa", "ab", "%s -> Pass");
+ }
+
+ function testHashEquality() {
+ $this->assertEqual(array("a" => "A", "b" => "B"), array("b" => "B", "a" => "A"), "%s -> Pass");
+ }
+
+ function testWithin() {
+ $this->assertWithinMargin(5, 5.4, 0.5, "%s -> Pass");
+ }
+
+ function testOutside() {
+ $this->assertOutsideMargin(5, 5.6, 0.5, "%s -> Pass");
+ }
+
+ function testStringIdentity() {
+ $a = "fred";
+ $b = $a;
+ $this->assertIdentical($a, $b, "%s -> Pass");
+ }
+
+ function testTypeIdentity() {
+ $a = "0";
+ $b = 0;
+ $this->assertNotIdentical($a, $b, "%s -> Pass");
+ }
+
+ function testNullIdentity() {
+ $this->assertNotIdentical(null, 1, "%s -> Pass");
+ $this->assertNotIdentical(1, null, "%s -> Pass");
+ }
+
+ function testHashIdentity() {
+ }
+
+ function testObjectEquality() {
+ $this->assertEqual(new TestDisplayClass(4), new TestDisplayClass(4), "%s -> Pass");
+ $this->assertNotEqual(new TestDisplayClass(4), new TestDisplayClass(5), "%s -> Pass");
+ }
+
+ function testObjectIndentity() {
+ $this->assertIdentical(new TestDisplayClass(false), new TestDisplayClass(false), "%s -> Pass");
+ $this->assertNotIdentical(new TestDisplayClass(false), new TestDisplayClass(0), "%s -> Pass");
+ }
+
+ function testReference() {
+ $a = "fred";
+ $b = &$a;
+ $this->assertReference($a, $b, "%s -> Pass");
+ }
+
+ function testCloneOnDifferentObjects() {
+ $a = "fred";
+ $b = $a;
+ $c = "Hello";
+ $this->assertClone($a, $b, "%s -> Pass");
+ }
+
+ function testPatterns() {
+ $this->assertPattern('/hello/i', "Hello there", "%s -> Pass");
+ $this->assertNoPattern('/hello/', "Hello there", "%s -> Pass");
+ }
+
+ function testLongStrings() {
+ $text = "";
+ for ($i = 0; $i < 10; $i++) {
+ $text .= "0123456789";
+ }
+ $this->assertEqual($text, $text);
+ }
+ }
+
+ class FailingUnitTestCaseOutput extends UnitTestCase {
+
+ function testOfResults() {
+ $this->fail('Fail'); // Fail.
+ }
+
+ function testTrue() {
+ $this->assertTrue(false); // Fail.
+ }
+
+ function testFalse() {
+ $this->assertFalse(true); // Fail.
+ }
+
+ function testExpectation() {
+ $expectation = &new EqualExpectation(25, 'My expectation message: %s');
+ $this->assert($expectation, 24, 'My assert message : %s'); // Fail.
+ }
+
+ function testNull() {
+ $this->assertNull(false, "%s -> Fail"); // Fail.
+ $this->assertNotNull(null, "%s -> Fail"); // Fail.
+ }
+
+ function testType() {
+ $this->assertIsA(14, "string", "%s -> Fail"); // Fail.
+ $this->assertIsA(14, "TestOfUnitTestCaseOutput", "%s -> Fail"); // Fail.
+ $this->assertIsA($this, "TestReporter", "%s -> Fail"); // Fail.
+ }
+
+ function testTypeEquality() {
+ $this->assertNotEqual("0", 0, "%s -> Fail"); // Fail.
+ }
+
+ function testNullEquality() {
+ $this->assertEqual(null, 1, "%s -> Fail"); // Fail.
+ $this->assertEqual(1, null, "%s -> Fail"); // Fail.
+ }
+
+ function testIntegerEquality() {
+ $this->assertEqual(1, 2, "%s -> Fail"); // Fail.
+ }
+
+ function testStringEquality() {
+ $this->assertNotEqual("a", "a", "%s -> Fail"); // Fail.
+ $this->assertEqual("aa", "ab", "%s -> Fail"); // Fail.
+ }
+
+ function testHashEquality() {
+ $this->assertEqual(array("a" => "A", "b" => "B"), array("b" => "B", "a" => "Z"), "%s -> Fail");
+ }
+
+ function testWithin() {
+ $this->assertWithinMargin(5, 5.6, 0.5, "%s -> Fail"); // Fail.
+ }
+
+ function testOutside() {
+ $this->assertOutsideMargin(5, 5.4, 0.5, "%s -> Fail"); // Fail.
+ }
+
+ function testStringIdentity() {
+ $a = "fred";
+ $b = $a;
+ $this->assertNotIdentical($a, $b, "%s -> Fail"); // Fail.
+ }
+
+ function testTypeIdentity() {
+ $a = "0";
+ $b = 0;
+ $this->assertIdentical($a, $b, "%s -> Fail"); // Fail.
+ }
+
+ function testNullIdentity() {
+ $this->assertIdentical(null, 1, "%s -> Fail"); // Fail.
+ $this->assertIdentical(1, null, "%s -> Fail"); // Fail.
+ }
+
+ function testHashIdentity() {
+ $this->assertIdentical(array("a" => "A", "b" => "B"), array("b" => "B", "a" => "A"), "%s -> fail"); // Fail.
+ }
+
+ function testObjectEquality() {
+ $this->assertNotEqual(new TestDisplayClass(4), new TestDisplayClass(4), "%s -> Fail"); // Fail.
+ $this->assertEqual(new TestDisplayClass(4), new TestDisplayClass(5), "%s -> Fail"); // Fail.
+ }
+
+ function testObjectIndentity() {
+ $this->assertNotIdentical(new TestDisplayClass(false), new TestDisplayClass(false), "%s -> Fail"); // Fail.
+ $this->assertIdentical(new TestDisplayClass(false), new TestDisplayClass(0), "%s -> Fail"); // Fail.
+ }
+
+ function testReference() {
+ $a = "fred";
+ $b = &$a;
+ $this->assertClone($a, $b, "%s -> Fail"); // Fail.
+ }
+
+ function testCloneOnDifferentObjects() {
+ $a = "fred";
+ $b = $a;
+ $c = "Hello";
+ $this->assertClone($a, $c, "%s -> Fail"); // Fail.
+ }
+
+ function testPatterns() {
+ $this->assertPattern('/hello/', "Hello there", "%s -> Fail"); // Fail.
+ $this->assertNoPattern('/hello/i', "Hello there", "%s -> Fail"); // Fail.
+ }
+
+ function testLongStrings() {
+ $text = "";
+ for ($i = 0; $i < 10; $i++) {
+ $text .= "0123456789";
+ }
+ $this->assertEqual($text . $text, $text . "a" . $text); // Fail.
+ }
+ }
+
+ class Dummy {
+ function Dummy() {
+ }
+
+ function a() {
+ }
+ }
+ Mock::generate('Dummy');
+
+ class TestOfMockObjectsOutput extends UnitTestCase {
+
+ function testCallCounts() {
+ $dummy = &new MockDummy();
+ $dummy->expectCallCount('a', 1, 'My message: %s');
+ $dummy->a();
+ $dummy->a();
+ }
+
+ function testMinimumCallCounts() {
+ $dummy = &new MockDummy();
+ $dummy->expectMinimumCallCount('a', 2, 'My message: %s');
+ $dummy->a();
+ $dummy->a();
+ }
+
+ function testEmptyMatching() {
+ $dummy = &new MockDummy();
+ $dummy->expectArguments('a', array());
+ $dummy->a();
+ $dummy->a(null); // Fail.
+ }
+
+ function testEmptyMatchingWithCustomMessage() {
+ $dummy = &new MockDummy();
+ $dummy->expectArguments('a', array(), 'My expectation message: %s');
+ $dummy->a();
+ $dummy->a(null); // Fail.
+ }
+
+ function testNullMatching() {
+ $dummy = &new MockDummy();
+ $dummy->expectArguments('a', array(null));
+ $dummy->a(null);
+ $dummy->a(); // Fail.
+ }
+
+ function testBooleanMatching() {
+ $dummy = &new MockDummy();
+ $dummy->expectArguments('a', array(true, false));
+ $dummy->a(true, false);
+ $dummy->a(true, true); // Fail.
+ }
+
+ function testIntegerMatching() {
+ $dummy = &new MockDummy();
+ $dummy->expectArguments('a', array(32, 33));
+ $dummy->a(32, 33);
+ $dummy->a(32, 34); // Fail.
+ }
+
+ function testFloatMatching() {
+ $dummy = &new MockDummy();
+ $dummy->expectArguments('a', array(3.2, 3.3));
+ $dummy->a(3.2, 3.3);
+ $dummy->a(3.2, 3.4); // Fail.
+ }
+
+ function testStringMatching() {
+ $dummy = &new MockDummy();
+ $dummy->expectArguments('a', array('32', '33'));
+ $dummy->a('32', '33');
+ $dummy->a('32', '34'); // Fail.
+ }
+
+ function testEmptyMatchingWithCustomExpectationMessage() {
+ $dummy = &new MockDummy();
+ $dummy->expectArguments(
+ 'a',
+ array(new EqualExpectation('A', 'My part expectation message: %s')),
+ 'My expectation message: %s');
+ $dummy->a('A');
+ $dummy->a('B'); // Fail.
+ }
+
+ function testArrayMatching() {
+ $dummy = &new MockDummy();
+ $dummy->expectArguments('a', array(array(32), array(33)));
+ $dummy->a(array(32), array(33));
+ $dummy->a(array(32), array('33')); // Fail.
+ }
+
+ function testObjectMatching() {
+ $a = new Dummy();
+ $a->a = 'a';
+ $b = new Dummy();
+ $b->b = 'b';
+ $dummy = &new MockDummy();
+ $dummy->expectArguments('a', array($a, $b));
+ $dummy->a($a, $b);
+ $dummy->a($a, $a); // Fail.
+ }
+
+ function testBigList() {
+ $dummy = &new MockDummy();
+ $dummy->expectArguments('a', array(false, 0, 1, 1.0));
+ $dummy->a(false, 0, 1, 1.0);
+ $dummy->a(true, false, 2, 2.0); // Fail.
+ }
+ }
+
+ class TestOfPastBugs extends UnitTestCase {
+
+ function testMixedTypes() {
+ $this->assertEqual(array(), null, "%s -> Pass");
+ $this->assertIdentical(array(), null, "%s -> Fail"); // Fail.
+ }
+
+ function testMockWildcards() {
+ $dummy = &new MockDummy();
+ $dummy->expectArguments('a', array('*', array(33)));
+ $dummy->a(array(32), array(33));
+ $dummy->a(array(32), array('33')); // Fail.
+ }
+ }
+
+ class TestOfVisualShell extends ShellTestCase {
+
+ function testDump() {
+ $this->execute('ls');
+ $this->dumpOutput();
+ $this->execute('dir');
+ $this->dumpOutput();
+ }
+
+ function testDumpOfList() {
+ $this->execute('ls');
+ $this->dump($this->getOutputAsList());
+ }
+ }
+
+ class PassesAsWellReporter extends HtmlReporter {
+
+ function _getCss() {
+ return parent::_getCss() . ' .pass { color: darkgreen; }';
+ }
+
+ function paintPass($message) {
+ parent::paintPass($message);
+ print "<span class=\"pass\">Pass</span>: ";
+ $breadcrumb = $this->getTestList();
+ array_shift($breadcrumb);
+ print implode(" -&gt; ", $breadcrumb);
+ print " -&gt; " . htmlentities($message) . "<br />\n";
+ }
+
+ function paintSignal($type, &$payload) {
+ print "<span class=\"fail\">$type</span>: ";
+ $breadcrumb = $this->getTestList();
+ array_shift($breadcrumb);
+ print implode(" -&gt; ", $breadcrumb);
+ print " -&gt; " . htmlentities(serialize($payload)) . "<br />\n";
+ }
+ }
+
+ class TestOfSkippingNoMatterWhat extends UnitTestCase {
+ function skip() {
+ $this->skipIf(true, 'Always skipped -> %s');
+ }
+
+ function testFail() {
+ $this->fail('This really shouldn\'t have happened');
+ }
+ }
+
+ class TestOfSkippingOrElse extends UnitTestCase {
+ function skip() {
+ $this->skipUnless(false, 'Always skipped -> %s');
+ }
+
+ function testFail() {
+ $this->fail('This really shouldn\'t have happened');
+ }
+ }
+
+ class TestOfSkippingTwiceOver extends UnitTestCase {
+ function skip() {
+ $this->skipIf(true, 'First reason -> %s');
+ $this->skipIf(true, 'Second reason -> %s');
+ }
+
+ function testFail() {
+ $this->fail('This really shouldn\'t have happened');
+ }
+ }
+
+ class TestThatShouldNotBeSkipped extends UnitTestCase {
+ function skip() {
+ $this->skipIf(false);
+ $this->skipUnless(true);
+ }
+
+ function testFail() {
+ $this->fail('We should see this message');
+ }
+
+ function testPass() {
+ $this->pass('We should see this message');
+ }
+ }
+
+ $test = &new TestSuite('Visual test with 46 passes, 47 fails and 0 exceptions');
+ $test->addTestCase(new PassingUnitTestCaseOutput());
+ $test->addTestCase(new FailingUnitTestCaseOutput());
+ $test->addTestCase(new TestOfMockObjectsOutput());
+ $test->addTestCase(new TestOfPastBugs());
+ $test->addTestCase(new TestOfVisualShell());
+ $test->addTestCase(new TestOfSkippingNoMatterWhat());
+ $test->addTestCase(new TestOfSkippingOrElse());
+ $test->addTestCase(new TestOfSkippingTwiceOver());
+ $test->addTestCase(new TestThatShouldNotBeSkipped());
+
+ if (isset($_GET['xml']) || in_array('xml', (isset($argv) ? $argv : array()))) {
+ $reporter = &new XmlReporter();
+ } elseif (TextReporter::inCli()) {
+ $reporter = &new TextReporter();
+ } else {
+ $reporter = &new PassesAsWellReporter();
+ }
+ if (isset($_GET['dry']) || in_array('dry', (isset($argv) ? $argv : array()))) {
+ $reporter->makeDry();
+ }
+ exit ($test->run($reporter) ? 0 : 1);
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/web_tester_test.php b/vendors/simpletest/test/web_tester_test.php
new file mode 100755
index 000000000..01f7d3c8c
--- /dev/null
+++ b/vendors/simpletest/test/web_tester_test.php
@@ -0,0 +1,156 @@
+<?php
+// $Id: web_tester_test.php 1509 2007-05-08 22:11:49Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../web_tester.php');
+
+class TestOfFieldExpectation extends UnitTestCase {
+
+ function testStringMatchingIsCaseSensitive() {
+ $expectation = new FieldExpectation('a');
+ $this->assertTrue($expectation->test('a'));
+ $this->assertTrue($expectation->test(array('a')));
+ $this->assertFalse($expectation->test('A'));
+ }
+
+ function testMatchesInteger() {
+ $expectation = new FieldExpectation('1');
+ $this->assertTrue($expectation->test('1'));
+ $this->assertTrue($expectation->test(1));
+ $this->assertTrue($expectation->test(array('1')));
+ $this->assertTrue($expectation->test(array(1)));
+ }
+
+ function testNonStringFailsExpectation() {
+ $expectation = new FieldExpectation('a');
+ $this->assertFalse($expectation->test(null));
+ }
+
+ function testUnsetFieldCanBeTestedFor() {
+ $expectation = new FieldExpectation(false);
+ $this->assertTrue($expectation->test(false));
+ }
+
+ function testMultipleValuesCanBeInAnyOrder() {
+ $expectation = new FieldExpectation(array('a', 'b'));
+ $this->assertTrue($expectation->test(array('a', 'b')));
+ $this->assertTrue($expectation->test(array('b', 'a')));
+ $this->assertFalse($expectation->test(array('a', 'a')));
+ $this->assertFalse($expectation->test('a'));
+ }
+
+ function testSingleItemCanBeArrayOrString() {
+ $expectation = new FieldExpectation(array('a'));
+ $this->assertTrue($expectation->test(array('a')));
+ $this->assertTrue($expectation->test('a'));
+ }
+}
+
+class TestOfHeaderExpectations extends UnitTestCase {
+
+ function testExpectingOnlyTheHeaderName() {
+ $expectation = new HttpHeaderExpectation('a');
+ $this->assertIdentical($expectation->test(false), false);
+ $this->assertIdentical($expectation->test('a: A'), true);
+ $this->assertIdentical($expectation->test('A: A'), true);
+ $this->assertIdentical($expectation->test('a: B'), true);
+ $this->assertIdentical($expectation->test(' a : A '), true);
+ }
+
+ function testHeaderValueAsWell() {
+ $expectation = new HttpHeaderExpectation('a', 'A');
+ $this->assertIdentical($expectation->test(false), false);
+ $this->assertIdentical($expectation->test('a: A'), true);
+ $this->assertIdentical($expectation->test('A: A'), true);
+ $this->assertIdentical($expectation->test('A: a'), false);
+ $this->assertIdentical($expectation->test('a: B'), false);
+ $this->assertIdentical($expectation->test(' a : A '), true);
+ $this->assertIdentical($expectation->test(' a : AB '), false);
+ }
+
+ function testHeaderValueWithColons() {
+ $expectation = new HttpHeaderExpectation('a', 'A:B:C');
+ $this->assertIdentical($expectation->test('a: A'), false);
+ $this->assertIdentical($expectation->test('a: A:B'), false);
+ $this->assertIdentical($expectation->test('a: A:B:C'), true);
+ $this->assertIdentical($expectation->test('a: A:B:C:D'), false);
+ }
+
+ function testMultilineSearch() {
+ $expectation = new HttpHeaderExpectation('a', 'A');
+ $this->assertIdentical($expectation->test("aa: A\r\nb: B\r\nc: C"), false);
+ $this->assertIdentical($expectation->test("aa: A\r\na: A\r\nb: B"), true);
+ }
+
+ function testMultilineSearchWithPadding() {
+ $expectation = new HttpHeaderExpectation('a', ' A ');
+ $this->assertIdentical($expectation->test("aa:A\r\nb:B\r\nc:C"), false);
+ $this->assertIdentical($expectation->test("aa:A\r\na:A\r\nb:B"), true);
+ }
+
+ function testPatternMatching() {
+ $expectation = new HttpHeaderExpectation('a', new PatternExpectation('/A/'));
+ $this->assertIdentical($expectation->test('a: A'), true);
+ $this->assertIdentical($expectation->test('A: A'), true);
+ $this->assertIdentical($expectation->test('A: a'), false);
+ $this->assertIdentical($expectation->test('a: B'), false);
+ $this->assertIdentical($expectation->test(' a : A '), true);
+ $this->assertIdentical($expectation->test(' a : AB '), true);
+ }
+
+ function testCaseInsensitivePatternMatching() {
+ $expectation = new HttpHeaderExpectation('a', new PatternExpectation('/A/i'));
+ $this->assertIdentical($expectation->test('a: a'), true);
+ $this->assertIdentical($expectation->test('a: B'), false);
+ $this->assertIdentical($expectation->test(' a : A '), true);
+ $this->assertIdentical($expectation->test(' a : BAB '), true);
+ $this->assertIdentical($expectation->test(' a : bab '), true);
+ }
+
+ function testUnwantedHeader() {
+ $expectation = new NoHttpHeaderExpectation('a');
+ $this->assertIdentical($expectation->test(''), true);
+ $this->assertIdentical($expectation->test('stuff'), true);
+ $this->assertIdentical($expectation->test('b: B'), true);
+ $this->assertIdentical($expectation->test('a: A'), false);
+ $this->assertIdentical($expectation->test('A: A'), false);
+ }
+
+ function testMultilineUnwantedSearch() {
+ $expectation = new NoHttpHeaderExpectation('a');
+ $this->assertIdentical($expectation->test("aa:A\r\nb:B\r\nc:C"), true);
+ $this->assertIdentical($expectation->test("aa:A\r\na:A\r\nb:B"), false);
+ }
+
+ function testLocationHeaderSplitsCorrectly() {
+ $expectation = new HttpHeaderExpectation('Location', 'http://here/');
+ $this->assertIdentical($expectation->test('Location: http://here/'), true);
+ }
+}
+
+class TestOfTextExpectations extends UnitTestCase {
+
+ function testMatchingSubString() {
+ $expectation = new TextExpectation('wanted');
+ $this->assertIdentical($expectation->test(''), false);
+ $this->assertIdentical($expectation->test('Wanted'), false);
+ $this->assertIdentical($expectation->test('wanted'), true);
+ $this->assertIdentical($expectation->test('the wanted text is here'), true);
+ }
+
+ function testNotMatchingSubString() {
+ $expectation = new NoTextExpectation('wanted');
+ $this->assertIdentical($expectation->test(''), true);
+ $this->assertIdentical($expectation->test('Wanted'), true);
+ $this->assertIdentical($expectation->test('wanted'), false);
+ $this->assertIdentical($expectation->test('the wanted text is here'), false);
+ }
+}
+
+class TestOfGenericAssertionsInWebTester extends WebTestCase {
+
+ function testEquality() {
+ $this->assertEqual('a', 'a');
+ $this->assertNotEqual('a', 'A');
+ }
+}
+?> \ No newline at end of file
diff --git a/vendors/simpletest/test/xml_test.php b/vendors/simpletest/test/xml_test.php
new file mode 100755
index 000000000..91985b5d5
--- /dev/null
+++ b/vendors/simpletest/test/xml_test.php
@@ -0,0 +1,187 @@
+<?php
+// $Id: xml_test.php 1509 2007-05-08 22:11:49Z lastcraft $
+require_once(dirname(__FILE__) . '/../autorun.php');
+require_once(dirname(__FILE__) . '/../xml.php');
+Mock::generate('SimpleScorer');
+
+if (! function_exists('xml_parser_create')) {
+ SimpleTest::ignore('TestOfXmlStructureParsing');
+ SimpleTest::ignore('TestOfXmlResultsParsing');
+}
+
+class TestOfNestingTags extends UnitTestCase {
+ function testGroupSize() {
+ $nesting = new NestingGroupTag(array('SIZE' => 2));
+ $this->assertEqual($nesting->getSize(), 2);
+ }
+}
+
+class TestOfXmlStructureParsing extends UnitTestCase {
+ function testValidXml() {
+ $listener = &new MockSimpleScorer();
+ $listener->expectNever('paintGroupStart');
+ $listener->expectNever('paintGroupEnd');
+ $listener->expectNever('paintCaseStart');
+ $listener->expectNever('paintCaseEnd');
+ $parser = &new SimpleTestXmlParser($listener);
+ $this->assertTrue($parser->parse("<?xml version=\"1.0\"?>\n"));
+ $this->assertTrue($parser->parse("<run>\n"));
+ $this->assertTrue($parser->parse("</run>\n"));
+ }
+
+ function testEmptyGroup() {
+ $listener = &new MockSimpleScorer();
+ $listener->expectOnce('paintGroupStart', array('a_group', 7));
+ $listener->expectOnce('paintGroupEnd', array('a_group'));
+ $parser = &new SimpleTestXmlParser($listener);
+ $parser->parse("<?xml version=\"1.0\"?>\n");
+ $parser->parse("<run>\n");
+ $this->assertTrue($parser->parse("<group size=\"7\">\n"));
+ $this->assertTrue($parser->parse("<name>a_group</name>\n"));
+ $this->assertTrue($parser->parse("</group>\n"));
+ $parser->parse("</run>\n");
+ }
+
+ function testEmptyCase() {
+ $listener = &new MockSimpleScorer();
+ $listener->expectOnce('paintCaseStart', array('a_case'));
+ $listener->expectOnce('paintCaseEnd', array('a_case'));
+ $parser = &new SimpleTestXmlParser($listener);
+ $parser->parse("<?xml version=\"1.0\"?>\n");
+ $parser->parse("<run>\n");
+ $this->assertTrue($parser->parse("<case>\n"));
+ $this->assertTrue($parser->parse("<name>a_case</name>\n"));
+ $this->assertTrue($parser->parse("</case>\n"));
+ $parser->parse("</run>\n");
+ }
+
+ function testEmptyMethod() {
+ $listener = &new MockSimpleScorer();
+ $listener->expectOnce('paintCaseStart', array('a_case'));
+ $listener->expectOnce('paintCaseEnd', array('a_case'));
+ $listener->expectOnce('paintMethodStart', array('a_method'));
+ $listener->expectOnce('paintMethodEnd', array('a_method'));
+ $parser = &new SimpleTestXmlParser($listener);
+ $parser->parse("<?xml version=\"1.0\"?>\n");
+ $parser->parse("<run>\n");
+ $parser->parse("<case>\n");
+ $parser->parse("<name>a_case</name>\n");
+ $this->assertTrue($parser->parse("<test>\n"));
+ $this->assertTrue($parser->parse("<name>a_method</name>\n"));
+ $this->assertTrue($parser->parse("</test>\n"));
+ $parser->parse("</case>\n");
+ $parser->parse("</run>\n");
+ }
+
+ function testNestedGroup() {
+ $listener = &new MockSimpleScorer();
+ $listener->expectArgumentsAt(0, 'paintGroupStart', array('a_group', 7));
+ $listener->expectArgumentsAt(1, 'paintGroupStart', array('b_group', 3));
+ $listener->expectCallCount('paintGroupStart', 2);
+ $listener->expectArgumentsAt(0, 'paintGroupEnd', array('b_group'));
+ $listener->expectArgumentsAt(1, 'paintGroupEnd', array('a_group'));
+ $listener->expectCallCount('paintGroupEnd', 2);
+
+ $parser = &new SimpleTestXmlParser($listener);
+ $parser->parse("<?xml version=\"1.0\"?>\n");
+ $parser->parse("<run>\n");
+
+ $this->assertTrue($parser->parse("<group size=\"7\">\n"));
+ $this->assertTrue($parser->parse("<name>a_group</name>\n"));
+ $this->assertTrue($parser->parse("<group size=\"3\">\n"));
+ $this->assertTrue($parser->parse("<name>b_group</name>\n"));
+ $this->assertTrue($parser->parse("</group>\n"));
+ $this->assertTrue($parser->parse("</group>\n"));
+ $parser->parse("</run>\n");
+ }
+}
+
+class AnyOldSignal {
+ var $stuff = true;
+}
+
+class TestOfXmlResultsParsing extends UnitTestCase {
+
+ function sendValidStart(&$parser) {
+ $parser->parse("<?xml version=\"1.0\"?>\n");
+ $parser->parse("<run>\n");
+ $parser->parse("<case>\n");
+ $parser->parse("<name>a_case</name>\n");
+ $parser->parse("<test>\n");
+ $parser->parse("<name>a_method</name>\n");
+ }
+
+ function sendValidEnd(&$parser) {
+ $parser->parse("</test>\n");
+ $parser->parse("</case>\n");
+ $parser->parse("</run>\n");
+ }
+
+ function testPass() {
+ $listener = &new MockSimpleScorer();
+ $listener->expectOnce('paintPass', array('a_message'));
+ $parser = &new SimpleTestXmlParser($listener);
+ $this->sendValidStart($parser);
+ $this->assertTrue($parser->parse("<pass>a_message</pass>\n"));
+ $this->sendValidEnd($parser);
+ }
+
+ function testFail() {
+ $listener = &new MockSimpleScorer();
+ $listener->expectOnce('paintFail', array('a_message'));
+ $parser = &new SimpleTestXmlParser($listener);
+ $this->sendValidStart($parser);
+ $this->assertTrue($parser->parse("<fail>a_message</fail>\n"));
+ $this->sendValidEnd($parser);
+ }
+
+ function testException() {
+ $listener = &new MockSimpleScorer();
+ $listener->expectOnce('paintError', array('a_message'));
+ $parser = &new SimpleTestXmlParser($listener);
+ $this->sendValidStart($parser);
+ $this->assertTrue($parser->parse("<exception>a_message</exception>\n"));
+ $this->sendValidEnd($parser);
+ }
+
+ function testSkip() {
+ $listener = &new MockSimpleScorer();
+ $listener->expectOnce('paintSkip', array('a_message'));
+ $parser = &new SimpleTestXmlParser($listener);
+ $this->sendValidStart($parser);
+ $this->assertTrue($parser->parse("<skip>a_message</skip>\n"));
+ $this->sendValidEnd($parser);
+ }
+
+ function testSignal() {
+ $signal = new AnyOldSignal();
+ $signal->stuff = "Hello";
+ $listener = &new MockSimpleScorer();
+ $listener->expectOnce('paintSignal', array('a_signal', $signal));
+ $parser = &new SimpleTestXmlParser($listener);
+ $this->sendValidStart($parser);
+ $this->assertTrue($parser->parse(
+ "<signal type=\"a_signal\"><![CDATA[" .
+ serialize($signal) . "]]></signal>\n"));
+ $this->sendValidEnd($parser);
+ }
+
+ function testMessage() {
+ $listener = &new MockSimpleScorer();
+ $listener->expectOnce('paintMessage', array('a_message'));
+ $parser = &new SimpleTestXmlParser($listener);
+ $this->sendValidStart($parser);
+ $this->assertTrue($parser->parse("<message>a_message</message>\n"));
+ $this->sendValidEnd($parser);
+ }
+
+ function testFormattedMessage() {
+ $listener = &new MockSimpleScorer();
+ $listener->expectOnce('paintFormattedMessage', array("\na\tmessage\n"));
+ $parser = &new SimpleTestXmlParser($listener);
+ $this->sendValidStart($parser);
+ $this->assertTrue($parser->parse("<formatted><![CDATA[\na\tmessage\n]]></formatted>\n"));
+ $this->sendValidEnd($parser);
+ }
+}
+?> \ No newline at end of file