Viewing file:  AssertTest.php (46.96 KB) -rwxrwxr-x
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
<?php
/**
* PHPUnit
*
* Copyright (c) 2002-2008, Sebastian Bergmann <sb@sebastian-bergmann.de>.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* * Neither the name of Sebastian Bergmann nor the names of his
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* @category Testing
* @package PHPUnit
* @author Sebastian Bergmann <sb@sebastian-bergmann.de>
* @copyright 2002-2008 Sebastian Bergmann <sb@sebastian-bergmann.de>
* @license http://www.opensource.org/licenses/bsd-license.php BSD License
* @version SVN: $Id: AssertTest.php 2129 2008-01-16 11:08:24Z sb $
* @link http://www.phpunit.de/
* @since File available since Release 2.0.0
*/
require_once 'PHPUnit/Framework/TestCase.php';
require_once '_files/ClassWithNonPublicAttributes.php';
require_once '_files/SampleClass.php';
require_once '_files/Struct.php';
require_once '_files/TestIterator.php';
require_once '_files/WasRun.php';
/**
*
*
* @category Testing
* @package PHPUnit
* @author Sebastian Bergmann <sb@sebastian-bergmann.de>
* @copyright 2002-2008 Sebastian Bergmann <sb@sebastian-bergmann.de>
* @license http://www.opensource.org/licenses/bsd-license.php BSD License
* @version Release: 3.2.9
* @link http://www.phpunit.de/
* @since Class available since Release 2.0.0
*/
class Framework_AssertTest extends PHPUnit_Framework_TestCase {
public function testFail() {
try {
$this->fail();
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertArrayContainsObject() {
$a = new stdClass();
$b = new stdClass();
$this->assertContains($a, array($a));
try {
$this->assertContains($a, array($b));
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertArrayContainsString() {
$this->assertContains('foo', array('foo'));
try {
$this->assertContains('foo', array('bar'));
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertArrayHasIntegerKey() {
$this->assertArrayHasKey(0, array('foo'));
try {
$this->assertArrayHasKey(1, array('foo'));
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertArrayNotHasIntegerKey() {
$this->assertArrayNotHasKey(1, array('foo'));
try {
$this->assertArrayNotHasKey(0, array('foo'));
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertArrayHasStringKey() {
$this->assertArrayHasKey('foo', array('foo' => 'bar'));
try {
$this->assertArrayHasKey('bar', array('foo' => 'bar'));
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertArrayNotHasStringKey() {
$this->assertArrayNotHasKey('bar', array('foo' => 'bar'));
try {
$this->assertArrayNotHasKey('foo', array('foo' => 'bar'));
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertIteratorContainsObject() {
$foo = new stdClass();
$this->assertContains($foo, new TestIterator(array($foo)));
try {
$this->assertContains($foo, new TestIterator(array(new stdClass())));
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertIteratorContainsString() {
$this->assertContains('foo', new TestIterator(array('foo')));
try {
$this->assertContains('foo', new TestIterator(array('bar')));
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertStringContainsString() {
$this->assertContains('foo', 'foobar');
try {
$this->assertContains('foo', 'bar');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertArrayNotContainsObject() {
$a = new stdClass();
$b = new stdClass();
$this->assertNotContains($a, array($b));
try {
$this->assertNotContains($a, array($a));
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertArrayNotContainsString() {
$this->assertNotContains('foo', array('bar'));
try {
$this->assertNotContains('foo', array('foo'));
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertStringNotContainsString() {
$this->assertNotContains('foo', 'bar');
try {
$this->assertNotContains('foo', 'foo');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertArrayContainsOnlyIntegers() {
$this->assertContainsOnly('integer', array(1, 2, 3));
try {
$this->assertContainsOnly('integer', array("1", 2, 3));
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertArrayNotContainsOnlyIntegers() {
$this->assertNotContainsOnly('integer', array("1", 2, 3));
try {
$this->assertNotContainsOnly('integer', array(1, 2, 3));
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertArrayContainsOnlyStdClass() {
$this->assertContainsOnly('StdClass', array(new StdClass()));
try {
$this->assertContainsOnly('StdClass', array('StdClass'));
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertArrayNotContainsOnlyStdClass() {
$this->assertNotContainsOnly('StdClass', array('StdClass'));
try {
$this->assertNotContainsOnly('StdClass', array(new StdClass()));
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsArray() {
$this->assertEquals(array('a', 'b' => array(1, 2)), array('a', 'b' => array(1, 2)));
try {
$this->assertEquals(array('a', 'b' => array(1, 2)), array('a', 'b' => array(2, 1)));
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotEqualsArray() {
$this->assertNotEquals(array('a', 'b' => array(1, 2)), array('a', 'b' => array(2, 1)));
try {
$this->assertNotEquals(array('a', 'b' => array(1, 2)), array('a', 'b' => array(1, 2)));
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsFloat() {
$this->assertEquals(2.3, 2.3);
try {
$this->assertEquals(2.3, 4.2);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotEqualsFloat() {
$this->assertNotEquals(2.3, 4.2);
try {
$this->assertNotEquals(2.3, 2.3);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsFloatDelta() {
$this->assertEquals(2.3, 2.5, '', 0.5);
try {
$this->assertEquals(2.3, 4.2, '', 0.5);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotEqualsFloatDelta() {
$this->assertNotEquals(2.3, 4.2, '', 0.5);
try {
$this->assertNotEquals(2.3, 2.5, '', 0.5);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsArrayFloatDelta() {
$this->assertEquals(array(2.3), array(2.5), '', 0.5);
try {
$this->assertEquals(array(2.3), array(4.2), '', 0.5);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotEqualsArrayFloatDelta() {
$this->assertNotEquals(array(2.3), array(4.2), '', 0.5);
try {
$this->assertNotEquals(array(2.3), array(2.5), '', 0.5);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsStructFloatDelta() {
$this->assertEquals(new Struct(2.3), new Struct(2.5), '', 0.5);
try {
$this->assertEquals(new Struct(2.3), new Struct(4.2), '', 0.5);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotEqualsStructFloatDelta() {
$this->assertNotEquals(new Struct(2.3), new Struct(4.2), '', 0.5);
try {
$this->assertNotEquals(new Struct(2.3), new Struct(2.5), '', 0.5);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsArrayStructFloatDelta() {
$this->assertEquals(array(new Struct(2.3)), array(new Struct(2.5)), '', 0.5);
try {
$this->assertEquals(array(new Struct(2.3)), array(new Struct(4.2)), '', 0.5);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotEqualsArrayStructFloatDelta() {
$this->assertNotEquals(array(new Struct(2.3)), array(new Struct(4.2)), '', 0.5);
try {
$this->assertNotEquals(array(new Struct(2.3)), array(new Struct(2.5)), '', 0.5);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsArrayOfArrayFloatDelta() {
$this->assertEquals(array(array(2.3)), array(array(2.5)), '', 0.5);
try {
$this->assertEquals(array(array(2.3)), array(array(4.2)), '', 0.5);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotEqualsArrayOfArrayFloatDelta() {
$this->assertNotEquals(array(array(2.3)), array(array(4.2)), '', 0.5);
try {
$this->assertNotEquals(array(array(2.3)), array(array(2.5)), '', 0.5);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsInteger() {
$this->assertEquals(23, 23);
try {
$this->assertEquals(23, 42);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotEqualsInteger() {
$this->assertNotEquals(23, 42);
try {
$this->assertNotEquals(23, 23);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsObject() {
$a = new SampleClass(4, 8, 15);
$b = new SampleClass(16, 23, 42);
$this->assertEquals($a, $a);
try {
$this->assertEquals($a, $b);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotEqualsObject() {
$a = new SampleClass(4, 8, 15);
$b = new SampleClass(16, 23, 42);
$this->assertNotEquals($a, $b);
try {
$this->assertNotEquals($a, $a);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsString() {
$this->assertEquals('ab', 'ab');
try {
$this->assertEquals('ab', 'ba');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotEqualsString() {
$this->assertNotEquals('ab', 'ba');
try {
$this->assertNotEquals('ab', 'ab');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertXmlFileEqualsXmlFile() {
$this->assertXmlFileEqualsXmlFile(dirname(dirname(__FILE__)) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'foo.xml', dirname(dirname(__FILE__)) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'foo.xml');
try {
$this->assertXmlFileEqualsXmlFile(dirname(dirname(__FILE__)) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'foo.xml', dirname(dirname(__FILE__)) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'bar.xml');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertXmlFileNotEqualsXmlFile() {
$this->assertXmlFileNotEqualsXmlFile(dirname(dirname(__FILE__)) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'foo.xml', dirname(dirname(__FILE__)) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'bar.xml');
try {
$this->assertXmlFileNotEqualsXmlFile(dirname(dirname(__FILE__)) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'foo.xml', dirname(dirname(__FILE__)) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'foo.xml');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertXmlStringEqualsXmlString() {
$this->assertXmlStringEqualsXmlString('<root/>', '<root/>');
try {
$this->assertXmlStringEqualsXmlString('<foo/>', '<bar/>');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertXmlStringNotEqualsXmlString() {
$this->assertXmlStringNotEqualsXmlString('<foo/>', '<bar/>');
try {
$this->assertXmlStringNotEqualsXmlString('<root/>', '<root/>');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsDOMDocument() {
$expected = new DOMDocument();
$expected->loadXML('<root></root>');
$actual = new DOMDocument();
$actual->loadXML('<root/>');
$this->assertEquals($expected, $actual);
try {
$this->assertNotEquals($expected, $actual);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsDOMDocument2() {
$expected = new DOMDocument();
$expected->loadXML('<foo></foo>');
$actual = new DOMDocument();
$actual->loadXML('<bar/>');
$this->assertNotEquals($expected, $actual);
try {
$this->assertEquals($expected, $actual);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsDOMDocument3() {
$expected = new DOMDocument();
$expected->loadXML('<foo attr="bar"></foo>');
$actual = new DOMDocument();
$actual->loadXML('<foo attr="bar"/>');
$this->assertEquals($expected, $actual);
try {
$this->assertNotEquals($expected, $actual);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsDOMDocument4() {
$expected = new DOMDocument();
$expected->loadXML('<root><foo attr="bar"></foo></root>');
$actual = new DOMDocument();
$actual->loadXML('<root><foo attr="bar"/></root>');
$this->assertEquals($expected, $actual);
try {
$this->assertNotEquals($expected, $actual);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsDOMDocument5() {
$expected = new DOMDocument();
$expected->loadXML('<foo attr1="bar"/>');
$actual = new DOMDocument();
$actual->loadXML('<foo attr1="foobar"/>');
$this->assertNotEquals($expected, $actual);
try {
$this->assertEquals($expected, $actual);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsDOMDocument6() {
$expected = new DOMDocument();
$expected->loadXML('<foo> bar </foo>');
$actual = new DOMDocument();
$actual->loadXML('<foo />');
$this->assertNotEquals($expected, $actual);
try {
$this->assertEquals($expected, $actual);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsDOMDocument7() {
$expected = new DOMDocument();
$expected->loadXML('<foo xmlns="urn:myns:bar"/>');
$actual = new DOMDocument();
$actual->loadXML('<foo xmlns="urn:notmyns:bar"/>');
$this->assertNotEquals($expected, $actual);
try {
$this->assertEquals($expected, $actual);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsDOMDocument8() {
$expected = new DOMDocument();
$expected->loadXML("<root>\n <child/>\n</root>");
$actual = new DOMDocument();
$actual->loadXML('<root><child/></root>');
$this->assertEquals($expected, $actual);
try {
$this->assertNotEquals($expected, $actual);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertEqualsDOMDocument9() {
$expected = new DOMDocument();
$expected->loadXML('<foo> bar </foo>');
$actual = new DOMDocument();
$actual->loadXML('<foo> bir </foo>');
$this->assertNotEquals($expected, $actual);
try {
$this->assertEquals($expected, $actual);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertStringEqualsNumeric() {
$this->assertEquals('0', 0);
try {
$this->assertEquals('0', 1);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertStringEqualsNumeric2() {
$this->assertNotEquals('A', 0);
}
public function testAssertFileExists() {
$this->assertFileExists(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'AllTests.php');
try {
$this->assertFileExists(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'NotExisting');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertFileNotExists() {
$this->assertFileNotExists(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'NotExisting');
try {
$this->assertFileNotExists(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'AllTests.php');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertObjectHasAttribute() {
$o = new WasRun('runTest');
$this->assertObjectHasAttribute('wasRun', $o);
try {
$this->assertObjectHasAttribute('foo', $o);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertObjectNotHasAttribute() {
$o = new WasRun('runTest');
$this->assertObjectNotHasAttribute('foo', $o);
try {
$this->assertObjectNotHasAttribute('wasRun', $o);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNull() {
$this->assertNull(NULL);
try {
$this->assertNull(new stdClass());
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotNull() {
$this->assertNotNull(new stdClass());
try {
$this->assertNotNull(NULL);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertTrue() {
$this->assertTrue(TRUE);
try {
$this->assertTrue(FALSE);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertFalse() {
$this->assertFalse(FALSE);
try {
$this->assertFalse(TRUE);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertRegExp() {
$this->assertRegExp('/foo/', 'foobar');
try {
$this->assertRegExp('/foo/', 'bar');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotRegExp() {
$this->assertNotRegExp('/foo/', 'bar');
try {
$this->assertNotRegExp('/foo/', 'foobar');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertSame() {
$o = new stdClass();
$this->assertSame($o, $o);
try {
$this->assertSame(new stdClass(), new stdClass());
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertSame2() {
$this->assertSame(TRUE, TRUE);
$this->assertSame(FALSE, FALSE);
try {
$this->assertSame(TRUE, FALSE);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotSame() {
$this->assertNotSame(new stdClass(), NULL);
$this->assertNotSame(NULL, new stdClass());
$this->assertNotSame(new stdClass(), new stdClass());
$o = new stdClass();
try {
$this->assertNotSame($o, $o);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotSame2() {
$this->assertNotSame(TRUE, FALSE);
$this->assertNotSame(FALSE, TRUE);
try {
$this->assertNotSame(TRUE, TRUE);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotSameFailsNull() {
try {
$this->assertNotSame(NULL, NULL);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertTypeArray() {
$this->assertType('array', array());
try {
$this->assertType('array', 'string');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotTypeArray() {
$this->assertNotType('array', 'string');
try {
$this->assertNotType('array', array());
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertTypeBool() {
$this->assertType('bool', TRUE);
try {
$this->assertType('bool', 'string');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotTypeBool() {
$this->assertNotType('bool', 'string');
try {
$this->assertNotType('bool', TRUE);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertTypeClass() {
$this->assertType('stdClass', new stdClass());
try {
$this->assertType('stdClass', new Exception());
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotTypeClass() {
$this->assertNotType('stdClass', new Exception());
try {
$this->assertNotType('stdClass', new stdClass());
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertTypeFloat() {
$this->assertType('float', 22.04);
try {
$this->assertType('integer', 'string');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotTypeFloat() {
$this->assertNotType('float', 'string');
try {
$this->assertNotType('float', 22.04);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertTypeInteger() {
$this->assertType('integer', 2204);
try {
$this->assertType('integer', 'string');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotTypeInteger() {
$this->assertNotType('integer', 'string');
try {
$this->assertNotType('integer', 2204);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertTypeNull() {
$this->assertType('null', NULL);
try {
$this->assertType('null', 'string');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotTypeNull() {
$this->assertNotType('null', 'string');
try {
$this->assertNotType('null', NULL);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertTypeObject() {
$this->assertType('object', new stdClass());
try {
$this->assertType('object', 'string');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotTypeObject() {
$this->assertNotType('object', 'string');
try {
$this->assertNotType('object', new stdClass());
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertTypeString() {
$this->assertType('string', 'string');
try {
$this->assertType('string', 2204);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertNotTypeString() {
$this->assertNotType('string', 2204);
try {
$this->assertNotType('string', 'string');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testGreaterThan() {
$this->assertGreaterThan(1, 2);
try {
$this->assertGreaterThan(2, 1);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAttributeGreaterThan() {
$this->assertAttributeGreaterThan(1, 'bar', new ClassWithNonPublicAttributes());
try {
$this->assertAttributeGreaterThan(1, 'foo', new ClassWithNonPublicAttributes());
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testGreaterThanOrEqual() {
$this->assertGreaterThanOrEqual(1, 2);
try {
$this->assertGreaterThanOrEqual(2, 1);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAttributeGreaterThanOrEqual() {
$this->assertAttributeGreaterThanOrEqual(1, 'bar', new ClassWithNonPublicAttributes());
try {
$this->assertAttributeGreaterThanOrEqual(2, 'foo', new ClassWithNonPublicAttributes());
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testLessThan() {
$this->assertLessThan(2, 1);
try {
$this->assertLessThan(1, 2);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAttributeLessThan() {
$this->assertAttributeLessThan(2, 'foo', new ClassWithNonPublicAttributes());
try {
$this->assertAttributeLessThan(1, 'bar', new ClassWithNonPublicAttributes());
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testLessThanOrEqual() {
$this->assertLessThanOrEqual(2, 1);
try {
$this->assertLessThanOrEqual(1, 2);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAttributeLessThanOrEqual() {
$this->assertAttributeLessThanOrEqual(2, 'foo', new ClassWithNonPublicAttributes());
try {
$this->assertAttributeLessThanOrEqual(1, 'bar', new ClassWithNonPublicAttributes());
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testGetObjectAttribute() {
$obj = new ClassWithNonPublicAttributes();
$this->assertEquals('foo', $this->readAttribute($obj, 'publicAttribute'));
$this->assertEquals('bar', $this->readAttribute($obj, 'protectedAttribute'));
$this->assertEquals('baz', $this->readAttribute($obj, 'privateAttribute'));
$this->assertEquals('parent', $this->readAttribute($obj, 'privateParentAttribute'));
}
public function testGetStaticAttribute() {
$this->assertEquals('foo', $this->readAttribute('ClassWithNonPublicAttributes', 'publicStaticAttribute'));
$this->assertEquals('bar', $this->readAttribute('ClassWithNonPublicAttributes', 'protectedStaticAttribute'));
$this->assertEquals('baz', $this->readAttribute('ClassWithNonPublicAttributes', 'privateStaticAttribute'));
$this->assertEquals('parent', $this->readAttribute('ClassWithNonPublicAttributes', 'privateStaticParentAttribute'));
}
public function testAssertPublicAttributeContains() {
$obj = new ClassWithNonPublicAttributes();
$this->assertAttributeContains('foo', 'publicArray', $obj);
try {
$this->assertAttributeContains('bar', 'publicArray', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertPublicAttributeContainsOnly() {
$obj = new ClassWithNonPublicAttributes();
$this->assertAttributeContainsOnly('string', 'publicArray', $obj);
try {
$this->assertAttributeContainsOnly('integer', 'publicArray', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertPublicAttributeNotContains() {
$obj = new ClassWithNonPublicAttributes();
$this->assertAttributeNotContains('bar', 'publicArray', $obj);
try {
$this->assertAttributeNotContains('foo', 'publicArray', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertPublicAttributeNotContainsOnly() {
$obj = new ClassWithNonPublicAttributes();
$this->assertAttributeNotContainsOnly('integer', 'publicArray', $obj);
try {
$this->assertAttributeNotContainsOnly('string', 'publicArray', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertProtectedAttributeContains() {
$obj = new ClassWithNonPublicAttributes();
$this->assertAttributeContains('bar', 'protectedArray', $obj);
try {
$this->assertAttributeContains('foo', 'protectedArray', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertProtectedAttributeNotContains() {
$obj = new ClassWithNonPublicAttributes();
$this->assertAttributeNotContains('foo', 'protectedArray', $obj);
try {
$this->assertAttributeNotContains('bar', 'protectedArray', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertPrivateAttributeContains() {
$obj = new ClassWithNonPublicAttributes();
$this->assertAttributeContains('baz', 'privateArray', $obj);
try {
$this->assertAttributeContains('foo', 'privateArray', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertPrivateAttributeNotContains() {
$obj = new ClassWithNonPublicAttributes();
$this->assertAttributeNotContains('foo', 'privateArray', $obj);
try {
$this->assertAttributeNotContains('baz', 'privateArray', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertPublicAttributeEquals() {
$obj = new ClassWithNonPublicAttributes();
$this->assertAttributeEquals('foo', 'publicAttribute', $obj);
try {
$this->assertAttributeEquals('bar', 'publicAttribute', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertPublicAttributeNotEquals() {
$obj = new ClassWithNonPublicAttributes();
$this->assertAttributeNotEquals('bar', 'publicAttribute', $obj);
try {
$this->assertAttributeNotEquals('foo', 'publicAttribute', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertPublicAttributeSame() {
$obj = new ClassWithNonPublicAttributes();
$this->assertAttributeSame('foo', 'publicAttribute', $obj);
try {
$this->assertAttributeSame('bar', 'publicAttribute', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertPublicAttributeNotSame() {
$obj = new ClassWithNonPublicAttributes();
$this->assertAttributeNotSame('bar', 'publicAttribute', $obj);
try {
$this->assertAttributeNotSame('foo', 'publicAttribute', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertProtectedAttributeEquals() {
$obj = new ClassWithNonPublicAttributes();
$this->assertAttributeEquals('bar', 'protectedAttribute', $obj);
try {
$this->assertAttributeEquals('foo', 'protectedAttribute', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertProtectedAttributeNotEquals() {
$obj = new ClassWithNonPublicAttributes();
$this->assertAttributeNotEquals('foo', 'protectedAttribute', $obj);
try {
$this->assertAttributeNotEquals('bar', 'protectedAttribute', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertPrivateAttributeEquals() {
$obj = new ClassWithNonPublicAttributes();
$this->assertAttributeEquals('baz', 'privateAttribute', $obj);
try {
$this->assertAttributeEquals('foo', 'privateAttribute', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertPrivateAttributeNotEquals() {
$obj = new ClassWithNonPublicAttributes();
$this->assertAttributeNotEquals('foo', 'privateAttribute', $obj);
try {
$this->assertAttributeNotEquals('baz', 'privateAttribute', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertPublicStaticAttributeEquals() {
$this->assertAttributeEquals('foo', 'publicStaticAttribute', 'ClassWithNonPublicAttributes');
try {
$this->assertAttributeEquals('bar', 'publicStaticAttribute', 'ClassWithNonPublicAttributes');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertPublicStaticAttributeNotEquals() {
$this->assertAttributeNotEquals('bar', 'publicStaticAttribute', 'ClassWithNonPublicAttributes');
try {
$this->assertAttributeNotEquals('foo', 'publicStaticAttribute', 'ClassWithNonPublicAttributes');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertProtectedStaticAttributeEquals() {
$this->assertAttributeEquals('bar', 'protectedStaticAttribute', 'ClassWithNonPublicAttributes');
try {
$this->assertAttributeEquals('foo', 'protectedStaticAttribute', 'ClassWithNonPublicAttributes');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertProtectedStaticAttributeNotEquals() {
$this->assertAttributeNotEquals('foo', 'protectedStaticAttribute', 'ClassWithNonPublicAttributes');
try {
$this->assertAttributeNotEquals('bar', 'protectedStaticAttribute', 'ClassWithNonPublicAttributes');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertPrivateStaticAttributeEquals() {
$this->assertAttributeEquals('baz', 'privateStaticAttribute', 'ClassWithNonPublicAttributes');
try {
$this->assertAttributeEquals('foo', 'privateStaticAttribute', 'ClassWithNonPublicAttributes');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertPrivateStaticAttributeNotEquals() {
$this->assertAttributeNotEquals('foo', 'privateStaticAttribute', 'ClassWithNonPublicAttributes');
try {
$this->assertAttributeNotEquals('baz', 'privateStaticAttribute', 'ClassWithNonPublicAttributes');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testClassHasPublicAttribute() {
$this->assertClassHasAttribute('publicAttribute', 'ClassWithNonPublicAttributes');
try {
$this->assertClassHasAttribute('attribute', 'ClassWithNonPublicAttributes');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testClassNotHasPublicAttribute() {
$this->assertClassNotHasAttribute('attribute', 'ClassWithNonPublicAttributes');
try {
$this->assertClassNotHasAttribute('publicAttribute', 'ClassWithNonPublicAttributes');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testClassHasPublicStaticAttribute() {
$this->assertClassHasStaticAttribute('publicStaticAttribute', 'ClassWithNonPublicAttributes');
try {
$this->assertClassHasStaticAttribute('attribute', 'ClassWithNonPublicAttributes');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testClassNotHasPublicStaticAttribute() {
$this->assertClassNotHasStaticAttribute('attribute', 'ClassWithNonPublicAttributes');
try {
$this->assertClassNotHasStaticAttribute('publicStaticAttribute', 'ClassWithNonPublicAttributes');
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testObjectHasPublicAttribute() {
$obj = new ClassWithNonPublicAttributes();
$this->assertObjectHasAttribute('publicAttribute', $obj);
try {
$this->assertObjectHasAttribute('attribute', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testObjectNotHasPublicAttribute() {
$obj = new ClassWithNonPublicAttributes();
$this->assertObjectNotHasAttribute('attribute', $obj);
try {
$this->assertObjectNotHasAttribute('publicAttribute', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testObjectHasOnTheFlyAttribute() {
$obj = new StdClass();
$obj->foo = 'bar';
$this->assertObjectHasAttribute('foo', $obj);
try {
$this->assertObjectHasAttribute('bar', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testObjectNotHasOnTheFlyAttribute() {
$obj = new StdClass();
$obj->foo = 'bar';
$this->assertObjectNotHasAttribute('bar', $obj);
try {
$this->assertObjectNotHasAttribute('foo', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testObjectHasProtectedAttribute() {
$obj = new ClassWithNonPublicAttributes();
$this->assertObjectHasAttribute('protectedAttribute', $obj);
try {
$this->assertObjectHasAttribute('attribute', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testObjectNotHasProtectedAttribute() {
$obj = new ClassWithNonPublicAttributes();
$this->assertObjectNotHasAttribute('attribute', $obj);
try {
$this->assertObjectNotHasAttribute('protectedAttribute', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testObjectHasPrivateAttribute() {
$obj = new ClassWithNonPublicAttributes();
$this->assertObjectHasAttribute('privateAttribute', $obj);
try {
$this->assertObjectHasAttribute('attribute', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testObjectNotHasPrivateAttribute() {
$obj = new ClassWithNonPublicAttributes();
$this->assertObjectNotHasAttribute('attribute', $obj);
try {
$this->assertObjectNotHasAttribute('privateAttribute', $obj);
}
catch (PHPUnit_Framework_AssertionFailedError $e) {
return;
}
$this->fail();
}
public function testAssertThatAttributeEquals() {
$this->assertThat(new ClassWithNonPublicAttributes(), $this->attribute($this->equalTo('foo'), 'publicAttribute'));
}
public function testAssertThatAttributeEqualTo() {
$this->assertThat(new ClassWithNonPublicAttributes(), $this->attributeEqualTo('publicAttribute', 'foo'));
}
public function testAssertThatAnything() {
$this->assertThat('anything', $this->anything());
}
public function testAssertThatAnythingAndAnything() {
$this->assertThat('anything', $this->logicalAnd($this->anything(), $this->anything()));
}
public function testAssertThatAnythingOrAnything() {
$this->assertThat('anything', $this->logicalOr($this->anything(), $this->anything()));
}
public function testAssertThatAnythingXorNotAnything() {
$this->assertThat('anything', $this->logicalXor($this->anything(), $this->logicalNot($this->anything())));
}
public function testAssertThatContains() {
$this->assertThat(array('foo'), $this->contains('foo'));
}
public function testAssertThatStringContains() {
$this->assertThat('barfoobar', $this->stringContains('foo'));
}
public function testAssertThatContainsOnly() {
$this->assertThat(array('foo'), $this->containsOnly('string'));
}
public function testAssertThatArrayHasKey() {
$this->assertThat(array('foo' => 'bar'), $this->arrayHasKey('foo'));
}
public function testAssertThatClassHasAttribute() {
$this->assertThat(new ClassWithNonPublicAttributes(), $this->classHasAttribute('publicAttribute'));
}
public function testAssertThatClassHasStaticAttribute() {
$this->assertThat(new ClassWithNonPublicAttributes(), $this->classHasStaticAttribute('publicStaticAttribute'));
}
public function testAssertThatObjectHasAttribute() {
$this->assertThat(new ClassWithNonPublicAttributes(), $this->objectHasAttribute('publicAttribute'));
}
public function testAssertThatEqualTo() {
$this->assertThat('foo', $this->equalTo('foo'));
}
public function testAssertThatIdenticalTo() {
$value = new StdClass();
$constraint = $this->identicalTo($value);
$this->assertThat($value, $constraint);
}
public function testAssertThatIsInstanceOf() {
$this->assertThat(new StdClass(), $this->isInstanceOf('StdClass'));
}
public function testAssertThatIsType() {
$this->assertThat('string', $this->isType('string'));
}
public function testAssertThatFileExists() {
$this->assertThat(dirname(__FILE__) . DIRECTORY_SEPARATOR . 'AllTests.php', $this->fileExists());
}
public function testAssertThatGreaterThan() {
$this->assertThat(2, $this->greaterThan(1));
}
public function testAssertThatGreaterThanOrEqual() {
$this->assertThat(2, $this->greaterThanOrEqual(1));
}
public function testAssertThatLessThan() {
$this->assertThat(1, $this->lessThan(2));
}
public function testAssertThatLessThanOrEqual() {
$this->assertThat(1, $this->lessThanOrEqual(2));
}
public function testAssertThatMatchesRegularExpression() {
$this->assertThat('foobar', $this->matchesRegularExpression('/foo/'));
}
/**
* @expectedException PHPUnit_Framework_IncompleteTestError incomplete 0
*/
public function testMarkTestIncomplete() {
$this->markTestIncomplete('incomplete');
}
/**
* @expectedException PHPUnit_Framework_SkippedTestError
*/
public function testMarkTestSkipped() {
$this->markTestSkipped();
}
}
?>
|