mbk-lab
/
nextcloud
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

drop SimpleTest compatibility

This commit is contained in:
Thomas Mueller 2013-01-24 16:47:17 +01:00
parent 1dac2ba496
commit ef88ceba8c
23 changed files with 196 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
apps/files_encryption/test/crypt.php
View File

@ -609,42 +609,42 @@ class Test_Crypt extends \PHPUnit_Framework_TestCase {
// $decrypted=OC_Encryption\Crypt::decrypt($encrypted,$key); // $decrypted=OC_Encryption\Crypt::decrypt($encrypted,$key);
// $decrypted=rtrim($decrypted, "\0"); // $decrypted=rtrim($decrypted, "\0");
// $this->assertNotEquals($encrypted,$source); // $this->assertNotEquals($encrypted,$source);
// $this->assertEqual($decrypted,$source); // $this->assertEquals($decrypted,$source);
// //
// $chunk=substr($source,0,8192); // $chunk=substr($source,0,8192);
// $encrypted=OC_Encryption\Crypt::encrypt($chunk,$key); // $encrypted=OC_Encryption\Crypt::encrypt($chunk,$key);
// $this->assertEqual(strlen($chunk),strlen($encrypted)); // $this->assertEquals(strlen($chunk),strlen($encrypted));
// $decrypted=OC_Encryption\Crypt::decrypt($encrypted,$key); // $decrypted=OC_Encryption\Crypt::decrypt($encrypted,$key);
// $decrypted=rtrim($decrypted, "\0"); // $decrypted=rtrim($decrypted, "\0");
// $this->assertEqual($decrypted,$chunk); // $this->assertEquals($decrypted,$chunk);
// //
// $encrypted=OC_Encryption\Crypt::blockEncrypt($source,$key); // $encrypted=OC_Encryption\Crypt::blockEncrypt($source,$key);
// $decrypted=OC_Encryption\Crypt::blockDecrypt($encrypted,$key); // $decrypted=OC_Encryption\Crypt::blockDecrypt($encrypted,$key);
// $this->assertNotEquals($encrypted,$source); // $this->assertNotEquals($encrypted,$source);
// $this->assertEqual($decrypted,$source); // $this->assertEquals($decrypted,$source);
// //
// $tmpFileEncrypted=OCP\Files::tmpFile(); // $tmpFileEncrypted=OCP\Files::tmpFile();
// OC_Encryption\Crypt::encryptfile($file,$tmpFileEncrypted,$key); // OC_Encryption\Crypt::encryptfile($file,$tmpFileEncrypted,$key);
// $encrypted=file_get_contents($tmpFileEncrypted); // $encrypted=file_get_contents($tmpFileEncrypted);
// $decrypted=OC_Encryption\Crypt::blockDecrypt($encrypted,$key); // $decrypted=OC_Encryption\Crypt::blockDecrypt($encrypted,$key);
// $this->assertNotEquals($encrypted,$source); // $this->assertNotEquals($encrypted,$source);
// $this->assertEqual($decrypted,$source); // $this->assertEquals($decrypted,$source);
// //
// $tmpFileDecrypted=OCP\Files::tmpFile(); // $tmpFileDecrypted=OCP\Files::tmpFile();
// OC_Encryption\Crypt::decryptfile($tmpFileEncrypted,$tmpFileDecrypted,$key); // OC_Encryption\Crypt::decryptfile($tmpFileEncrypted,$tmpFileDecrypted,$key);
// $decrypted=file_get_contents($tmpFileDecrypted); // $decrypted=file_get_contents($tmpFileDecrypted);
// $this->assertEqual($decrypted,$source); // $this->assertEquals($decrypted,$source);
// //
// $file=OC::$SERVERROOT.'/core/img/weather-clear.png'; // $file=OC::$SERVERROOT.'/core/img/weather-clear.png';
// $source=file_get_contents($file); //binary file // $source=file_get_contents($file); //binary file
// $encrypted=OC_Encryption\Crypt::encrypt($source,$key); // $encrypted=OC_Encryption\Crypt::encrypt($source,$key);
// $decrypted=OC_Encryption\Crypt::decrypt($encrypted,$key); // $decrypted=OC_Encryption\Crypt::decrypt($encrypted,$key);
// $decrypted=rtrim($decrypted, "\0"); // $decrypted=rtrim($decrypted, "\0");
// $this->assertEqual($decrypted,$source); // $this->assertEquals($decrypted,$source);
// //
// $encrypted=OC_Encryption\Crypt::blockEncrypt($source,$key); // $encrypted=OC_Encryption\Crypt::blockEncrypt($source,$key);
// $decrypted=OC_Encryption\Crypt::blockDecrypt($encrypted,$key); // $decrypted=OC_Encryption\Crypt::blockDecrypt($encrypted,$key);
// $this->assertEqual($decrypted,$source); // $this->assertEquals($decrypted,$source);
// //
// } // }
// //
@ -657,11 +657,11 @@ class Test_Crypt extends \PHPUnit_Framework_TestCase {
// $decrypted=OC_Encryption\Crypt::decrypt($encrypted,$key); // $decrypted=OC_Encryption\Crypt::decrypt($encrypted,$key);
// //
// $decrypted=rtrim($decrypted, "\0"); // $decrypted=rtrim($decrypted, "\0");
// $this->assertEqual($decrypted,$source); // $this->assertEquals($decrypted,$source);
// //
// $encrypted=OC_Encryption\Crypt::blockEncrypt($source,$key); // $encrypted=OC_Encryption\Crypt::blockEncrypt($source,$key);
// $decrypted=OC_Encryption\Crypt::blockDecrypt($encrypted,$key,strlen($source)); // $decrypted=OC_Encryption\Crypt::blockDecrypt($encrypted,$key,strlen($source));
// $this->assertEqual($decrypted,$source); // $this->assertEquals($decrypted,$source);
// } // }
} }

24
apps/files_encryption/test/proxy.php
View File

@ -109,7 +109,7 @@
// //
// } // }
// class Test_CryptProxy extends UnitTestCase { // class Test_CryptProxy extends PHPUnit_Framework_TestCase {
// private $oldConfig; // private $oldConfig;
// private $oldKey; // private $oldKey;
// //
@ -161,9 +161,9 @@
// OC_FileProxy::$enabled=true; // OC_FileProxy::$enabled=true;
// //
// $fromFile=OC_Filesystem::file_get_contents('/file'); // $fromFile=OC_Filesystem::file_get_contents('/file');
// $this->assertNotEqual($original,$stored); // $this->assertNotEquals($original,$stored);
// $this->assertEqual(strlen($original),strlen($fromFile)); // $this->assertEquals(strlen($original),strlen($fromFile));
// $this->assertEqual($original,$fromFile); // $this->assertEquals($original,$fromFile);
// //
// } // }
// //
@ -181,12 +181,12 @@
// $stored=$rootView->file_get_contents($userDir.'/file'); // $stored=$rootView->file_get_contents($userDir.'/file');
// OC_FileProxy::$enabled=true; // OC_FileProxy::$enabled=true;
// //
// $this->assertNotEqual($original,$stored); // $this->assertNotEquals($original,$stored);
// $fromFile=$rootView->file_get_contents($userDir.'/file'); // $fromFile=$rootView->file_get_contents($userDir.'/file');
// $this->assertEqual($original,$fromFile); // $this->assertEquals($original,$fromFile);
// //
// $fromFile=$view->file_get_contents('files/file'); // $fromFile=$view->file_get_contents('files/file');
// $this->assertEqual($original,$fromFile); // $this->assertEquals($original,$fromFile);
// } // }
// //
// public function testBinary(){ // public function testBinary(){
@ -200,9 +200,9 @@
// OC_FileProxy::$enabled=true; // OC_FileProxy::$enabled=true;
// //
// $fromFile=OC_Filesystem::file_get_contents('/file'); // $fromFile=OC_Filesystem::file_get_contents('/file');
// $this->assertNotEqual($original,$stored); // $this->assertNotEquals($original,$stored);
// $this->assertEqual(strlen($original),strlen($fromFile)); // $this->assertEquals(strlen($original),strlen($fromFile));
// $this->assertEqual($original,$fromFile); // $this->assertEquals($original,$fromFile);
// //
// $file=__DIR__.'/zeros'; // $file=__DIR__.'/zeros';
// $original=file_get_contents($file); // $original=file_get_contents($file);
@ -214,7 +214,7 @@
// OC_FileProxy::$enabled=true; // OC_FileProxy::$enabled=true;
// //
// $fromFile=OC_Filesystem::file_get_contents('/file'); // $fromFile=OC_Filesystem::file_get_contents('/file');
// $this->assertNotEqual($original,$stored); // $this->assertNotEquals($original,$stored);
// $this->assertEqual(strlen($original),strlen($fromFile)); // $this->assertEquals(strlen($original),strlen($fromFile));
// } // }
// } // }

22
apps/files_encryption/test/stream.php
View File

@ -117,7 +117,7 @@
// // // //
// // fclose( $stream ); // // fclose( $stream );
// // // //
// // $this->assertEqual( 'foobar', $data ); // // $this->assertEquals( 'foobar', $data );
// // // //
// // // //
// // $file = OC::$SERVERROOT.'/3rdparty/MDB2.php'; // // $file = OC::$SERVERROOT.'/3rdparty/MDB2.php';
@ -139,15 +139,15 @@
// // // //
// // $original = file_get_contents( $file ); // // $original = file_get_contents( $file );
// // // //
// // $this->assertEqual( strlen( $original ), strlen( $data ) ); // // $this->assertEquals( strlen( $original ), strlen( $data ) );
// // // //
// // $this->assertEqual( $original, $data ); // // $this->assertEquals( $original, $data );
// // // //
// // } // // }
// //
// } // }
// //
// // class Test_CryptStream extends UnitTestCase { // // class Test_CryptStream extends PHPUnit_Framework_TestCase {
// // private $tmpFiles=array(); // // private $tmpFiles=array();
// // // //
// // function testStream(){ // // function testStream(){
@ -158,7 +158,7 @@
// // $stream=$this->getStream('test1','r',strlen('foobar')); // // $stream=$this->getStream('test1','r',strlen('foobar'));
// // $data=fread($stream,6); // // $data=fread($stream,6);
// // fclose($stream); // // fclose($stream);
// // $this->assertEqual('foobar',$data); // // $this->assertEquals('foobar',$data);
// // // //
// // $file=OC::$SERVERROOT.'/3rdparty/MDB2.php'; // // $file=OC::$SERVERROOT.'/3rdparty/MDB2.php';
// // $source=fopen($file,'r'); // // $source=fopen($file,'r');
@ -170,8 +170,8 @@
// // $stream=$this->getStream('test2','r',filesize($file)); // // $stream=$this->getStream('test2','r',filesize($file));
// // $data=stream_get_contents($stream); // // $data=stream_get_contents($stream);
// // $original=file_get_contents($file); // // $original=file_get_contents($file);
// // $this->assertEqual(strlen($original),strlen($data)); // // $this->assertEquals(strlen($original),strlen($data));
// // $this->assertEqual($original,$data); // // $this->assertEquals($original,$data);
// // } // // }
// // // //
// // /** // // /**
@ -207,8 +207,8 @@
// // $stream=$this->getStream('test','r',strlen($source)); // // $stream=$this->getStream('test','r',strlen($source));
// // $data=stream_get_contents($stream); // // $data=stream_get_contents($stream);
// // fclose($stream); // // fclose($stream);
// // $this->assertEqual(strlen($data),strlen($source)); // // $this->assertEquals(strlen($data),strlen($source));
// // $this->assertEqual($source,$data); // // $this->assertEquals($source,$data);
// // // //
// // $file=__DIR__.'/zeros'; // // $file=__DIR__.'/zeros';
// // $source=file_get_contents($file); // // $source=file_get_contents($file);
@ -220,7 +220,7 @@
// // $stream=$this->getStream('test2','r',strlen($source)); // // $stream=$this->getStream('test2','r',strlen($source));
// // $data=stream_get_contents($stream); // // $data=stream_get_contents($stream);
// // fclose($stream); // // fclose($stream);
// // $this->assertEqual(strlen($data),strlen($source)); // // $this->assertEquals(strlen($data),strlen($source));
// // $this->assertEqual($source,$data); // // $this->assertEquals($source,$data);
// // } // // }
// // } // // }

2
apps/files_encryption/test/util.php
View File

@ -203,7 +203,7 @@ class Test_Enc_Util extends \PHPUnit_Framework_TestCase {
// //
// $decrypted = $c->legacyDecrypt( $encrypted, $c->legacyKey ); // $decrypted = $c->legacyDecrypt( $encrypted, $c->legacyKey );
// //
// $this->assertEqual( $decrypted, $this->data ); // $this->assertEquals( $decrypted, $this->data );
// //
// } // }

8
apps/files_external/tests/ftp.php
View File

@ -32,18 +32,18 @@ class Test_Filestorage_FTP extends Test_FileStorage {
'root' => '/', 'root' => '/',
'secure' => false ); 'secure' => false );
$instance = new OC_Filestorage_FTP($config); $instance = new OC_Filestorage_FTP($config);
$this->assertEqual('ftp://ftp:ftp@localhost/', $instance->constructUrl('')); $this->assertEquals('ftp://ftp:ftp@localhost/', $instance->constructUrl(''));
$config['secure'] = true; $config['secure'] = true;
$instance = new OC_Filestorage_FTP($config); $instance = new OC_Filestorage_FTP($config);
$this->assertEqual('ftps://ftp:ftp@localhost/', $instance->constructUrl('')); $this->assertEquals('ftps://ftp:ftp@localhost/', $instance->constructUrl(''));
$config['secure'] = 'false'; $config['secure'] = 'false';
$instance = new OC_Filestorage_FTP($config); $instance = new OC_Filestorage_FTP($config);
$this->assertEqual('ftp://ftp:ftp@localhost/', $instance->constructUrl('')); $this->assertEquals('ftp://ftp:ftp@localhost/', $instance->constructUrl(''));
$config['secure'] = 'true'; $config['secure'] = 'true';
$instance = new OC_Filestorage_FTP($config); $instance = new OC_Filestorage_FTP($config);
$this->assertEqual('ftps://ftp:ftp@localhost/', $instance->constructUrl('')); $this->assertEquals('ftps://ftp:ftp@localhost/', $instance->constructUrl(''));
} }
} }

2
apps/user_ldap/tests/group_ldap.php
View File

@ -20,7 +20,7 @@
* *
*/ */
class Test_Group_Ldap extends UnitTestCase { class Test_Group_Ldap extends PHPUnit_Framework_TestCase {
function setUp() { function setUp() {
OC_Group::clearBackends(); OC_Group::clearBackends();
} }

19
tests/bootstrap.php
View File

@ -8,24 +8,5 @@ if(!class_exists('PHPUnit_Framework_TestCase')) {
require_once('PHPUnit/Autoload.php'); require_once('PHPUnit/Autoload.php');
} }
//SimpleTest compatibility
abstract class UnitTestCase extends PHPUnit_Framework_TestCase{
function assertEqual($expected, $actual, $string='') {
$this->assertEquals($expected, $actual, $string);
}
function assertNotEqual($expected, $actual, $string='') {
$this->assertNotEquals($expected, $actual, $string);
}
static function assertTrue($actual, $string='') {
parent::assertTrue((bool)$actual, $string);
}
static function assertFalse($actual, $string='') {
parent::assertFalse((bool)$actual, $string);
}
}
OC_Hook::clear(); OC_Hook::clear();
OC_Log::$enabled = false; OC_Log::$enabled = false;

36
tests/lib/archive.php
View File

@ -6,7 +6,7 @@
* See the COPYING-README file. * See the COPYING-README file.
*/ */
abstract class Test_Archive extends UnitTestCase { abstract class Test_Archive extends PHPUnit_Framework_TestCase {
/** /**
* @var OC_Archive * @var OC_Archive
*/ */
@ -27,7 +27,7 @@ abstract class Test_Archive extends UnitTestCase {
$this->instance=$this->getExisting(); $this->instance=$this->getExisting();
$allFiles=$this->instance->getFiles(); $allFiles=$this->instance->getFiles();
$expected=array('lorem.txt','logo-wide.png','dir/', 'dir/lorem.txt'); $expected=array('lorem.txt','logo-wide.png','dir/', 'dir/lorem.txt');
$this->assertEqual(4, count($allFiles), 'only found '.count($allFiles).' out of 4 expected files'); $this->assertEquals(4, count($allFiles), 'only found '.count($allFiles).' out of 4 expected files');
foreach($expected as $file) { foreach($expected as $file) {
$this->assertContains($file, $allFiles, 'cant find '. $file . ' in archive'); $this->assertContains($file, $allFiles, 'cant find '. $file . ' in archive');
$this->assertTrue($this->instance->fileExists($file), 'file '.$file.' does not exist in archive'); $this->assertTrue($this->instance->fileExists($file), 'file '.$file.' does not exist in archive');
@ -36,14 +36,14 @@ abstract class Test_Archive extends UnitTestCase {
$rootContent=$this->instance->getFolder(''); $rootContent=$this->instance->getFolder('');
$expected=array('lorem.txt','logo-wide.png', 'dir/'); $expected=array('lorem.txt','logo-wide.png', 'dir/');
$this->assertEqual(3, count($rootContent)); $this->assertEquals(3, count($rootContent));
foreach($expected as $file) { foreach($expected as $file) {
$this->assertContains($file, $rootContent, 'cant find '. $file . ' in archive'); $this->assertContains($file, $rootContent, 'cant find '. $file . ' in archive');
} }
$dirContent=$this->instance->getFolder('dir/'); $dirContent=$this->instance->getFolder('dir/');
$expected=array('lorem.txt'); $expected=array('lorem.txt');
$this->assertEqual(1, count($dirContent)); $this->assertEquals(1, count($dirContent));
foreach($expected as $file) { foreach($expected as $file) {
$this->assertContains($file, $dirContent, 'cant find '. $file . ' in archive'); $this->assertContains($file, $dirContent, 'cant find '. $file . ' in archive');
} }
@ -53,36 +53,36 @@ abstract class Test_Archive extends UnitTestCase {
$this->instance=$this->getExisting(); $this->instance=$this->getExisting();
$dir=OC::$SERVERROOT.'/tests/data'; $dir=OC::$SERVERROOT.'/tests/data';
$textFile=$dir.'/lorem.txt'; $textFile=$dir.'/lorem.txt';
$this->assertEqual(file_get_contents($textFile), $this->instance->getFile('lorem.txt')); $this->assertEquals(file_get_contents($textFile), $this->instance->getFile('lorem.txt'));
$tmpFile=OCP\Files::tmpFile('.txt'); $tmpFile=OCP\Files::tmpFile('.txt');
$this->instance->extractFile('lorem.txt', $tmpFile); $this->instance->extractFile('lorem.txt', $tmpFile);
$this->assertEqual(file_get_contents($textFile), file_get_contents($tmpFile)); $this->assertEquals(file_get_contents($textFile), file_get_contents($tmpFile));
} }
public function testWrite() { public function testWrite() {
$dir=OC::$SERVERROOT.'/tests/data'; $dir=OC::$SERVERROOT.'/tests/data';
$textFile=$dir.'/lorem.txt'; $textFile=$dir.'/lorem.txt';
$this->instance=$this->getNew(); $this->instance=$this->getNew();
$this->assertEqual(0, count($this->instance->getFiles())); $this->assertEquals(0, count($this->instance->getFiles()));
$this->instance->addFile('lorem.txt', $textFile); $this->instance->addFile('lorem.txt', $textFile);
$this->assertEqual(1, count($this->instance->getFiles())); $this->assertEquals(1, count($this->instance->getFiles()));
$this->assertTrue($this->instance->fileExists('lorem.txt')); $this->assertTrue($this->instance->fileExists('lorem.txt'));
$this->assertFalse($this->instance->fileExists('lorem.txt/')); $this->assertFalse($this->instance->fileExists('lorem.txt/'));
$this->assertEqual(file_get_contents($textFile), $this->instance->getFile('lorem.txt')); $this->assertEquals(file_get_contents($textFile), $this->instance->getFile('lorem.txt'));
$this->instance->addFile('lorem.txt', 'foobar'); $this->instance->addFile('lorem.txt', 'foobar');
$this->assertEqual('foobar', $this->instance->getFile('lorem.txt')); $this->assertEquals('foobar', $this->instance->getFile('lorem.txt'));
} }
public function testReadStream() { public function testReadStream() {
$dir=OC::$SERVERROOT.'/tests/data'; $dir=OC::$SERVERROOT.'/tests/data';
$this->instance=$this->getExisting(); $this->instance=$this->getExisting();
$fh=$this->instance->getStream('lorem.txt', 'r'); $fh=$this->instance->getStream('lorem.txt', 'r');
$this->assertTrue($fh); $this->assertTrue((bool)$fh);
$content=fread($fh, $this->instance->filesize('lorem.txt')); $content=fread($fh, $this->instance->filesize('lorem.txt'));
fclose($fh); fclose($fh);
$this->assertEqual(file_get_contents($dir.'/lorem.txt'), $content); $this->assertEquals(file_get_contents($dir.'/lorem.txt'), $content);
} }
public function testWriteStream() { public function testWriteStream() {
$dir=OC::$SERVERROOT.'/tests/data'; $dir=OC::$SERVERROOT.'/tests/data';
@ -93,7 +93,7 @@ abstract class Test_Archive extends UnitTestCase {
fclose($source); fclose($source);
fclose($fh); fclose($fh);
$this->assertTrue($this->instance->fileExists('lorem.txt')); $this->assertTrue($this->instance->fileExists('lorem.txt'));
$this->assertEqual(file_get_contents($dir.'/lorem.txt'), $this->instance->getFile('lorem.txt')); $this->assertEquals(file_get_contents($dir.'/lorem.txt'), $this->instance->getFile('lorem.txt'));
} }
public function testFolder() { public function testFolder() {
$this->instance=$this->getNew(); $this->instance=$this->getNew();
@ -111,10 +111,10 @@ abstract class Test_Archive extends UnitTestCase {
$this->instance=$this->getExisting(); $this->instance=$this->getExisting();
$tmpDir=OCP\Files::tmpFolder(); $tmpDir=OCP\Files::tmpFolder();
$this->instance->extract($tmpDir); $this->instance->extract($tmpDir);
$this->assertEqual(true, file_exists($tmpDir.'lorem.txt')); $this->assertEquals(true, file_exists($tmpDir.'lorem.txt'));
$this->assertEqual(true, file_exists($tmpDir.'dir/lorem.txt')); $this->assertEquals(true, file_exists($tmpDir.'dir/lorem.txt'));
$this->assertEqual(true, file_exists($tmpDir.'logo-wide.png')); $this->assertEquals(true, file_exists($tmpDir.'logo-wide.png'));
$this->assertEqual(file_get_contents($dir.'/lorem.txt'), file_get_contents($tmpDir.'lorem.txt')); $this->assertEquals(file_get_contents($dir.'/lorem.txt'), file_get_contents($tmpDir.'lorem.txt'));
OCP\Files::rmdirr($tmpDir); OCP\Files::rmdirr($tmpDir);
} }
public function testMoveRemove() { public function testMoveRemove() {
@ -126,7 +126,7 @@ abstract class Test_Archive extends UnitTestCase {
$this->instance->rename('lorem.txt', 'target.txt'); $this->instance->rename('lorem.txt', 'target.txt');
$this->assertTrue($this->instance->fileExists('target.txt')); $this->assertTrue($this->instance->fileExists('target.txt'));
$this->assertFalse($this->instance->fileExists('lorem.txt')); $this->assertFalse($this->instance->fileExists('lorem.txt'));
$this->assertEqual(file_get_contents($textFile), $this->instance->getFile('target.txt')); $this->assertEquals(file_get_contents($textFile), $this->instance->getFile('target.txt'));
$this->instance->remove('target.txt'); $this->instance->remove('target.txt');
$this->assertFalse($this->instance->fileExists('target.txt')); $this->assertFalse($this->instance->fileExists('target.txt'));
} }

10
tests/lib/cache.php
View File

@ -6,7 +6,7 @@
* See the COPYING-README file. * See the COPYING-README file.
*/ */
abstract class Test_Cache extends UnitTestCase { abstract class Test_Cache extends PHPUnit_Framework_TestCase {
/** /**
* @var OC_Cache cache; * @var OC_Cache cache;
*/ */
@ -26,19 +26,19 @@ abstract class Test_Cache extends UnitTestCase {
$this->instance->set('value1', $value); $this->instance->set('value1', $value);
$this->assertTrue($this->instance->hasKey('value1')); $this->assertTrue($this->instance->hasKey('value1'));
$received=$this->instance->get('value1'); $received=$this->instance->get('value1');
$this->assertEqual($value, $received, 'Value recieved from cache not equal to the original'); $this->assertEquals($value, $received, 'Value recieved from cache not equal to the original');
$value='ipsum lorum'; $value='ipsum lorum';
$this->instance->set('value1', $value); $this->instance->set('value1', $value);
$received=$this->instance->get('value1'); $received=$this->instance->get('value1');
$this->assertEqual($value, $received, 'Value not overwritten by second set'); $this->assertEquals($value, $received, 'Value not overwritten by second set');
$value2='foobar'; $value2='foobar';
$this->instance->set('value2', $value2); $this->instance->set('value2', $value2);
$received2=$this->instance->get('value2'); $received2=$this->instance->get('value2');
$this->assertTrue($this->instance->hasKey('value1')); $this->assertTrue($this->instance->hasKey('value1'));
$this->assertTrue($this->instance->hasKey('value2')); $this->assertTrue($this->instance->hasKey('value2'));
$this->assertEqual($value, $received, 'Value changed while setting other variable'); $this->assertEquals($value, $received, 'Value changed while setting other variable');
$this->assertEqual($value2, $received2, 'Second value not equal to original'); $this->assertEquals($value2, $received2, 'Second value not equal to original');
$this->assertFalse($this->instance->hasKey('not_set')); $this->assertFalse($this->instance->hasKey('not_set'));
$this->assertNull($this->instance->get('not_set'), 'Unset value not equal to null'); $this->assertNull($this->instance->get('not_set'), 'Unset value not equal to null');

40
tests/lib/db.php
View File

@ -6,7 +6,7 @@
* See the COPYING-README file. * See the COPYING-README file.
*/ */
class Test_DB extends UnitTestCase { class Test_DB extends PHPUnit_Framework_TestCase {
protected $backupGlobals = FALSE; protected $backupGlobals = FALSE;
protected static $schema_file = 'static://test_db_scheme'; protected static $schema_file = 'static://test_db_scheme';
@ -35,18 +35,18 @@ class Test_DB extends UnitTestCase {
public function testQuotes() { public function testQuotes() {
$query = OC_DB::prepare('SELECT `fullname` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?'); $query = OC_DB::prepare('SELECT `fullname` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?');
$result = $query->execute(array('uri_1')); $result = $query->execute(array('uri_1'));
$this->assertTrue($result); $this->assertTrue((bool)$result);
$row = $result->fetchRow(); $row = $result->fetchRow();
$this->assertFalse($row); $this->assertFalse($row);
$query = OC_DB::prepare('INSERT INTO *PREFIX*'.$this->table2.' (`fullname`,`uri`) VALUES (?,?)'); $query = OC_DB::prepare('INSERT INTO *PREFIX*'.$this->table2.' (`fullname`,`uri`) VALUES (?,?)');
$result = $query->execute(array('fullname test', 'uri_1')); $result = $query->execute(array('fullname test', 'uri_1'));
$this->assertTrue($result); $this->assertTrue((bool)$result);
$query = OC_DB::prepare('SELECT `fullname`,`uri` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?'); $query = OC_DB::prepare('SELECT `fullname`,`uri` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?');
$result = $query->execute(array('uri_1')); $result = $query->execute(array('uri_1'));
$this->assertTrue($result); $this->assertTrue((bool)$result);
$row = $result->fetchRow(); $row = $result->fetchRow();
$this->assertArrayHasKey('fullname', $row); $this->assertArrayHasKey('fullname', $row);
$this->assertEqual($row['fullname'], 'fullname test'); $this->assertEquals($row['fullname'], 'fullname test');
$row = $result->fetchRow(); $row = $result->fetchRow();
$this->assertFalse($row); $this->assertFalse($row);
} }
@ -54,19 +54,19 @@ class Test_DB extends UnitTestCase {
public function testNOW() { public function testNOW() {
$query = OC_DB::prepare('INSERT INTO *PREFIX*'.$this->table2.' (`fullname`,`uri`) VALUES (NOW(),?)'); $query = OC_DB::prepare('INSERT INTO *PREFIX*'.$this->table2.' (`fullname`,`uri`) VALUES (NOW(),?)');
$result = $query->execute(array('uri_2')); $result = $query->execute(array('uri_2'));
$this->assertTrue($result); $this->assertTrue((bool)$result);
$query = OC_DB::prepare('SELECT `fullname`,`uri` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?'); $query = OC_DB::prepare('SELECT `fullname`,`uri` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?');
$result = $query->execute(array('uri_2')); $result = $query->execute(array('uri_2'));
$this->assertTrue($result); $this->assertTrue((bool)$result);
} }
public function testUNIX_TIMESTAMP() { public function testUNIX_TIMESTAMP() {
$query = OC_DB::prepare('INSERT INTO *PREFIX*'.$this->table2.' (`fullname`,`uri`) VALUES (UNIX_TIMESTAMP(),?)'); $query = OC_DB::prepare('INSERT INTO *PREFIX*'.$this->table2.' (`fullname`,`uri`) VALUES (UNIX_TIMESTAMP(),?)');
$result = $query->execute(array('uri_3')); $result = $query->execute(array('uri_3'));
$this->assertTrue($result); $this->assertTrue((bool)$result);
$query = OC_DB::prepare('SELECT `fullname`,`uri` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?'); $query = OC_DB::prepare('SELECT `fullname`,`uri` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?');
$result = $query->execute(array('uri_3')); $result = $query->execute(array('uri_3'));
$this->assertTrue($result); $this->assertTrue((bool)$result);
} }
public function testinsertIfNotExist() { public function testinsertIfNotExist() {
@ -85,13 +85,13 @@ class Test_DB extends UnitTestCase {
'type' => $entry['type'], 'type' => $entry['type'],
'category' => $entry['category'], 'category' => $entry['category'],
)); ));
$this->assertTrue($result); $this->assertTrue((bool)$result);
} }
$query = OC_DB::prepare('SELECT * FROM *PREFIX*'.$this->table3); $query = OC_DB::prepare('SELECT * FROM *PREFIX*'.$this->table3);
$result = $query->execute(); $result = $query->execute();
$this->assertTrue($result); $this->assertTrue((bool)$result);
$this->assertEqual('4', $result->numRows()); $this->assertEquals('4', $result->numRows());
} }
public function testinsertIfNotExistDontOverwrite() { public function testinsertIfNotExistDontOverwrite() {
@ -102,14 +102,14 @@ class Test_DB extends UnitTestCase {
// Normal test to have same known data inserted. // Normal test to have same known data inserted.
$query = OC_DB::prepare('INSERT INTO *PREFIX*'.$this->table2.' (`fullname`, `uri`, `carddata`) VALUES (?, ?, ?)'); $query = OC_DB::prepare('INSERT INTO *PREFIX*'.$this->table2.' (`fullname`, `uri`, `carddata`) VALUES (?, ?, ?)');
$result = $query->execute(array($fullname, $uri, $carddata)); $result = $query->execute(array($fullname, $uri, $carddata));
$this->assertTrue($result); $this->assertTrue((bool)$result);
$query = OC_DB::prepare('SELECT `fullname`, `uri`, `carddata` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?'); $query = OC_DB::prepare('SELECT `fullname`, `uri`, `carddata` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?');
$result = $query->execute(array($uri)); $result = $query->execute(array($uri));
$this->assertTrue($result); $this->assertTrue((bool)$result);
$row = $result->fetchRow(); $row = $result->fetchRow();
$this->assertArrayHasKey('carddata', $row); $this->assertArrayHasKey('carddata', $row);
$this->assertEqual($carddata, $row['carddata']); $this->assertEquals($carddata, $row['carddata']);
$this->assertEqual('1', $result->numRows()); $this->assertEquals('1', $result->numRows());
// Try to insert a new row // Try to insert a new row
$result = OC_DB::insertIfNotExist('*PREFIX*'.$this->table2, $result = OC_DB::insertIfNotExist('*PREFIX*'.$this->table2,
@ -117,17 +117,17 @@ class Test_DB extends UnitTestCase {
'fullname' => $fullname, 'fullname' => $fullname,
'uri' => $uri, 'uri' => $uri,
)); ));
$this->assertTrue($result); $this->assertTrue((bool)$result);
$query = OC_DB::prepare('SELECT `fullname`, `uri`, `carddata` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?'); $query = OC_DB::prepare('SELECT `fullname`, `uri`, `carddata` FROM *PREFIX*'.$this->table2.' WHERE `uri` = ?');
$result = $query->execute(array($uri)); $result = $query->execute(array($uri));
$this->assertTrue($result); $this->assertTrue((bool)$result);
$row = $result->fetchRow(); $row = $result->fetchRow();
$this->assertArrayHasKey('carddata', $row); $this->assertArrayHasKey('carddata', $row);
// Test that previously inserted data isn't overwritten // Test that previously inserted data isn't overwritten
$this->assertEqual($carddata, $row['carddata']); $this->assertEquals($carddata, $row['carddata']);
// And that a new row hasn't been inserted. // And that a new row hasn't been inserted.
$this->assertEqual('1', $result->numRows()); $this->assertEquals('1', $result->numRows());
} }
} }

2
tests/lib/dbschema.php
View File

@ -6,7 +6,7 @@
* See the COPYING-README file. * See the COPYING-README file.
*/ */
class Test_DBSchema extends UnitTestCase { class Test_DBSchema extends PHPUnit_Framework_TestCase {
protected static $schema_file = 'static://test_db_scheme'; protected static $schema_file = 'static://test_db_scheme';
protected static $schema_file2 = 'static://test_db_scheme2'; protected static $schema_file2 = 'static://test_db_scheme2';
protected $test_prefix; protected $test_prefix;

50
tests/lib/filestorage.php
View File

@ -20,7 +20,7 @@
* *
*/ */
abstract class Test_FileStorage extends UnitTestCase { abstract class Test_FileStorage extends PHPUnit_Framework_TestCase {
/** /**
* @var OC_Filestorage instance * @var OC_Filestorage instance
*/ */
@ -34,7 +34,7 @@ abstract class Test_FileStorage extends UnitTestCase {
$this->assertTrue($this->instance->isReadable('/'), 'Root folder is not readable'); $this->assertTrue($this->instance->isReadable('/'), 'Root folder is not readable');
$this->assertTrue($this->instance->is_dir('/'), 'Root folder is not a directory'); $this->assertTrue($this->instance->is_dir('/'), 'Root folder is not a directory');
$this->assertFalse($this->instance->is_file('/'), 'Root folder is a file'); $this->assertFalse($this->instance->is_file('/'), 'Root folder is a file');
$this->assertEqual('dir', $this->instance->filetype('/')); $this->assertEquals('dir', $this->instance->filetype('/'));
//without this, any further testing would be useless, not an acutal requirement for filestorage though //without this, any further testing would be useless, not an acutal requirement for filestorage though
$this->assertTrue($this->instance->isUpdatable('/'), 'Root folder is not writable'); $this->assertTrue($this->instance->isUpdatable('/'), 'Root folder is not writable');
@ -48,8 +48,8 @@ abstract class Test_FileStorage extends UnitTestCase {
$this->assertTrue($this->instance->file_exists('/folder')); $this->assertTrue($this->instance->file_exists('/folder'));
$this->assertTrue($this->instance->is_dir('/folder')); $this->assertTrue($this->instance->is_dir('/folder'));
$this->assertFalse($this->instance->is_file('/folder')); $this->assertFalse($this->instance->is_file('/folder'));
$this->assertEqual('dir', $this->instance->filetype('/folder')); $this->assertEquals('dir', $this->instance->filetype('/folder'));
$this->assertEqual(0, $this->instance->filesize('/folder')); $this->assertEquals(0, $this->instance->filesize('/folder'));
$this->assertTrue($this->instance->isReadable('/folder')); $this->assertTrue($this->instance->isReadable('/folder'));
$this->assertTrue($this->instance->isUpdatable('/folder')); $this->assertTrue($this->instance->isUpdatable('/folder'));
@ -60,7 +60,7 @@ abstract class Test_FileStorage extends UnitTestCase {
$content[] = $file; $content[] = $file;
} }
} }
$this->assertEqual(array('folder'), $content); $this->assertEquals(array('folder'), $content);
$this->assertFalse($this->instance->mkdir('/folder')); //cant create existing folders $this->assertFalse($this->instance->mkdir('/folder')); //cant create existing folders
$this->assertTrue($this->instance->rmdir('/folder')); $this->assertTrue($this->instance->rmdir('/folder'));
@ -76,7 +76,7 @@ abstract class Test_FileStorage extends UnitTestCase {
$content[] = $file; $content[] = $file;
} }
} }
$this->assertEqual(array(), $content); $this->assertEquals(array(), $content);
} }
/** /**
@ -89,31 +89,31 @@ abstract class Test_FileStorage extends UnitTestCase {
//fill a file with string data //fill a file with string data
$this->instance->file_put_contents('/lorem.txt', $sourceText); $this->instance->file_put_contents('/lorem.txt', $sourceText);
$this->assertFalse($this->instance->is_dir('/lorem.txt')); $this->assertFalse($this->instance->is_dir('/lorem.txt'));
$this->assertEqual($sourceText, $this->instance->file_get_contents('/lorem.txt'), 'data returned from file_get_contents is not equal to the source data'); $this->assertEquals($sourceText, $this->instance->file_get_contents('/lorem.txt'), 'data returned from file_get_contents is not equal to the source data');
//empty the file //empty the file
$this->instance->file_put_contents('/lorem.txt', ''); $this->instance->file_put_contents('/lorem.txt', '');
$this->assertEqual('', $this->instance->file_get_contents('/lorem.txt'), 'file not emptied'); $this->assertEquals('', $this->instance->file_get_contents('/lorem.txt'), 'file not emptied');
} }
/** /**
* test various known mimetypes * test various known mimetypes
*/ */
public function testMimeType() { public function testMimeType() {
$this->assertEqual('httpd/unix-directory', $this->instance->getMimeType('/')); $this->assertEquals('httpd/unix-directory', $this->instance->getMimeType('/'));
$this->assertEqual(false, $this->instance->getMimeType('/non/existing/file')); $this->assertEquals(false, $this->instance->getMimeType('/non/existing/file'));
$textFile = OC::$SERVERROOT . '/tests/data/lorem.txt'; $textFile = OC::$SERVERROOT . '/tests/data/lorem.txt';
$this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile, 'r')); $this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile, 'r'));
$this->assertEqual('text/plain', $this->instance->getMimeType('/lorem.txt')); $this->assertEquals('text/plain', $this->instance->getMimeType('/lorem.txt'));
$pngFile = OC::$SERVERROOT . '/tests/data/logo-wide.png'; $pngFile = OC::$SERVERROOT . '/tests/data/logo-wide.png';
$this->instance->file_put_contents('/logo-wide.png', file_get_contents($pngFile, 'r')); $this->instance->file_put_contents('/logo-wide.png', file_get_contents($pngFile, 'r'));
$this->assertEqual('image/png', $this->instance->getMimeType('/logo-wide.png')); $this->assertEquals('image/png', $this->instance->getMimeType('/logo-wide.png'));
$svgFile = OC::$SERVERROOT . '/tests/data/logo-wide.svg'; $svgFile = OC::$SERVERROOT . '/tests/data/logo-wide.svg';
$this->instance->file_put_contents('/logo-wide.svg', file_get_contents($svgFile, 'r')); $this->instance->file_put_contents('/logo-wide.svg', file_get_contents($svgFile, 'r'));
$this->assertEqual('image/svg+xml', $this->instance->getMimeType('/logo-wide.svg')); $this->assertEquals('image/svg+xml', $this->instance->getMimeType('/logo-wide.svg'));
} }
public function testCopyAndMove() { public function testCopyAndMove() {
@ -121,12 +121,12 @@ abstract class Test_FileStorage extends UnitTestCase {
$this->instance->file_put_contents('/source.txt', file_get_contents($textFile)); $this->instance->file_put_contents('/source.txt', file_get_contents($textFile));
$this->instance->copy('/source.txt', '/target.txt'); $this->instance->copy('/source.txt', '/target.txt');
$this->assertTrue($this->instance->file_exists('/target.txt')); $this->assertTrue($this->instance->file_exists('/target.txt'));
$this->assertEqual($this->instance->file_get_contents('/source.txt'), $this->instance->file_get_contents('/target.txt')); $this->assertEquals($this->instance->file_get_contents('/source.txt'), $this->instance->file_get_contents('/target.txt'));
$this->instance->rename('/source.txt', '/target2.txt'); $this->instance->rename('/source.txt', '/target2.txt');
$this->assertTrue($this->instance->file_exists('/target2.txt')); $this->assertTrue($this->instance->file_exists('/target2.txt'));
$this->assertFalse($this->instance->file_exists('/source.txt')); $this->assertFalse($this->instance->file_exists('/source.txt'));
$this->assertEqual(file_get_contents($textFile), $this->instance->file_get_contents('/target.txt')); $this->assertEquals(file_get_contents($textFile), $this->instance->file_get_contents('/target.txt'));
} }
public function testLocal() { public function testLocal() {
@ -134,7 +134,7 @@ abstract class Test_FileStorage extends UnitTestCase {
$this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile)); $this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
$localFile = $this->instance->getLocalFile('/lorem.txt'); $localFile = $this->instance->getLocalFile('/lorem.txt');
$this->assertTrue(file_exists($localFile)); $this->assertTrue(file_exists($localFile));
$this->assertEqual(file_get_contents($localFile), file_get_contents($textFile)); $this->assertEquals(file_get_contents($localFile), file_get_contents($textFile));
$this->instance->mkdir('/folder'); $this->instance->mkdir('/folder');
$this->instance->file_put_contents('/folder/lorem.txt', file_get_contents($textFile)); $this->instance->file_put_contents('/folder/lorem.txt', file_get_contents($textFile));
@ -145,9 +145,9 @@ abstract class Test_FileStorage extends UnitTestCase {
$this->assertTrue(is_dir($localFolder)); $this->assertTrue(is_dir($localFolder));
$this->assertTrue(file_exists($localFolder . '/lorem.txt')); $this->assertTrue(file_exists($localFolder . '/lorem.txt'));
$this->assertEqual(file_get_contents($localFolder . '/lorem.txt'), file_get_contents($textFile)); $this->assertEquals(file_get_contents($localFolder . '/lorem.txt'), file_get_contents($textFile));
$this->assertEqual(file_get_contents($localFolder . '/bar.txt'), 'asd'); $this->assertEquals(file_get_contents($localFolder . '/bar.txt'), 'asd');
$this->assertEqual(file_get_contents($localFolder . '/recursive/file.txt'), 'foo'); $this->assertEquals(file_get_contents($localFolder . '/recursive/file.txt'), 'foo');
} }
public function testStat() { public function testStat() {
@ -162,12 +162,12 @@ abstract class Test_FileStorage extends UnitTestCase {
$this->assertTrue(($ctimeStart - 1) <= $mTime); $this->assertTrue(($ctimeStart - 1) <= $mTime);
$this->assertTrue($mTime <= ($ctimeEnd + 1)); $this->assertTrue($mTime <= ($ctimeEnd + 1));
$this->assertEqual(filesize($textFile), $this->instance->filesize('/lorem.txt')); $this->assertEquals(filesize($textFile), $this->instance->filesize('/lorem.txt'));
$stat = $this->instance->stat('/lorem.txt'); $stat = $this->instance->stat('/lorem.txt');
//only size and mtime are requered in the result //only size and mtime are requered in the result
$this->assertEqual($stat['size'], $this->instance->filesize('/lorem.txt')); $this->assertEquals($stat['size'], $this->instance->filesize('/lorem.txt'));
$this->assertEqual($stat['mtime'], $mTime); $this->assertEquals($stat['mtime'], $mTime);
$mtimeStart = time(); $mtimeStart = time();
$supportsTouch = $this->instance->touch('/lorem.txt'); $supportsTouch = $this->instance->touch('/lorem.txt');
@ -181,7 +181,7 @@ abstract class Test_FileStorage extends UnitTestCase {
if ($this->instance->touch('/lorem.txt', 100) !== false) { if ($this->instance->touch('/lorem.txt', 100) !== false) {
$mTime = $this->instance->filemtime('/lorem.txt'); $mTime = $this->instance->filemtime('/lorem.txt');
$this->assertEqual($mTime, 100); $this->assertEquals($mTime, 100);
} }
} }
@ -207,7 +207,7 @@ abstract class Test_FileStorage extends UnitTestCase {
$svgFile = OC::$SERVERROOT . '/tests/data/logo-wide.svg'; $svgFile = OC::$SERVERROOT . '/tests/data/logo-wide.svg';
$this->instance->file_put_contents('/logo-wide.svg', file_get_contents($svgFile, 'r')); $this->instance->file_put_contents('/logo-wide.svg', file_get_contents($svgFile, 'r'));
$result = $this->instance->search('logo'); $result = $this->instance->search('logo');
$this->assertEqual(2, count($result)); $this->assertEquals(2, count($result));
$this->assertContains('/logo-wide.svg', $result); $this->assertContains('/logo-wide.svg', $result);
$this->assertContains('/logo-wide.png', $result); $this->assertContains('/logo-wide.png', $result);
} }
@ -229,6 +229,6 @@ abstract class Test_FileStorage extends UnitTestCase {
$fh = $this->instance->fopen('foo', 'r'); $fh = $this->instance->fopen('foo', 'r');
$content = stream_get_contents($fh); $content = stream_get_contents($fh);
$this->assertEqual(file_get_contents($textFile), $content); $this->assertEquals(file_get_contents($textFile), $content);
} }
} }

42
tests/lib/filesystem.php
View File

@ -20,7 +20,7 @@
* *
*/ */
class Test_Filesystem extends UnitTestCase { class Test_Filesystem extends PHPUnit_Framework_TestCase {
/** /**
* @var array tmpDirs * @var array tmpDirs
*/ */
@ -47,28 +47,28 @@ class Test_Filesystem extends UnitTestCase {
public function testMount() { public function testMount() {
OC_Filesystem::mount('OC_Filestorage_Local', self::getStorageData(), '/'); OC_Filesystem::mount('OC_Filestorage_Local', self::getStorageData(), '/');
$this->assertEqual('/', OC_Filesystem::getMountPoint('/')); $this->assertEquals('/', OC_Filesystem::getMountPoint('/'));
$this->assertEqual('/', OC_Filesystem::getMountPoint('/some/folder')); $this->assertEquals('/', OC_Filesystem::getMountPoint('/some/folder'));
$this->assertEqual('', OC_Filesystem::getInternalPath('/')); $this->assertEquals('', OC_Filesystem::getInternalPath('/'));
$this->assertEqual('some/folder', OC_Filesystem::getInternalPath('/some/folder')); $this->assertEquals('some/folder', OC_Filesystem::getInternalPath('/some/folder'));
OC_Filesystem::mount('OC_Filestorage_Local', self::getStorageData(), '/some'); OC_Filesystem::mount('OC_Filestorage_Local', self::getStorageData(), '/some');
$this->assertEqual('/', OC_Filesystem::getMountPoint('/')); $this->assertEquals('/', OC_Filesystem::getMountPoint('/'));
$this->assertEqual('/some/', OC_Filesystem::getMountPoint('/some/folder')); $this->assertEquals('/some/', OC_Filesystem::getMountPoint('/some/folder'));
$this->assertEqual('/some/', OC_Filesystem::getMountPoint('/some/')); $this->assertEquals('/some/', OC_Filesystem::getMountPoint('/some/'));
$this->assertEqual('/', OC_Filesystem::getMountPoint('/some')); $this->assertEquals('/', OC_Filesystem::getMountPoint('/some'));
$this->assertEqual('folder', OC_Filesystem::getInternalPath('/some/folder')); $this->assertEquals('folder', OC_Filesystem::getInternalPath('/some/folder'));
} }
public function testNormalize() { public function testNormalize() {
$this->assertEqual('/path', OC_Filesystem::normalizePath('/path/')); $this->assertEquals('/path', OC_Filesystem::normalizePath('/path/'));
$this->assertEqual('/path/', OC_Filesystem::normalizePath('/path/', false)); $this->assertEquals('/path/', OC_Filesystem::normalizePath('/path/', false));
$this->assertEqual('/path', OC_Filesystem::normalizePath('path')); $this->assertEquals('/path', OC_Filesystem::normalizePath('path'));
$this->assertEqual('/path', OC_Filesystem::normalizePath('\path')); $this->assertEquals('/path', OC_Filesystem::normalizePath('\path'));
$this->assertEqual('/foo/bar', OC_Filesystem::normalizePath('/foo//bar/')); $this->assertEquals('/foo/bar', OC_Filesystem::normalizePath('/foo//bar/'));
$this->assertEqual('/foo/bar', OC_Filesystem::normalizePath('/foo////bar')); $this->assertEquals('/foo/bar', OC_Filesystem::normalizePath('/foo////bar'));
if (class_exists('Normalizer')) { if (class_exists('Normalizer')) {
$this->assertEqual("/foo/bar\xC3\xBC", OC_Filesystem::normalizePath("/foo/baru\xCC\x88")); $this->assertEquals("/foo/bar\xC3\xBC", OC_Filesystem::normalizePath("/foo/baru\xCC\x88"));
} }
} }
@ -100,10 +100,10 @@ class Test_Filesystem extends UnitTestCase {
$rootView->mkdir('/' . $user); $rootView->mkdir('/' . $user);
$rootView->mkdir('/' . $user . '/files'); $rootView->mkdir('/' . $user . '/files');
$this->assertFalse($rootView->file_put_contents('/.htaccess', 'foo')); $this->assertFalse((bool)$rootView->file_put_contents('/.htaccess', 'foo'));
$this->assertFalse(OC_Filesystem::file_put_contents('/.htaccess', 'foo')); $this->assertFalse((bool)OC_Filesystem::file_put_contents('/.htaccess', 'foo'));
$fh = fopen(__FILE__, 'r'); $fh = fopen(__FILE__, 'r');
$this->assertFalse(OC_Filesystem::file_put_contents('/.htaccess', $fh)); $this->assertFalse((bool)OC_Filesystem::file_put_contents('/.htaccess', $fh));
} }
public function testHooks() { public function testHooks() {
@ -134,6 +134,6 @@ class Test_Filesystem extends UnitTestCase {
public function dummyHook($arguments) { public function dummyHook($arguments) {
$path = $arguments['path']; $path = $arguments['path'];
$this->assertEqual($path, OC_Filesystem::normalizePath($path)); //the path passed to the hook should already be normalized $this->assertEquals($path, OC_Filesystem::normalizePath($path)); //the path passed to the hook should already be normalized
} }
} }

2
tests/lib/geo.php
View File

@ -6,7 +6,7 @@
* See the COPYING-README file. * See the COPYING-README file.
*/ */
class Test_Geo extends UnitTestCase { class Test_Geo extends PHPUnit_Framework_TestCase {
function testTimezone() { function testTimezone() {
$result = OC_Geo::timezone(3, 3); $result = OC_Geo::timezone(3, 3);
$expected = 'Africa/Porto-Novo'; $expected = 'Africa/Porto-Novo';

56
tests/lib/group.php
View File

@ -22,7 +22,7 @@
* *
*/ */
class Test_Group extends UnitTestCase { class Test_Group extends PHPUnit_Framework_TestCase {
function setUp() { function setUp() {
OC_Group::clearBackends(); OC_Group::clearBackends();
} }
@ -43,24 +43,24 @@ class Test_Group extends UnitTestCase {
$this->assertFalse(OC_Group::inGroup($user1, $group2)); $this->assertFalse(OC_Group::inGroup($user1, $group2));
$this->assertFalse(OC_Group::inGroup($user2, $group2)); $this->assertFalse(OC_Group::inGroup($user2, $group2));
$this->assertTrue(OC_Group::addToGroup($user1, $group1)); $this->assertTrue((bool)OC_Group::addToGroup($user1, $group1));
$this->assertTrue(OC_Group::inGroup($user1, $group1)); $this->assertTrue(OC_Group::inGroup($user1, $group1));
$this->assertFalse(OC_Group::inGroup($user2, $group1)); $this->assertFalse(OC_Group::inGroup($user2, $group1));
$this->assertFalse(OC_Group::inGroup($user1, $group2)); $this->assertFalse(OC_Group::inGroup($user1, $group2));
$this->assertFalse(OC_Group::inGroup($user2, $group2)); $this->assertFalse(OC_Group::inGroup($user2, $group2));
$this->assertFalse(OC_Group::addToGroup($user1, $group1)); $this->assertFalse((bool)OC_Group::addToGroup($user1, $group1));
$this->assertEqual(array($user1), OC_Group::usersInGroup($group1)); $this->assertEquals(array($user1), OC_Group::usersInGroup($group1));
$this->assertEqual(array(), OC_Group::usersInGroup($group2)); $this->assertEquals(array(), OC_Group::usersInGroup($group2));
$this->assertEqual(array($group1), OC_Group::getUserGroups($user1)); $this->assertEquals(array($group1), OC_Group::getUserGroups($user1));
$this->assertEqual(array(), OC_Group::getUserGroups($user2)); $this->assertEquals(array(), OC_Group::getUserGroups($user2));
OC_Group::deleteGroup($group1); OC_Group::deleteGroup($group1);
$this->assertEqual(array(), OC_Group::getUserGroups($user1)); $this->assertEquals(array(), OC_Group::getUserGroups($user1));
$this->assertEqual(array(), OC_Group::usersInGroup($group1)); $this->assertEquals(array(), OC_Group::usersInGroup($group1));
$this->assertFalse(OC_Group::inGroup($user1, $group1)); $this->assertFalse(OC_Group::inGroup($user1, $group1));
} }
@ -69,7 +69,7 @@ class Test_Group extends UnitTestCase {
OC_Group::useBackend(new OC_Group_Dummy()); OC_Group::useBackend(new OC_Group_Dummy());
$emptyGroup = null; $emptyGroup = null;
$this->assertEqual(false, OC_Group::createGroup($emptyGroup)); $this->assertEquals(false, OC_Group::createGroup($emptyGroup));
} }
@ -80,8 +80,8 @@ class Test_Group extends UnitTestCase {
$groupCopy = $group; $groupCopy = $group;
$this->assertEqual(false, OC_Group::createGroup($groupCopy)); $this->assertEquals(false, OC_Group::createGroup($groupCopy));
$this->assertEqual(array($group), OC_Group::getGroups()); $this->assertEquals(array($group), OC_Group::getGroups());
} }
@ -90,8 +90,8 @@ class Test_Group extends UnitTestCase {
$adminGroup = 'admin'; $adminGroup = 'admin';
OC_Group::createGroup($adminGroup); OC_Group::createGroup($adminGroup);
$this->assertEqual(false, OC_Group::deleteGroup($adminGroup)); $this->assertEquals(false, OC_Group::deleteGroup($adminGroup));
$this->assertEqual(array($adminGroup), OC_Group::getGroups()); $this->assertEquals(array($adminGroup), OC_Group::getGroups());
} }
@ -100,8 +100,8 @@ class Test_Group extends UnitTestCase {
$groupNonExistent = 'notExistent'; $groupNonExistent = 'notExistent';
$user = uniqid(); $user = uniqid();
$this->assertEqual(false, OC_Group::addToGroup($user, $groupNonExistent)); $this->assertEquals(false, OC_Group::addToGroup($user, $groupNonExistent));
$this->assertEqual(array(), OC_Group::getGroups()); $this->assertEquals(array(), OC_Group::getGroups());
} }
@ -122,7 +122,7 @@ class Test_Group extends UnitTestCase {
OC_Group::addToGroup($user3, $group1); OC_Group::addToGroup($user3, $group1);
OC_Group::addToGroup($user3, $group2); OC_Group::addToGroup($user3, $group2);
$this->assertEqual(array($user1, $user2, $user3), $this->assertEquals(array($user1, $user2, $user3),
OC_Group::usersInGroups(array($group1, $group2, $group3))); OC_Group::usersInGroups(array($group1, $group2, $group3)));
// FIXME: needs more parameter variation // FIXME: needs more parameter variation
@ -141,16 +141,16 @@ class Test_Group extends UnitTestCase {
OC_Group::createGroup($group1); OC_Group::createGroup($group1);
//groups should be added to the first registered backend //groups should be added to the first registered backend
$this->assertEqual(array($group1), $backend1->getGroups()); $this->assertEquals(array($group1), $backend1->getGroups());
$this->assertEqual(array(), $backend2->getGroups()); $this->assertEquals(array(), $backend2->getGroups());
$this->assertEqual(array($group1), OC_Group::getGroups()); $this->assertEquals(array($group1), OC_Group::getGroups());
$this->assertTrue(OC_Group::groupExists($group1)); $this->assertTrue(OC_Group::groupExists($group1));
$this->assertFalse(OC_Group::groupExists($group2)); $this->assertFalse(OC_Group::groupExists($group2));
$backend1->createGroup($group2); $backend1->createGroup($group2);
$this->assertEqual(array($group1, $group2), OC_Group::getGroups()); $this->assertEquals(array($group1, $group2), OC_Group::getGroups());
$this->assertTrue(OC_Group::groupExists($group1)); $this->assertTrue(OC_Group::groupExists($group1));
$this->assertTrue(OC_Group::groupExists($group2)); $this->assertTrue(OC_Group::groupExists($group2));
@ -161,22 +161,22 @@ class Test_Group extends UnitTestCase {
$this->assertFalse(OC_Group::inGroup($user2, $group1)); $this->assertFalse(OC_Group::inGroup($user2, $group1));
$this->assertTrue(OC_Group::addToGroup($user1, $group1)); $this->assertTrue((bool)OC_Group::addToGroup($user1, $group1));
$this->assertTrue(OC_Group::inGroup($user1, $group1)); $this->assertTrue(OC_Group::inGroup($user1, $group1));
$this->assertFalse(OC_Group::inGroup($user2, $group1)); $this->assertFalse(OC_Group::inGroup($user2, $group1));
$this->assertFalse($backend2->inGroup($user1, $group1)); $this->assertFalse($backend2->inGroup($user1, $group1));
$this->assertFalse(OC_Group::addToGroup($user1, $group1)); $this->assertFalse((bool)OC_Group::addToGroup($user1, $group1));
$this->assertEqual(array($user1), OC_Group::usersInGroup($group1)); $this->assertEquals(array($user1), OC_Group::usersInGroup($group1));
$this->assertEqual(array($group1), OC_Group::getUserGroups($user1)); $this->assertEquals(array($group1), OC_Group::getUserGroups($user1));
$this->assertEqual(array(), OC_Group::getUserGroups($user2)); $this->assertEquals(array(), OC_Group::getUserGroups($user2));
OC_Group::deleteGroup($group1); OC_Group::deleteGroup($group1);
$this->assertEqual(array(), OC_Group::getUserGroups($user1)); $this->assertEquals(array(), OC_Group::getUserGroups($user1));
$this->assertEqual(array(), OC_Group::usersInGroup($group1)); $this->assertEquals(array(), OC_Group::usersInGroup($group1));
$this->assertFalse(OC_Group::inGroup($user1, $group1)); $this->assertFalse(OC_Group::inGroup($user1, $group1));
} }
} }

20
tests/lib/group/backend.php
View File

@ -20,7 +20,7 @@
* *
*/ */
abstract class Test_Group_Backend extends UnitTestCase { abstract class Test_Group_Backend extends PHPUnit_Framework_TestCase {
/** /**
* @var OC_Group_Backend $backend * @var OC_Group_Backend $backend
*/ */
@ -52,18 +52,18 @@ abstract class Test_Group_Backend extends UnitTestCase {
$name2=$this->getGroupName(); $name2=$this->getGroupName();
$this->backend->createGroup($name1); $this->backend->createGroup($name1);
$count=count($this->backend->getGroups())-$startCount; $count=count($this->backend->getGroups())-$startCount;
$this->assertEqual(1, $count); $this->assertEquals(1, $count);
$this->assertTrue((array_search($name1, $this->backend->getGroups())!==false)); $this->assertTrue((array_search($name1, $this->backend->getGroups())!==false));
$this->assertFalse((array_search($name2, $this->backend->getGroups())!==false)); $this->assertFalse((array_search($name2, $this->backend->getGroups())!==false));
$this->backend->createGroup($name2); $this->backend->createGroup($name2);
$count=count($this->backend->getGroups())-$startCount; $count=count($this->backend->getGroups())-$startCount;
$this->assertEqual(2, $count); $this->assertEquals(2, $count);
$this->assertTrue((array_search($name1, $this->backend->getGroups())!==false)); $this->assertTrue((array_search($name1, $this->backend->getGroups())!==false));
$this->assertTrue((array_search($name2, $this->backend->getGroups())!==false)); $this->assertTrue((array_search($name2, $this->backend->getGroups())!==false));
$this->backend->deleteGroup($name2); $this->backend->deleteGroup($name2);
$count=count($this->backend->getGroups())-$startCount; $count=count($this->backend->getGroups())-$startCount;
$this->assertEqual(1, $count); $this->assertEquals(1, $count);
$this->assertTrue((array_search($name1, $this->backend->getGroups())!==false)); $this->assertTrue((array_search($name1, $this->backend->getGroups())!==false));
$this->assertFalse((array_search($name2, $this->backend->getGroups())!==false)); $this->assertFalse((array_search($name2, $this->backend->getGroups())!==false));
} }
@ -91,15 +91,15 @@ abstract class Test_Group_Backend extends UnitTestCase {
$this->assertFalse($this->backend->addToGroup($user1, $group1)); $this->assertFalse($this->backend->addToGroup($user1, $group1));
$this->assertEqual(array($user1), $this->backend->usersInGroup($group1)); $this->assertEquals(array($user1), $this->backend->usersInGroup($group1));
$this->assertEqual(array(), $this->backend->usersInGroup($group2)); $this->assertEquals(array(), $this->backend->usersInGroup($group2));
$this->assertEqual(array($group1), $this->backend->getUserGroups($user1)); $this->assertEquals(array($group1), $this->backend->getUserGroups($user1));
$this->assertEqual(array(), $this->backend->getUserGroups($user2)); $this->assertEquals(array(), $this->backend->getUserGroups($user2));
$this->backend->deleteGroup($group1); $this->backend->deleteGroup($group1);
$this->assertEqual(array(), $this->backend->getUserGroups($user1)); $this->assertEquals(array(), $this->backend->getUserGroups($user1));
$this->assertEqual(array(), $this->backend->usersInGroup($group1)); $this->assertEquals(array(), $this->backend->usersInGroup($group1));
$this->assertFalse($this->backend->inGroup($user1, $group1)); $this->assertFalse($this->backend->inGroup($user1, $group1));
} }
} }

2
tests/lib/helper.php
View File

@ -6,7 +6,7 @@
* See the COPYING-README file. * See the COPYING-README file.
*/ */
class Test_Helper extends UnitTestCase { class Test_Helper extends PHPUnit_Framework_TestCase {
function testHumanFileSize() { function testHumanFileSize() {
$result = OC_Helper::humanFileSize(0); $result = OC_Helper::humanFileSize(0);

2
tests/lib/share/share.php
View File

@ -19,7 +19,7 @@
* License along with this library. If not, see <http://www.gnu.org/licenses/>. * License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/ */
class Test_Share extends UnitTestCase { class Test_Share extends PHPUnit_Framework_TestCase {
protected $itemType; protected $itemType;
protected $userBackend; protected $userBackend;

10
tests/lib/streamwrappers.php
View File

@ -20,7 +20,7 @@
* *
*/ */
class Test_StreamWrappers extends UnitTestCase { class Test_StreamWrappers extends PHPUnit_Framework_TestCase {
public function testFakeDir() { public function testFakeDir() {
$items=array('foo', 'bar'); $items=array('foo', 'bar');
OC_FakeDirStream::$dirs['test']=$items; OC_FakeDirStream::$dirs['test']=$items;
@ -30,7 +30,7 @@ class Test_StreamWrappers extends UnitTestCase {
$result[]=$file; $result[]=$file;
$this->assertContains($file, $items); $this->assertContains($file, $items);
} }
$this->assertEqual(count($items), count($result)); $this->assertEquals(count($items), count($result));
} }
public function testStaticStream() { public function testStaticStream() {
@ -39,7 +39,7 @@ class Test_StreamWrappers extends UnitTestCase {
$this->assertFalse(file_exists($staticFile)); $this->assertFalse(file_exists($staticFile));
file_put_contents($staticFile, file_get_contents($sourceFile)); file_put_contents($staticFile, file_get_contents($sourceFile));
$this->assertTrue(file_exists($staticFile)); $this->assertTrue(file_exists($staticFile));
$this->assertEqual(file_get_contents($sourceFile), file_get_contents($staticFile)); $this->assertEquals(file_get_contents($sourceFile), file_get_contents($staticFile));
unlink($staticFile); unlink($staticFile);
clearstatcache(); clearstatcache();
$this->assertFalse(file_exists($staticFile)); $this->assertFalse(file_exists($staticFile));
@ -52,7 +52,7 @@ class Test_StreamWrappers extends UnitTestCase {
$file='close://'.$tmpFile; $file='close://'.$tmpFile;
$this->assertTrue(file_exists($file)); $this->assertTrue(file_exists($file));
file_put_contents($file, file_get_contents($sourceFile)); file_put_contents($file, file_get_contents($sourceFile));
$this->assertEqual(file_get_contents($sourceFile), file_get_contents($file)); $this->assertEquals(file_get_contents($sourceFile), file_get_contents($file));
unlink($file); unlink($file);
clearstatcache(); clearstatcache();
$this->assertFalse(file_exists($file)); $this->assertFalse(file_exists($file));
@ -68,7 +68,7 @@ class Test_StreamWrappers extends UnitTestCase {
$this->fail('Expected exception'); $this->fail('Expected exception');
}catch(Exception $e) { }catch(Exception $e) {
$path=$e->getMessage(); $path=$e->getMessage();
$this->assertEqual($path, $tmpFile); $this->assertEquals($path, $tmpFile);
} }
} }

10
tests/lib/template.php
View File

@ -22,7 +22,7 @@
OC::autoload('OC_Template'); OC::autoload('OC_Template');
class Test_TemplateFunctions extends UnitTestCase { class Test_TemplateFunctions extends PHPUnit_Framework_TestCase {
public function testP() { public function testP() {
// FIXME: do we need more testcases? // FIXME: do we need more testcases?
@ -31,7 +31,7 @@ class Test_TemplateFunctions extends UnitTestCase {
p($htmlString); p($htmlString);
$result = ob_get_clean(); $result = ob_get_clean();
$this->assertEqual("&lt;script&gt;alert(&#039;xss&#039;);&lt;/script&gt;", $result); $this->assertEquals("&lt;script&gt;alert(&#039;xss&#039;);&lt;/script&gt;", $result);
} }
public function testPNormalString() { public function testPNormalString() {
@ -40,7 +40,7 @@ class Test_TemplateFunctions extends UnitTestCase {
p($normalString); p($normalString);
$result = ob_get_clean(); $result = ob_get_clean();
$this->assertEqual("This is a good string!", $result); $this->assertEquals("This is a good string!", $result);
} }
@ -51,7 +51,7 @@ class Test_TemplateFunctions extends UnitTestCase {
print_unescaped($htmlString); print_unescaped($htmlString);
$result = ob_get_clean(); $result = ob_get_clean();
$this->assertEqual($htmlString, $result); $this->assertEquals($htmlString, $result);
} }
public function testPrintUnescapedNormalString() { public function testPrintUnescapedNormalString() {
@ -60,7 +60,7 @@ class Test_TemplateFunctions extends UnitTestCase {
print_unescaped($normalString); print_unescaped($normalString);
$result = ob_get_clean(); $result = ob_get_clean();
$this->assertEqual("This is a good string!", $result); $this->assertEquals("This is a good string!", $result);
} }

8
tests/lib/user/backend.php
View File

@ -30,7 +30,7 @@
* For an example see /tests/lib/user/dummy.php * For an example see /tests/lib/user/dummy.php
*/ */
abstract class Test_User_Backend extends UnitTestCase { abstract class Test_User_Backend extends PHPUnit_Framework_TestCase {
/** /**
* @var OC_User_Backend $backend * @var OC_User_Backend $backend
*/ */
@ -53,18 +53,18 @@ abstract class Test_User_Backend extends UnitTestCase {
$name2=$this->getUser(); $name2=$this->getUser();
$this->backend->createUser($name1, ''); $this->backend->createUser($name1, '');
$count=count($this->backend->getUsers())-$startCount; $count=count($this->backend->getUsers())-$startCount;
$this->assertEqual(1, $count); $this->assertEquals(1, $count);
$this->assertTrue((array_search($name1, $this->backend->getUsers())!==false)); $this->assertTrue((array_search($name1, $this->backend->getUsers())!==false));
$this->assertFalse((array_search($name2, $this->backend->getUsers())!==false)); $this->assertFalse((array_search($name2, $this->backend->getUsers())!==false));
$this->backend->createUser($name2, ''); $this->backend->createUser($name2, '');
$count=count($this->backend->getUsers())-$startCount; $count=count($this->backend->getUsers())-$startCount;
$this->assertEqual(2, $count); $this->assertEquals(2, $count);
$this->assertTrue((array_search($name1, $this->backend->getUsers())!==false)); $this->assertTrue((array_search($name1, $this->backend->getUsers())!==false));
$this->assertTrue((array_search($name2, $this->backend->getUsers())!==false)); $this->assertTrue((array_search($name2, $this->backend->getUsers())!==false));
$this->backend->deleteUser($name2); $this->backend->deleteUser($name2);
$count=count($this->backend->getUsers())-$startCount; $count=count($this->backend->getUsers())-$startCount;
$this->assertEqual(1, $count); $this->assertEquals(1, $count);
$this->assertTrue((array_search($name1, $this->backend->getUsers())!==false)); $this->assertTrue((array_search($name1, $this->backend->getUsers())!==false));
$this->assertFalse((array_search($name2, $this->backend->getUsers())!==false)); $this->assertFalse((array_search($name2, $this->backend->getUsers())!==false));
} }

2
tests/lib/util.php
View File

@ -6,7 +6,7 @@
* See the COPYING-README file. * See the COPYING-README file.
*/ */
class Test_Util extends UnitTestCase { class Test_Util extends PHPUnit_Framework_TestCase {
// Constructor // Constructor
function Test_Util() { function Test_Util() {

22
tests/lib/vcategories.php
View File

@ -22,7 +22,7 @@
//require_once("../lib/template.php"); //require_once("../lib/template.php");
class Test_VCategories extends UnitTestCase { class Test_VCategories extends PHPUnit_Framework_TestCase {
protected $objectType; protected $objectType;
protected $user; protected $user;
@ -49,7 +49,7 @@ class Test_VCategories extends UnitTestCase {
$catmgr = new OC_VCategories($this->objectType, $this->user, $defcategories); $catmgr = new OC_VCategories($this->objectType, $this->user, $defcategories);
$this->assertEqual(4, count($catmgr->categories())); $this->assertEquals(4, count($catmgr->categories()));
} }
public function testAddCategories() { public function testAddCategories() {
@ -59,25 +59,25 @@ class Test_VCategories extends UnitTestCase {
foreach($categories as $category) { foreach($categories as $category) {
$result = $catmgr->add($category); $result = $catmgr->add($category);
$this->assertTrue($result); $this->assertTrue((bool)$result);
} }
$this->assertFalse($catmgr->add('Family')); $this->assertFalse($catmgr->add('Family'));
$this->assertFalse($catmgr->add('fAMILY')); $this->assertFalse($catmgr->add('fAMILY'));
$this->assertEqual(4, count($catmgr->categories())); $this->assertEquals(4, count($catmgr->categories()));
} }
public function testdeleteCategories() { public function testdeleteCategories() {
$defcategories = array('Friends', 'Family', 'Work', 'Other'); $defcategories = array('Friends', 'Family', 'Work', 'Other');
$catmgr = new OC_VCategories($this->objectType, $this->user, $defcategories); $catmgr = new OC_VCategories($this->objectType, $this->user, $defcategories);
$this->assertEqual(4, count($catmgr->categories())); $this->assertEquals(4, count($catmgr->categories()));
$catmgr->delete('family'); $catmgr->delete('family');
$this->assertEqual(3, count($catmgr->categories())); $this->assertEquals(3, count($catmgr->categories()));
$catmgr->delete(array('Friends', 'Work', 'Other')); $catmgr->delete(array('Friends', 'Work', 'Other'));
$this->assertEqual(0, count($catmgr->categories())); $this->assertEquals(0, count($catmgr->categories()));
} }
@ -90,8 +90,8 @@ class Test_VCategories extends UnitTestCase {
$catmgr->addToCategory($id, 'Family'); $catmgr->addToCategory($id, 'Family');
} }
$this->assertEqual(1, count($catmgr->categories())); $this->assertEquals(1, count($catmgr->categories()));
$this->assertEqual(9, count($catmgr->idsForCategory('Family'))); $this->assertEquals(9, count($catmgr->idsForCategory('Family')));
} }
/** /**
@ -110,8 +110,8 @@ class Test_VCategories extends UnitTestCase {
$this->assertFalse(in_array($id, $catmgr->idsForCategory('Family'))); $this->assertFalse(in_array($id, $catmgr->idsForCategory('Family')));
} }
$this->assertEqual(1, count($catmgr->categories())); $this->assertEquals(1, count($catmgr->categories()));
$this->assertEqual(0, count($catmgr->idsForCategory('Family'))); $this->assertEquals(0, count($catmgr->idsForCategory('Family')));
} }
} }