From 9fc0fbdb8c9c52c876468f5918c369674329efd0 Mon Sep 17 00:00:00 2001
From: Daniele Alessandri <suppakilla@gmail.com>
Date: Sat, 17 Apr 2010 19:49:20 +0200
Subject: [PATCH] Converted the test suite to invoke commands on the client
 instance as they are defined in the command reference of Redis instead of
 using their aliases.

---
 test/PredisShared.php      |  14 +-
 test/RedisCommandsTest.php | 659 ++++++++++++++++++-------------------
 2 files changed, 332 insertions(+), 341 deletions(-)

diff --git a/test/PredisShared.php b/test/PredisShared.php
index 2eb2bbe9..6cd09261 100644
--- a/test/PredisShared.php
+++ b/test/PredisShared.php
@@ -29,7 +29,7 @@ class RC {
         $serverProfile = Predis\RedisServerProfile::get('dev');
         $connection = new Predis\Client(array('host' => RC::SERVER_HOST, 'port' => RC::SERVER_PORT), $serverProfile);
         $connection->connect();
-        $connection->selectDatabase(RC::DEFAULT_DATABASE);
+        $connection->select(RC::DEFAULT_DATABASE);
         return $connection;
     }
 
@@ -110,20 +110,20 @@ class RC {
 
     public static function pushTailAndReturn(Predis\Client $client, $keyName, Array $values, $wipeOut = 0) {
         if ($wipeOut == true) {
-            $client->delete($keyName);
+            $client->del($keyName);
         }
         foreach ($values as $value) {
-            $client->pushTail($keyName, $value);
+            $client->rpush($keyName, $value);
         }
         return $values;
     }
 
     public static function setAddAndReturn(Predis\Client $client, $keyName, Array $values, $wipeOut = 0) {
         if ($wipeOut == true) {
-            $client->delete($keyName);
+            $client->del($keyName);
         }
         foreach ($values as $value) {
-            $client->setAdd($keyName, $value);
+            $client->sadd($keyName, $value);
         }
         return $values;
     }
@@ -131,10 +131,10 @@ class RC {
     public static function zsetAddAndReturn(Predis\Client $client, $keyName, Array $values, $wipeOut = 0) {
         // $values: array(SCORE => VALUE, ...);
         if ($wipeOut == true) {
-            $client->delete($keyName);
+            $client->del($keyName);
         }
         foreach ($values as $value => $score) {
-            $client->zsetAdd($keyName, $score, $value);
+            $client->zadd($keyName, $score, $value);
         }
         return $values;
     }
diff --git a/test/RedisCommandsTest.php b/test/RedisCommandsTest.php
index fe474453..b8c76d71 100644
--- a/test/RedisCommandsTest.php
+++ b/test/RedisCommandsTest.php
@@ -10,19 +10,19 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
     // TODO: instead of an boolean assertion against the return value 
     //       of RC::sameValuesInArrays, we should extend PHPUnit with 
     //       a new assertion, e.g. $this->assertSameValues();
-    // TODO: an option to skip certain tests such as testFlushDatabases
+    // TODO: an option to skip certain tests such as testflushdbs
     //       should be provided.
     // TODO: missing test with float values for a few commands
 
     protected function setUp() { 
         $this->redis = RC::getConnection();
-        $this->redis->flushDatabase();
+        $this->redis->flushdb();
     }
 
     protected function tearDown() { 
     }
 
-    protected function onNotSuccessfulTest($exception) {
+    protected function onNotSuccessfulTest(Exception $exception) {
         // drops and reconnect to a redis server on uncaught exceptions
         RC::resetConnection();
         parent::onNotSuccessfulTest($exception);
@@ -95,7 +95,7 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
 
         // should throw an exception when trying to do a GET on non-string types
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
-            $test->redis->pushTail('metavars', 'foo');
+            $test->redis->rpush('metavars', 'foo');
             $test->redis->get('metavars');
         });
     }
@@ -110,8 +110,8 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
     function testSetPreserve() {
         $multi = RC::getKeyValueArray();
 
-        $this->assertTrue($this->redis->setPreserve('foo', 'bar'));
-        $this->assertFalse($this->redis->setPreserve('foo', 'rab'));
+        $this->assertTrue($this->redis->setnx('foo', 'bar'));
+        $this->assertFalse($this->redis->setnx('foo', 'rab'));
         $this->assertEquals('bar', $this->redis->get('foo'));
     }
 
@@ -119,13 +119,13 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
         $multi = RC::getKeyValueArray();
 
         // key=>value pairs via array instance
-        $this->assertTrue($this->redis->setMultiple($multi));
-        $multiRet = $this->redis->getMultiple(array_keys($multi));
+        $this->assertTrue($this->redis->mset($multi));
+        $multiRet = $this->redis->mget(array_keys($multi));
         $this->assertEquals($multi, array_combine(array_keys($multi), array_values($multiRet)));
 
         // key=>value pairs via function arguments
-        $this->assertTrue($this->redis->setMultiple('a', 1, 'b', 2, 'c', 3));
-        $this->assertEquals(array(1, 2, 3), $this->redis->getMultiple('a', 'b', 'c'));
+        $this->assertTrue($this->redis->mset('a', 1, 'b', 2, 'c', 3));
+        $this->assertEquals(array(1, 2, 3), $this->redis->mget('a', 'b', 'c'));
     }
 
     function testSetMultiplePreserve() {
@@ -135,58 +135,58 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
 
         // successful set
         $expectedResult = array_merge($multi, $newpair);
-        $this->redis->setMultiple($multi);
-        $this->assertTrue($this->redis->setMultiplePreserve($newpair));
+        $this->redis->mset($multi);
+        $this->assertTrue($this->redis->msetnx($newpair));
         $this->assertEquals(
             array_values($expectedResult), 
-            $this->redis->getMultiple(array_keys($expectedResult))
+            $this->redis->mget(array_keys($expectedResult))
         );
 
-        $this->redis->flushDatabase();
+        $this->redis->flushdb();
 
         // unsuccessful set
         $expectedResult = array_merge($multi, array('hogehoge' => null));
-        $this->redis->setMultiple($multi);
-        $this->assertFalse($this->redis->setMultiplePreserve(array_merge($newpair, $hijacked)));
+        $this->redis->mset($multi);
+        $this->assertFalse($this->redis->msetnx(array_merge($newpair, $hijacked)));
         $this->assertEquals(
             array_values($expectedResult), 
-            $this->redis->getMultiple(array_keys($expectedResult))
+            $this->redis->mget(array_keys($expectedResult))
         );
     }
 
     function testGetSet() {
-        $this->assertNull($this->redis->getSet('foo', 'bar'));
-        $this->assertEquals('bar', $this->redis->getSet('foo', 'barbar'));
-        $this->assertEquals('barbar', $this->redis->getSet('foo', 'baz'));
+        $this->assertNull($this->redis->getset('foo', 'bar'));
+        $this->assertEquals('bar', $this->redis->getset('foo', 'barbar'));
+        $this->assertEquals('barbar', $this->redis->getset('foo', 'baz'));
     }
 
     function testIncrementAndIncrementBy() {
         // test subsequent increment commands
-        $this->assertEquals(1, $this->redis->increment('foo'));
-        $this->assertEquals(2, $this->redis->increment('foo'));
+        $this->assertEquals(1, $this->redis->incr('foo'));
+        $this->assertEquals(2, $this->redis->incr('foo'));
 
         // test subsequent incrementBy commands
-        $this->assertEquals(22, $this->redis->incrementBy('foo', 20));
-        $this->assertEquals(10, $this->redis->incrementBy('foo', -12));
-        $this->assertEquals(-100, $this->redis->incrementBy('foo', -110));
+        $this->assertEquals(22, $this->redis->incrby('foo', 20));
+        $this->assertEquals(10, $this->redis->incrby('foo', -12));
+        $this->assertEquals(-100, $this->redis->incrby('foo', -110));
     }
 
     function testDecrementAndDecrementBy() {
         // test subsequent decrement commands
-        $this->assertEquals(-1, $this->redis->decrement('foo'));
-        $this->assertEquals(-2, $this->redis->decrement('foo'));
+        $this->assertEquals(-1, $this->redis->decr('foo'));
+        $this->assertEquals(-2, $this->redis->decr('foo'));
 
         // test subsequent decrementBy commands
-        $this->assertEquals(-22, $this->redis->decrementBy('foo', 20));
-        $this->assertEquals(-10, $this->redis->decrementBy('foo', -12));
-        $this->assertEquals(100, $this->redis->decrementBy('foo', -110));
+        $this->assertEquals(-22, $this->redis->decrby('foo', 20));
+        $this->assertEquals(-10, $this->redis->decrby('foo', -12));
+        $this->assertEquals(100, $this->redis->decrby('foo', -110));
     }
 
     function testDelete() {
         $this->redis->set('foo', 'bar');
-        $this->assertTrue($this->redis->delete('foo'));
+        $this->assertTrue($this->redis->del('foo'));
         $this->assertFalse($this->redis->exists('foo'));
-        $this->assertFalse($this->redis->delete('foo'));
+        $this->assertFalse($this->redis->del('foo'));
     }
 
     function testType() {
@@ -195,13 +195,13 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
         $this->redis->set('fooString', 'bar');
         $this->assertEquals('string', $this->redis->type('fooString'));
 
-        $this->redis->pushTail('fooList', 'bar');
+        $this->redis->rpush('fooList', 'bar');
         $this->assertEquals('list', $this->redis->type('fooList'));
 
-        $this->redis->setAdd('fooSet', 'bar');
+        $this->redis->sadd('fooSet', 'bar');
         $this->assertEquals('set', $this->redis->type('fooSet'));
 
-        $this->redis->zsetAdd('fooZSet', 0, 'bar');
+        $this->redis->zadd('fooZSet', 0, 'bar');
         $this->assertEquals('zset', $this->redis->type('fooZSet'));
     }
 
@@ -215,7 +215,7 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
         $this->assertEquals('piyo', $this->redis->get('hoge'));
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
-            $test->redis->pushTail('metavars', 'foo');
+            $test->redis->rpush('metavars', 'foo');
             $test->redis->append('metavars', 'bar');
         });
     }
@@ -232,7 +232,7 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
         $this->assertEquals(12345, $this->redis->substr('numeric', 0, 4));
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
-            $test->redis->pushTail('metavars', 'foo');
+            $test->redis->rpush('metavars', 'foo');
             $test->redis->substr('metavars', 0, 3);
         });
     }
@@ -244,7 +244,7 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
         $keyValsOthers = array('aaa' => 1, 'aba' => 2, 'aca' => 3);
         $allKeyVals    = array_merge($keyValsNs, $keyValsOthers);
 
-        $this->redis->setMultiple($allKeyVals);
+        $this->redis->mset($allKeyVals);
 
         $this->assertEquals(array(), $this->redis->keys('nokeys:*'));
 
@@ -261,14 +261,14 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
     function testRandomKey() {
         $keyvals = RC::getKeyValueArray();
 
-        $this->assertNull($this->redis->randomKey());
+        $this->assertNull($this->redis->randomkey());
 
-        $this->redis->setMultiple($keyvals);
-        $this->assertTrue(in_array($this->redis->randomKey(), array_keys($keyvals)));
+        $this->redis->mset($keyvals);
+        $this->assertTrue(in_array($this->redis->randomkey(), array_keys($keyvals)));
     }
 
     function testRename() {
-        $this->redis->setMultiple(array('foo' => 'bar', 'foofoo' => 'barbar'));
+        $this->redis->mset(array('foo' => 'bar', 'foofoo' => 'barbar'));
 
         // rename existing keys
         $this->assertTrue($this->redis->rename('foo', 'foofoo'));
@@ -282,18 +282,18 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
     }
 
     function testRenamePreserve() {
-        $this->redis->setMultiple(array('foo' => 'bar', 'hoge' => 'piyo', 'hogehoge' => 'piyopiyo'));
+        $this->redis->mset(array('foo' => 'bar', 'hoge' => 'piyo', 'hogehoge' => 'piyopiyo'));
 
-        $this->assertTrue($this->redis->renamePreserve('foo', 'foofoo'));
+        $this->assertTrue($this->redis->renamenx('foo', 'foofoo'));
         $this->assertFalse($this->redis->exists('foo'));
         $this->assertEquals('bar', $this->redis->get('foofoo'));
 
-        $this->assertFalse($this->redis->renamePreserve('hoge', 'hogehoge'));
+        $this->assertFalse($this->redis->renamenx('hoge', 'hogehoge'));
         $this->assertTrue($this->redis->exists('hoge'));
 
         // should throw an excepion then trying to rename non-existing keys
         RC::testForServerException($this, RC::EXCEPTION_NO_SUCH_KEY, function($test) {
-            $test->redis->renamePreserve('fuga', 'baz');
+            $test->redis->renamenx('fuga', 'baz');
         });
     }
 
@@ -323,9 +323,9 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
 
     function testDatabaseSize() {
         // TODO: is this really OK?
-        $this->assertEquals(0, $this->redis->databaseSize());
-        $this->redis->setMultiple(RC::getKeyValueArray());
-        $this->assertGreaterThan(0, $this->redis->databaseSize());
+        $this->assertEquals(0, $this->redis->dbsize());
+        $this->redis->mset(RC::getKeyValueArray());
+        $this->assertGreaterThan(0, $this->redis->dbsize());
     }
 
 
@@ -333,42 +333,42 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
 
     function testPushTail() {
         // NOTE: List push operations return the list length since Redis commit 520b5a3
-        $this->assertEquals(1, $this->redis->pushTail('metavars', 'foo'));
+        $this->assertEquals(1, $this->redis->rpush('metavars', 'foo'));
         $this->assertTrue($this->redis->exists('metavars'));
-        $this->assertEquals(2, $this->redis->pushTail('metavars', 'hoge'));
+        $this->assertEquals(2, $this->redis->rpush('metavars', 'hoge'));
 
         // should throw an exception when trying to do a RPUSH on non-list types
         // should throw an exception when trying to do a LPUSH on non-list types
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->pushTail('foo', 'bar');
+            $test->redis->rpush('foo', 'bar');
         });
     }
 
     function testPushHead() {
         // NOTE: List push operations return the list length since Redis commit 520b5a3
-        $this->assertEquals(1, $this->redis->pushHead('metavars', 'foo'));
+        $this->assertEquals(1, $this->redis->lpush('metavars', 'foo'));
         $this->assertTrue($this->redis->exists('metavars'));
-        $this->assertEquals(2, $this->redis->pushHead('metavars', 'hoge'));
+        $this->assertEquals(2, $this->redis->lpush('metavars', 'hoge'));
 
         // should throw an exception when trying to do a LPUSH on non-list types
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->pushHead('foo', 'bar');
+            $test->redis->lpush('foo', 'bar');
         });
     }
 
     function testListLength() {
-        $this->assertEquals(1, $this->redis->pushTail('metavars', 'foo'));
-        $this->assertEquals(2, $this->redis->pushTail('metavars', 'hoge'));
-        $this->assertEquals(2, $this->redis->listLength('metavars'));
+        $this->assertEquals(1, $this->redis->rpush('metavars', 'foo'));
+        $this->assertEquals(2, $this->redis->rpush('metavars', 'hoge'));
+        $this->assertEquals(2, $this->redis->llen('metavars'));
 
-        $this->assertEquals(0, $this->redis->listLength('doesnotexist'));
+        $this->assertEquals(0, $this->redis->llen('doesnotexist'));
 
         // should throw an exception when trying to do a LLEN on non-list types
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->listLength('foo');
+            $test->redis->llen('foo');
         });
     }
 
@@ -377,127 +377,127 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
 
         $this->assertEquals(
             array_slice($numbers, 0, 4),
-            $this->redis->listRange('numbers', 0, 3)
+            $this->redis->lrange('numbers', 0, 3)
         );
         $this->assertEquals(
             array_slice($numbers, 4, 5),
-            $this->redis->listRange('numbers', 4, 8)
+            $this->redis->lrange('numbers', 4, 8)
         );
         $this->assertEquals(
             array_slice($numbers, 0, 1),
-            $this->redis->listRange('numbers', 0, 0)
+            $this->redis->lrange('numbers', 0, 0)
         );
         $this->assertEquals(
             array(),
-            $this->redis->listRange('numbers', 1, 0)
+            $this->redis->lrange('numbers', 1, 0)
         );
         $this->assertEquals(
             $numbers,
-            $this->redis->listRange('numbers', 0, -1)
+            $this->redis->lrange('numbers', 0, -1)
         );
         $this->assertEquals(
             array(5),
-            $this->redis->listRange('numbers', 5, -5)
+            $this->redis->lrange('numbers', 5, -5)
         );
         $this->assertEquals(
             array(),
-            $this->redis->listRange('numbers', 7, -5)
+            $this->redis->lrange('numbers', 7, -5)
         );
         $this->assertEquals(
             array_slice($numbers, -5, -1),
-            $this->redis->listRange('numbers', -5, -2)
+            $this->redis->lrange('numbers', -5, -2)
         );
         $this->assertEquals(
             $numbers,
-            $this->redis->listRange('numbers', -100, 100)
+            $this->redis->lrange('numbers', -100, 100)
         );
 
         $this->assertEquals(
             array(), 
-            $this->redis->listRange('keyDoesNotExist', 0, 1)
+            $this->redis->lrange('keyDoesNotExist', 0, 1)
         );
 
         // should throw an exception when trying to do a LRANGE on non-list types
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->listRange('foo', 0, -1);
+            $test->redis->lrange('foo', 0, -1);
         });
     }
 
     function testListTrim() {
         $numbers = RC::pushTailAndReturn($this->redis, 'numbers', RC::getArrayOfNumbers());
-        $this->assertTrue($this->redis->listTrim('numbers', 0, 2));
+        $this->assertTrue($this->redis->ltrim('numbers', 0, 2));
         $this->assertEquals(
             array_slice($numbers, 0, 3), 
-            $this->redis->listRange('numbers', 0, -1)
+            $this->redis->lrange('numbers', 0, -1)
         );
 
         $numbers = RC::pushTailAndReturn($this->redis, 'numbers', RC::getArrayOfNumbers(), RC::WIPE_OUT);
-        $this->assertTrue($this->redis->listTrim('numbers', 5, 9));
+        $this->assertTrue($this->redis->ltrim('numbers', 5, 9));
         $this->assertEquals(
             array_slice($numbers, 5, 5), 
-            $this->redis->listRange('numbers', 0, -1)
+            $this->redis->lrange('numbers', 0, -1)
         );
 
         $numbers = RC::pushTailAndReturn($this->redis, 'numbers', RC::getArrayOfNumbers(), RC::WIPE_OUT);
-        $this->assertTrue($this->redis->listTrim('numbers', 0, -6));
+        $this->assertTrue($this->redis->ltrim('numbers', 0, -6));
         $this->assertEquals(
             array_slice($numbers, 0, -5), 
-            $this->redis->listRange('numbers', 0, -1)
+            $this->redis->lrange('numbers', 0, -1)
         );
 
         $numbers = RC::pushTailAndReturn($this->redis, 'numbers', RC::getArrayOfNumbers(), RC::WIPE_OUT);
-        $this->assertTrue($this->redis->listTrim('numbers', -5, -3));
+        $this->assertTrue($this->redis->ltrim('numbers', -5, -3));
         $this->assertEquals(
             array_slice($numbers, 5, 3), 
-            $this->redis->listRange('numbers', 0, -1)
+            $this->redis->lrange('numbers', 0, -1)
         );
 
         $numbers = RC::pushTailAndReturn($this->redis, 'numbers', RC::getArrayOfNumbers(), RC::WIPE_OUT);
-        $this->assertTrue($this->redis->listTrim('numbers', -100, 100));
+        $this->assertTrue($this->redis->ltrim('numbers', -100, 100));
         $this->assertEquals(
             $numbers, 
-            $this->redis->listRange('numbers', 0, -1)
+            $this->redis->lrange('numbers', 0, -1)
         );
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->listTrim('foo', 0, 1);
+            $test->redis->ltrim('foo', 0, 1);
         });
     }
 
     function testListIndex() {
         $numbers = RC::pushTailAndReturn($this->redis, 'numbers', RC::getArrayOfNumbers());
 
-        $this->assertEquals(0, $this->redis->listIndex('numbers', 0));
-        $this->assertEquals(5, $this->redis->listIndex('numbers', 5));
-        $this->assertEquals(9, $this->redis->listIndex('numbers', 9));
-        $this->assertNull($this->redis->listIndex('numbers', 100));
+        $this->assertEquals(0, $this->redis->lindex('numbers', 0));
+        $this->assertEquals(5, $this->redis->lindex('numbers', 5));
+        $this->assertEquals(9, $this->redis->lindex('numbers', 9));
+        $this->assertNull($this->redis->lindex('numbers', 100));
 
-        $this->assertEquals(0, $this->redis->listIndex('numbers', -0));
-        $this->assertEquals(9, $this->redis->listIndex('numbers', -1));
-        $this->assertEquals(7, $this->redis->listIndex('numbers', -3));
-        $this->assertNull($this->redis->listIndex('numbers', -100));
+        $this->assertEquals(0, $this->redis->lindex('numbers', -0));
+        $this->assertEquals(9, $this->redis->lindex('numbers', -1));
+        $this->assertEquals(7, $this->redis->lindex('numbers', -3));
+        $this->assertNull($this->redis->lindex('numbers', -100));
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->listIndex('foo', 0);
+            $test->redis->lindex('foo', 0);
         });
     }
 
     function testListSet() {
         $numbers = RC::pushTailAndReturn($this->redis, 'numbers', RC::getArrayOfNumbers());
 
-        $this->assertTrue($this->redis->listSet('numbers', 5, -5));
-        $this->assertEquals(-5, $this->redis->listIndex('numbers', 5));
+        $this->assertTrue($this->redis->lset('numbers', 5, -5));
+        $this->assertEquals(-5, $this->redis->lindex('numbers', 5));
 
         RC::testForServerException($this, RC::EXCEPTION_OUT_OF_RANGE, function($test) {
-            $test->redis->listSet('numbers', 99, 99);
+            $test->redis->lset('numbers', 99, 99);
         });
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->listSet('foo', 0, 0);
+            $test->redis->lset('foo', 0, 0);
         });
     }
 
@@ -505,103 +505,103 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
         $mixed = array(0, '_', 2, '_', 4, '_', 6, '_');
 
         RC::pushTailAndReturn($this->redis, 'mixed', $mixed);
-        $this->assertEquals(2, $this->redis->listRemove('mixed', 2, '_'));
-        $this->assertEquals(array(0, 2, 4, '_', 6, '_'), $this->redis->listRange('mixed', 0, -1));
+        $this->assertEquals(2, $this->redis->lrem('mixed', 2, '_'));
+        $this->assertEquals(array(0, 2, 4, '_', 6, '_'), $this->redis->lrange('mixed', 0, -1));
 
         RC::pushTailAndReturn($this->redis, 'mixed', $mixed, RC::WIPE_OUT);
-        $this->assertEquals(4, $this->redis->listRemove('mixed', 0, '_'));
-        $this->assertEquals(array(0, 2, 4, 6), $this->redis->listRange('mixed', 0, -1));
+        $this->assertEquals(4, $this->redis->lrem('mixed', 0, '_'));
+        $this->assertEquals(array(0, 2, 4, 6), $this->redis->lrange('mixed', 0, -1));
 
         RC::pushTailAndReturn($this->redis, 'mixed', $mixed, RC::WIPE_OUT);
-        $this->assertEquals(2, $this->redis->listRemove('mixed', -2, '_'));
-        $this->assertEquals(array(0, '_', 2, '_', 4, 6), $this->redis->listRange('mixed', 0, -1));
+        $this->assertEquals(2, $this->redis->lrem('mixed', -2, '_'));
+        $this->assertEquals(array(0, '_', 2, '_', 4, 6), $this->redis->lrange('mixed', 0, -1));
 
         RC::pushTailAndReturn($this->redis, 'mixed', $mixed, RC::WIPE_OUT);
-        $this->assertEquals(0, $this->redis->listRemove('mixed', 2, '|'));
-        $this->assertEquals($mixed, $this->redis->listRange('mixed', 0, -1));
+        $this->assertEquals(0, $this->redis->lrem('mixed', 2, '|'));
+        $this->assertEquals($mixed, $this->redis->lrange('mixed', 0, -1));
 
-        $this->assertEquals(0, $this->redis->listRemove('listDoesNotExist', 2, '_'));
+        $this->assertEquals(0, $this->redis->lrem('listDoesNotExist', 2, '_'));
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->listRemove('foo', 0, 0);
+            $test->redis->lrem('foo', 0, 0);
         });
     }
 
     function testListPopFirst() {
         $numbers = RC::pushTailAndReturn($this->redis, 'numbers', array(0, 1, 2, 3, 4));
 
-        $this->assertEquals(0, $this->redis->popFirst('numbers'));
-        $this->assertEquals(1, $this->redis->popFirst('numbers'));
-        $this->assertEquals(2, $this->redis->popFirst('numbers'));
+        $this->assertEquals(0, $this->redis->lpop('numbers'));
+        $this->assertEquals(1, $this->redis->lpop('numbers'));
+        $this->assertEquals(2, $this->redis->lpop('numbers'));
 
-        $this->assertEquals(array(3, 4), $this->redis->listRange('numbers', 0, -1));
+        $this->assertEquals(array(3, 4), $this->redis->lrange('numbers', 0, -1));
 
-        $this->redis->popFirst('numbers');
-        $this->redis->popFirst('numbers');
-        $this->assertNull($this->redis->popFirst('numbers'));
+        $this->redis->lpop('numbers');
+        $this->redis->lpop('numbers');
+        $this->assertNull($this->redis->lpop('numbers'));
 
-        $this->assertNull($this->redis->popFirst('numbers'));
+        $this->assertNull($this->redis->lpop('numbers'));
 
-        $this->assertNull($this->redis->popFirst('listDoesNotExist'));
+        $this->assertNull($this->redis->lpop('listDoesNotExist'));
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->popFirst('foo');
+            $test->redis->lpop('foo');
         });
     }
 
     function testListPopLast() {
         $numbers = RC::pushTailAndReturn($this->redis, 'numbers', array(0, 1, 2, 3, 4));
 
-        $this->assertEquals(4, $this->redis->popLast('numbers'));
-        $this->assertEquals(3, $this->redis->popLast('numbers'));
-        $this->assertEquals(2, $this->redis->popLast('numbers'));
+        $this->assertEquals(4, $this->redis->rpop('numbers'));
+        $this->assertEquals(3, $this->redis->rpop('numbers'));
+        $this->assertEquals(2, $this->redis->rpop('numbers'));
 
-        $this->assertEquals(array(0, 1), $this->redis->listRange('numbers', 0, -1));
+        $this->assertEquals(array(0, 1), $this->redis->lrange('numbers', 0, -1));
 
-        $this->redis->popLast('numbers');
-        $this->redis->popLast('numbers');
-        $this->assertNull($this->redis->popLast('numbers'));
+        $this->redis->rpop('numbers');
+        $this->redis->rpop('numbers');
+        $this->assertNull($this->redis->rpop('numbers'));
 
-        $this->assertNull($this->redis->popLast('numbers'));
+        $this->assertNull($this->redis->rpop('numbers'));
 
-        $this->assertNull($this->redis->popLast('listDoesNotExist'));
+        $this->assertNull($this->redis->rpop('listDoesNotExist'));
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->popLast('foo');
+            $test->redis->rpop('foo');
         });
     }
 
 
     function testListPopLastPushHead() {
         $numbers = RC::pushTailAndReturn($this->redis, 'numbers', array(0, 1, 2));
-        $this->assertEquals(0, $this->redis->listLength('temporary'));
-        $this->assertEquals(2, $this->redis->listPopLastPushHead('numbers', 'temporary'));
-        $this->assertEquals(1, $this->redis->listPopLastPushHead('numbers', 'temporary'));
-        $this->assertEquals(0, $this->redis->listPopLastPushHead('numbers', 'temporary'));
-        $this->assertEquals(0, $this->redis->listLength('numbers'));
-        $this->assertEquals(3, $this->redis->listLength('temporary'));
-        $this->assertEquals(array(), $this->redis->listRange('numbers', 0, -1));
-        $this->assertEquals($numbers, $this->redis->listRange('temporary', 0, -1));
+        $this->assertEquals(0, $this->redis->llen('temporary'));
+        $this->assertEquals(2, $this->redis->rpoplpush('numbers', 'temporary'));
+        $this->assertEquals(1, $this->redis->rpoplpush('numbers', 'temporary'));
+        $this->assertEquals(0, $this->redis->rpoplpush('numbers', 'temporary'));
+        $this->assertEquals(0, $this->redis->llen('numbers'));
+        $this->assertEquals(3, $this->redis->llen('temporary'));
+        $this->assertEquals(array(), $this->redis->lrange('numbers', 0, -1));
+        $this->assertEquals($numbers, $this->redis->lrange('temporary', 0, -1));
 
         $numbers = RC::pushTailAndReturn($this->redis, 'numbers', array(0, 1, 2));
-        $this->redis->listPopLastPushHead('numbers', 'numbers');
-        $this->redis->listPopLastPushHead('numbers', 'numbers');
-        $this->redis->listPopLastPushHead('numbers', 'numbers');
-        $this->assertEquals($numbers, $this->redis->listRange('numbers', 0, -1));
+        $this->redis->rpoplpush('numbers', 'numbers');
+        $this->redis->rpoplpush('numbers', 'numbers');
+        $this->redis->rpoplpush('numbers', 'numbers');
+        $this->assertEquals($numbers, $this->redis->lrange('numbers', 0, -1));
 
-        $this->assertNull($this->redis->listPopLastPushHead('listDoesNotExist1', 'listDoesNotExist2'));
+        $this->assertNull($this->redis->rpoplpush('listDoesNotExist1', 'listDoesNotExist2'));
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->listPopLastPushHead('foo', 'hoge');
+            $test->redis->rpoplpush('foo', 'hoge');
         });
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->listPopLastPushHead('temporary', 'foo');
+            $test->redis->rpoplpush('temporary', 'foo');
         });
     }
 
@@ -663,39 +663,39 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
     /* commands operating on sets */
 
     function testSetAdd() {
-        $this->assertTrue($this->redis->setAdd('set', 0));
-        $this->assertTrue($this->redis->setAdd('set', 1));
-        $this->assertFalse($this->redis->setAdd('set', 0));
+        $this->assertTrue($this->redis->sadd('set', 0));
+        $this->assertTrue($this->redis->sadd('set', 1));
+        $this->assertFalse($this->redis->sadd('set', 0));
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->setAdd('foo', 0);
+            $test->redis->sadd('foo', 0);
         });
     }
 
     function testSetRemove() {
         $set = RC::setAddAndReturn($this->redis, 'set', array(0, 1, 2, 3, 4));
 
-        $this->assertTrue($this->redis->setRemove('set', 0));
-        $this->assertTrue($this->redis->setRemove('set', 4));
-        $this->assertFalse($this->redis->setRemove('set', 10));
+        $this->assertTrue($this->redis->srem('set', 0));
+        $this->assertTrue($this->redis->srem('set', 4));
+        $this->assertFalse($this->redis->srem('set', 10));
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->setRemove('foo', 0);
+            $test->redis->srem('foo', 0);
         });
     }
 
     function testSetPop() {
         $set = RC::setAddAndReturn($this->redis, 'set', array(0, 1, 2, 3, 4));
 
-        $this->assertTrue(in_array($this->redis->setPop('set'), $set));
+        $this->assertTrue(in_array($this->redis->spop('set'), $set));
 
-        $this->assertNull($this->redis->setPop('setDoesNotExist'));
+        $this->assertNull($this->redis->spop('setDoesNotExist'));
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->setPop('foo');
+            $test->redis->spop('foo');
         });
     }
 
@@ -703,69 +703,69 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
         $setA = RC::setAddAndReturn($this->redis, 'setA', array(0, 1, 2, 3, 4, 5));
         $setB = RC::setAddAndReturn($this->redis, 'setB', array(5, 6, 7, 8, 9, 10));
 
-        $this->assertTrue($this->redis->setMove('setA', 'setB', 0));
-        $this->assertFalse($this->redis->setRemove('setA', 0));
-        $this->assertTrue($this->redis->setRemove('setB', 0));
+        $this->assertTrue($this->redis->smove('setA', 'setB', 0));
+        $this->assertFalse($this->redis->srem('setA', 0));
+        $this->assertTrue($this->redis->srem('setB', 0));
 
-        $this->assertTrue($this->redis->setMove('setA', 'setB', 5));
-        $this->assertFalse($this->redis->setMove('setA', 'setB', 100));
+        $this->assertTrue($this->redis->smove('setA', 'setB', 5));
+        $this->assertFalse($this->redis->smove('setA', 'setB', 100));
 
         // wrong type
         $this->redis->set('foo', 'bar');
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
-            $test->redis->setMove('foo', 'setB', 5);
+            $test->redis->smove('foo', 'setB', 5);
         });
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
-            $test->redis->setMove('setA', 'foo', 5);
+            $test->redis->smove('setA', 'foo', 5);
         });
     }
 
     function testSetCardinality() {
         RC::setAddAndReturn($this->redis, 'setA', array(0, 1, 2, 3, 4, 5));
 
-        $this->assertEquals(6, $this->redis->setCardinality('setA'));
+        $this->assertEquals(6, $this->redis->scard('setA'));
 
         // empty set
-        $this->redis->setAdd('setB', 0);
-        $this->redis->setPop('setB');
-        $this->assertEquals(0, $this->redis->setCardinality('setB'));
+        $this->redis->sadd('setB', 0);
+        $this->redis->spop('setB');
+        $this->assertEquals(0, $this->redis->scard('setB'));
 
         // non-existing set
-        $this->assertEquals(0, $this->redis->setCardinality('setDoesNotExist'));
+        $this->assertEquals(0, $this->redis->scard('setDoesNotExist'));
 
         // wrong type
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->setCardinality('foo');
+            $test->redis->scard('foo');
         });
     }
 
     function testSetIsMember() {
         RC::setAddAndReturn($this->redis, 'set', array(0, 1, 2, 3, 4, 5));
 
-        $this->assertTrue($this->redis->setIsMember('set', 3));
-        $this->assertFalse($this->redis->setIsMember('set', 100));
+        $this->assertTrue($this->redis->sismember('set', 3));
+        $this->assertFalse($this->redis->sismember('set', 100));
 
-        $this->assertFalse($this->redis->setIsMember('setDoesNotExist', 0));
+        $this->assertFalse($this->redis->sismember('setDoesNotExist', 0));
 
         // wrong type
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->setIsMember('foo', 0);
+            $test->redis->sismember('foo', 0);
         });
     }
 
     function testSetMembers() {
         $set = RC::setAddAndReturn($this->redis, 'set', array(0, 1, 2, 3, 4, 5, 6));
 
-        $this->assertTrue(RC::sameValuesInArrays($set, $this->redis->setMembers('set')));
+        $this->assertTrue(RC::sameValuesInArrays($set, $this->redis->smembers('set')));
 
-        $this->assertEquals(array(), $this->redis->setMembers('setDoesNotExist'));
+        $this->assertEquals(array(), $this->redis->smembers('setDoesNotExist'));
 
         // wrong type
         $this->redis->set('foo', 'bar');
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
-            $test->redis->setMembers('foo');
+            $test->redis->smembers('foo');
         });
     }
 
@@ -775,23 +775,23 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
 
         $this->assertTrue(RC::sameValuesInArrays(
             $setA, 
-            $this->redis->setIntersection('setA')
+            $this->redis->sinter('setA')
         ));
 
         $this->assertTrue(RC::sameValuesInArrays(
             array_intersect($setA, $setB), 
-            $this->redis->setIntersection('setA', 'setB')
+            $this->redis->sinter('setA', 'setB')
         ));
 
-        $this->assertEquals(array(), $this->redis->setIntersection('setA', 'setDoesNotExist'));
+        $this->assertEquals(array(), $this->redis->sinter('setA', 'setDoesNotExist'));
 
         // wrong type
         $this->redis->set('foo', 'bar');
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
-            $test->redis->setIntersection('foo');
+            $test->redis->sinter('foo');
         });
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
-            $test->redis->setIntersection('setA', 'foo');
+            $test->redis->sinter('setA', 'foo');
         });
     }
 
@@ -799,31 +799,31 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
         $setA = RC::setAddAndReturn($this->redis, 'setA', array(0, 1, 2, 3, 4, 5, 6));
         $setB = RC::setAddAndReturn($this->redis, 'setB', array(1, 3, 4, 6, 9, 10));
 
-        $this->assertEquals(count($setA), $this->redis->setIntersectionStore('setC', 'setA'));
+        $this->assertEquals(count($setA), $this->redis->sinterstore('setC', 'setA'));
         $this->assertTrue(RC::sameValuesInArrays(
             $setA, 
-            $this->redis->setMembers('setC')
+            $this->redis->smembers('setC')
         ));
 
-        $this->redis->delete('setC');
-        $this->assertEquals(4, $this->redis->setIntersectionStore('setC', 'setA', 'setB'));
+        $this->redis->del('setC');
+        $this->assertEquals(4, $this->redis->sinterstore('setC', 'setA', 'setB'));
         $this->assertTrue(RC::sameValuesInArrays(
             array(1, 3, 4, 6), 
-            $this->redis->setMembers('setC')
+            $this->redis->smembers('setC')
         ));
 
-        $this->redis->delete('setC');
-        $this->assertEquals(array(), $this->redis->setIntersection('setC', 'setDoesNotExist'));
+        $this->redis->del('setC');
+        $this->assertEquals(array(), $this->redis->sinter('setC', 'setDoesNotExist'));
         $this->assertFalse($this->redis->exists('setC'));
 
         // existing keys are replaced by SINTERSTORE
         $this->redis->set('foo', 'bar');
-        $this->assertEquals(count($setA), $this->redis->setIntersectionStore('foo', 'setA'));
+        $this->assertEquals(count($setA), $this->redis->sinterstore('foo', 'setA'));
 
         // wrong type
         $this->redis->set('foo', 'bar');
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
-            $test->redis->setIntersectionStore('setA', 'foo');
+            $test->redis->sinterstore('setA', 'foo');
         });
     }
 
@@ -833,26 +833,26 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
 
         $this->assertTrue(RC::sameValuesInArrays(
             $setA, 
-            $this->redis->setUnion('setA')
+            $this->redis->sunion('setA')
         ));
 
         $this->assertTrue(RC::sameValuesInArrays(
             array_union($setA, $setB), 
-            $this->redis->setUnion('setA', 'setB')
+            $this->redis->sunion('setA', 'setB')
         ));
 
         $this->assertTrue(RC::sameValuesInArrays(
             $setA, 
-            $this->redis->setUnion('setA', 'setDoesNotExist')
+            $this->redis->sunion('setA', 'setDoesNotExist')
         ));
 
         // wrong type
         $this->redis->set('foo', 'bar');
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
-            $test->redis->setUnion('foo');
+            $test->redis->sunion('foo');
         });
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
-            $test->redis->setUnion('setA', 'foo');
+            $test->redis->sunion('setA', 'foo');
         });
     }
 
@@ -860,33 +860,33 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
         $setA = RC::setAddAndReturn($this->redis, 'setA', array(0, 1, 2, 3, 4, 5, 6));
         $setB = RC::setAddAndReturn($this->redis, 'setB', array(1, 3, 4, 6, 9, 10));
 
-        $this->assertEquals(count($setA), $this->redis->setUnionStore('setC', 'setA'));
+        $this->assertEquals(count($setA), $this->redis->sunionstore('setC', 'setA'));
         $this->assertTrue(RC::sameValuesInArrays(
             $setA, 
-            $this->redis->setMembers('setC')
+            $this->redis->smembers('setC')
         ));
 
-        $this->redis->delete('setC');
-        $this->assertEquals(9, $this->redis->setUnionStore('setC', 'setA', 'setB'));
+        $this->redis->del('setC');
+        $this->assertEquals(9, $this->redis->sunionstore('setC', 'setA', 'setB'));
         $this->assertTrue(RC::sameValuesInArrays(
             array_union($setA, $setB), 
-            $this->redis->setMembers('setC')
+            $this->redis->smembers('setC')
         ));
 
         // non-existing keys are considered empty sets
-        $this->redis->delete('setC');
-        $this->assertEquals(0, $this->redis->setUnionStore('setC', 'setDoesNotExist'));
+        $this->redis->del('setC');
+        $this->assertEquals(0, $this->redis->sunionstore('setC', 'setDoesNotExist'));
         $this->assertFalse($this->redis->exists('setC'));
-        $this->assertEquals(0, $this->redis->setCardinality('setC'));
+        $this->assertEquals(0, $this->redis->scard('setC'));
 
         // existing keys are replaced by SUNIONSTORE
         $this->redis->set('foo', 'bar');
-        $this->assertEquals(count($setA), $this->redis->setUnionStore('foo', 'setA'));
+        $this->assertEquals(count($setA), $this->redis->sunionstore('foo', 'setA'));
 
         // wrong type
         $this->redis->set('foo', 'bar');
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
-            $test->redis->setUnionStore('setA', 'foo');
+            $test->redis->sunionstore('setA', 'foo');
         });
     }
 
@@ -896,26 +896,26 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
 
         $this->assertTrue(RC::sameValuesInArrays(
             $setA, 
-            $this->redis->setDifference('setA')
+            $this->redis->sdiff('setA')
         ));
 
         $this->assertTrue(RC::sameValuesInArrays(
             array_diff($setA, $setB), 
-            $this->redis->setDifference('setA', 'setB')
+            $this->redis->sdiff('setA', 'setB')
         ));
 
         $this->assertTrue(RC::sameValuesInArrays(
             $setA, 
-            $this->redis->setDifference('setA', 'setDoesNotExist')
+            $this->redis->sdiff('setA', 'setDoesNotExist')
         ));
 
         // wrong type
         $this->redis->set('foo', 'bar');
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
-            $test->redis->setDifference('foo');
+            $test->redis->sdiff('foo');
         });
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
-            $test->redis->setDifference('setA', 'foo');
+            $test->redis->sdiff('setA', 'foo');
         });
     }
 
@@ -923,47 +923,47 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
         $setA = RC::setAddAndReturn($this->redis, 'setA', array(0, 1, 2, 3, 4, 5, 6));
         $setB = RC::setAddAndReturn($this->redis, 'setB', array(1, 3, 4, 6, 9, 10));
 
-        $this->assertEquals(count($setA), $this->redis->setDifferenceStore('setC', 'setA'));
+        $this->assertEquals(count($setA), $this->redis->sdiffstore('setC', 'setA'));
         $this->assertTrue(RC::sameValuesInArrays(
             $setA, 
-            $this->redis->setMembers('setC')
+            $this->redis->smembers('setC')
         ));
 
-        $this->redis->delete('setC');
-        $this->assertEquals(3, $this->redis->setDifferenceStore('setC', 'setA', 'setB'));
+        $this->redis->del('setC');
+        $this->assertEquals(3, $this->redis->sdiffstore('setC', 'setA', 'setB'));
         $this->assertTrue(RC::sameValuesInArrays(
             array_diff($setA, $setB), 
-            $this->redis->setMembers('setC')
+            $this->redis->smembers('setC')
         ));
 
         // non-existing keys are considered empty sets
-        $this->redis->delete('setC');
-        $this->assertEquals(0, $this->redis->setDifferenceStore('setC', 'setDoesNotExist'));
+        $this->redis->del('setC');
+        $this->assertEquals(0, $this->redis->sdiffstore('setC', 'setDoesNotExist'));
         $this->assertFalse($this->redis->exists('setC'));
-        $this->assertEquals(0, $this->redis->setCardinality('setC'));
+        $this->assertEquals(0, $this->redis->scard('setC'));
 
         // existing keys are replaced by SDIFFSTORE
         $this->redis->set('foo', 'bar');
-        $this->assertEquals(count($setA), $this->redis->setDifferenceStore('foo', 'setA'));
+        $this->assertEquals(count($setA), $this->redis->sdiffstore('foo', 'setA'));
 
         // wrong type
         $this->redis->set('foo', 'bar');
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
-            $test->redis->setDifferenceStore('setA', 'foo');
+            $test->redis->sdiffstore('setA', 'foo');
         });
     }
 
     function testRandomMember() {
         $set = RC::setAddAndReturn($this->redis, 'set', array(0, 1, 2, 3, 4, 5, 6));
 
-        $this->assertTrue(in_array($this->redis->setRandomMember('set'), $set));
+        $this->assertTrue(in_array($this->redis->srandmember('set'), $set));
 
-        $this->assertNull($this->redis->setRandomMember('setDoesNotExist'));
+        $this->assertNull($this->redis->srandmember('setDoesNotExist'));
 
         // wrong type
         $this->redis->set('foo', 'bar');
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
-            $test->redis->setRandomMember('foo');
+            $test->redis->srandmember('foo');
         });
     }
 
@@ -971,53 +971,53 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
     /* commands operating on sorted sets */
 
     function testZsetAdd() {
-        $this->assertTrue($this->redis->zsetAdd('zset', 0, 'a'));
-        $this->assertTrue($this->redis->zsetAdd('zset', 1, 'b'));
+        $this->assertTrue($this->redis->zadd('zset', 0, 'a'));
+        $this->assertTrue($this->redis->zadd('zset', 1, 'b'));
 
-        $this->assertTrue($this->redis->zsetAdd('zset', -1, 'c'));
+        $this->assertTrue($this->redis->zadd('zset', -1, 'c'));
 
         // TODO: floats?
-        //$this->assertTrue($this->redis->zsetAdd('zset', -1.0, 'c'));
-        //$this->assertTrue($this->redis->zsetAdd('zset', -1.0, 'c'));
+        //$this->assertTrue($this->redis->zadd('zset', -1.0, 'c'));
+        //$this->assertTrue($this->redis->zadd('zset', -1.0, 'c'));
 
-        $this->assertFalse($this->redis->zsetAdd('zset', 2, 'b'));
-        $this->assertFalse($this->redis->zsetAdd('zset', -2, 'b'));
+        $this->assertFalse($this->redis->zadd('zset', 2, 'b'));
+        $this->assertFalse($this->redis->zadd('zset', -2, 'b'));
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->zsetAdd('foo', 0, 'a');
+            $test->redis->zadd('foo', 0, 'a');
         });
     }
 
     function testZsetIncrementBy() {
-        $this->assertEquals(1, $this->redis->zsetIncrementBy('zsetDoesNotExist', 1, 'foo'));
+        $this->assertEquals(1, $this->redis->zincrby('zsetDoesNotExist', 1, 'foo'));
         $this->assertEquals('zset', $this->redis->type('zsetDoesNotExist'));
 
         RC::zsetAddAndReturn($this->redis, 'zset', RC::getZSetArray());
-        $this->assertEquals(-5, $this->redis->zsetIncrementBy('zset', 5, 'a'));
-        $this->assertEquals(1, $this->redis->zsetIncrementBy('zset', 1, 'b'));
-        $this->assertEquals(10, $this->redis->zsetIncrementBy('zset', 0, 'c'));
-        $this->assertEquals(0, $this->redis->zsetIncrementBy('zset', -20, 'd'));
-        $this->assertEquals(2, $this->redis->zsetIncrementBy('zset', 2, 'd'));
-        $this->assertEquals(-10, $this->redis->zsetIncrementBy('zset', -30, 'e'));
-        $this->assertEquals(1, $this->redis->zsetIncrementBy('zset', 1, 'x'));
+        $this->assertEquals(-5, $this->redis->zincrby('zset', 5, 'a'));
+        $this->assertEquals(1, $this->redis->zincrby('zset', 1, 'b'));
+        $this->assertEquals(10, $this->redis->zincrby('zset', 0, 'c'));
+        $this->assertEquals(0, $this->redis->zincrby('zset', -20, 'd'));
+        $this->assertEquals(2, $this->redis->zincrby('zset', 2, 'd'));
+        $this->assertEquals(-10, $this->redis->zincrby('zset', -30, 'e'));
+        $this->assertEquals(1, $this->redis->zincrby('zset', 1, 'x'));
 
         // wrong type
         $this->redis->set('foo', 'bar');
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
-            $test->redis->zsetIncrementBy('foo', 1, 'a');
+            $test->redis->zincrby('foo', 1, 'a');
         });
     }
 
     function testZsetRemove() {
         RC::zsetAddAndReturn($this->redis, 'zset', RC::getZSetArray());
         
-        $this->assertTrue($this->redis->zsetRemove('zset', 'a'));
-        $this->assertFalse($this->redis->zsetRemove('zset', 'x'));
+        $this->assertTrue($this->redis->zrem('zset', 'a'));
+        $this->assertFalse($this->redis->zrem('zset', 'x'));
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->zsetRemove('foo', 'bar');
+            $test->redis->zrem('foo', 'bar');
         });
     }
 
@@ -1026,57 +1026,57 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
 
         $this->assertEquals(
             array_slice(array_keys($zset), 0, 4), 
-            $this->redis->zsetRange('zset', 0, 3)
+            $this->redis->zrange('zset', 0, 3)
         );
 
         $this->assertEquals(
             array_slice(array_keys($zset), 0, 1), 
-            $this->redis->zsetRange('zset', 0, 0)
+            $this->redis->zrange('zset', 0, 0)
         );
 
         $this->assertEquals(
             array(), 
-            $this->redis->zsetRange('zset', 1, 0)
+            $this->redis->zrange('zset', 1, 0)
         );
 
         $this->assertEquals(
             array_values(array_keys($zset)), 
-            $this->redis->zsetRange('zset', 0, -1)
+            $this->redis->zrange('zset', 0, -1)
         );
 
         $this->assertEquals(
             array_slice(array_keys($zset), 3, 1), 
-            $this->redis->zsetRange('zset', 3, -3)
+            $this->redis->zrange('zset', 3, -3)
         );
 
         $this->assertEquals(
             array(), 
-            $this->redis->zsetRange('zset', 5, -3)
+            $this->redis->zrange('zset', 5, -3)
         );
 
         $this->assertEquals(
             array_slice(array_keys($zset), -5, -1), 
-            $this->redis->zsetRange('zset', -5, -2)
+            $this->redis->zrange('zset', -5, -2)
         );
 
         $this->assertEquals(
             array_values(array_keys($zset)), 
-            $this->redis->zsetRange('zset', -100, 100)
+            $this->redis->zrange('zset', -100, 100)
         );
 
         $this->assertEquals(
             array_values(array_keys($zset)), 
-            $this->redis->zsetRange('zset', -100, 100)
+            $this->redis->zrange('zset', -100, 100)
         );
 
         $this->assertEquals(
             array(array('a', -10), array('b', 0), array('c', 10)), 
-            $this->redis->zsetRange('zset', 0, 2, 'withscores')
+            $this->redis->zrange('zset', 0, 2, 'withscores')
         );
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->zsetRange('foo', 0, -1);
+            $test->redis->zrange('foo', 0, -1);
         });
     }
 
@@ -1085,52 +1085,52 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
 
         $this->assertEquals(
             array_slice(array_reverse(array_keys($zset)), 0, 4), 
-            $this->redis->zsetReverseRange('zset', 0, 3)
+            $this->redis->zrevrange('zset', 0, 3)
         );
 
         $this->assertEquals(
             array_slice(array_reverse(array_keys($zset)), 0, 1), 
-            $this->redis->zsetReverseRange('zset', 0, 0)
+            $this->redis->zrevrange('zset', 0, 0)
         );
 
         $this->assertEquals(
             array(), 
-            $this->redis->zsetReverseRange('zset', 1, 0)
+            $this->redis->zrevrange('zset', 1, 0)
         );
 
         $this->assertEquals(
             array_values(array_reverse(array_keys($zset))), 
-            $this->redis->zsetReverseRange('zset', 0, -1)
+            $this->redis->zrevrange('zset', 0, -1)
         );
 
         $this->assertEquals(
             array_slice(array_reverse(array_keys($zset)), 3, 1), 
-            $this->redis->zsetReverseRange('zset', 3, -3)
+            $this->redis->zrevrange('zset', 3, -3)
         );
 
         $this->assertEquals(
             array(), 
-            $this->redis->zsetReverseRange('zset', 5, -3)
+            $this->redis->zrevrange('zset', 5, -3)
         );
 
         $this->assertEquals(
             array_slice(array_reverse(array_keys($zset)), -5, -1), 
-            $this->redis->zsetReverseRange('zset', -5, -2)
+            $this->redis->zrevrange('zset', -5, -2)
         );
 
         $this->assertEquals(
             array_values(array_reverse(array_keys($zset))), 
-            $this->redis->zsetReverseRange('zset', -100, 100)
+            $this->redis->zrevrange('zset', -100, 100)
         );
 
         $this->assertEquals(
             array(array('f', 30), array('e', 20), array('d', 20)), 
-            $this->redis->zsetReverseRange('zset', 0, 2, 'withscores')
+            $this->redis->zrevrange('zset', 0, 2, 'withscores')
         );
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->zsetReverseRange('foo', 0, -1);
+            $test->redis->zrevrange('foo', 0, -1);
         });
     }
 
@@ -1139,148 +1139,148 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
 
         $this->assertEquals(
             array('a'), 
-            $this->redis->zsetRangeByScore('zset', -10, -10)
+            $this->redis->zrangebyscore('zset', -10, -10)
         );
 
         $this->assertEquals(
             array('c', 'd', 'e', 'f'), 
-            $this->redis->zsetRangeByScore('zset', 10, 30)
+            $this->redis->zrangebyscore('zset', 10, 30)
         );
 
         $this->assertEquals(
             array('d', 'e'), 
-            $this->redis->zsetRangeByScore('zset', 20, 20)
+            $this->redis->zrangebyscore('zset', 20, 20)
         );
 
         $this->assertEquals(
             array(), 
-            $this->redis->zsetRangeByScore('zset', 30, 0)
+            $this->redis->zrangebyscore('zset', 30, 0)
         );
 
         $this->assertEquals(
             array(array('c', 10), array('d', 20), array('e', 20)), 
-            $this->redis->zsetRangeByScore('zset', 10, 20, 'withscores')
+            $this->redis->zrangebyscore('zset', 10, 20, 'withscores')
         );
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->zsetRangeByScore('foo', 0, 0);
+            $test->redis->zrangebyscore('foo', 0, 0);
         });
     }
 
     function testZsetCount() {
         $zset = RC::zsetAddAndReturn($this->redis, 'zset', RC::getZSetArray());
 
-        $this->assertEquals(0, $this->redis->zsetCount('zset', 50, 100));
-        $this->assertEquals(6, $this->redis->zsetCount('zset', -100, 100));
-        $this->assertEquals(3, $this->redis->zsetCount('zset', 10, 20));
-        $this->assertEquals(2, $this->redis->zsetCount('zset', "(10", 20));
-        $this->assertEquals(1, $this->redis->zsetCount('zset', 10, "(20"));
-        $this->assertEquals(0, $this->redis->zsetCount('zset', "(10", "(20"));
-        $this->assertEquals(3, $this->redis->zsetCount('zset', "(0", "(30"));
+        $this->assertEquals(0, $this->redis->zcount('zset', 50, 100));
+        $this->assertEquals(6, $this->redis->zcount('zset', -100, 100));
+        $this->assertEquals(3, $this->redis->zcount('zset', 10, 20));
+        $this->assertEquals(2, $this->redis->zcount('zset', "(10", 20));
+        $this->assertEquals(1, $this->redis->zcount('zset', 10, "(20"));
+        $this->assertEquals(0, $this->redis->zcount('zset', "(10", "(20"));
+        $this->assertEquals(3, $this->redis->zcount('zset', "(0", "(30"));
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->zsetCount('foo', 0, 0);
+            $test->redis->zcount('foo', 0, 0);
         });
     }
 
     function testZsetCardinality() {
         $zset = RC::zsetAddAndReturn($this->redis, 'zset', RC::getZSetArray());
 
-        $this->assertEquals(count($zset), $this->redis->zsetCardinality('zset'));
+        $this->assertEquals(count($zset), $this->redis->zcard('zset'));
         
-        $this->redis->zsetRemove('zset', 'a');
-        $this->assertEquals(count($zset) - 1, $this->redis->zsetCardinality('zset'));
+        $this->redis->zrem('zset', 'a');
+        $this->assertEquals(count($zset) - 1, $this->redis->zcard('zset'));
 
         // empty zset
-        $this->redis->zsetAdd('zsetB', 0, 'a');
-        $this->redis->zsetRemove('zsetB', 'a');
-        $this->assertEquals(0, $this->redis->zsetCardinality('setB'));
+        $this->redis->zadd('zsetB', 0, 'a');
+        $this->redis->zrem('zsetB', 'a');
+        $this->assertEquals(0, $this->redis->zcard('setB'));
 
         // non-existing zset
-        $this->assertEquals(0, $this->redis->zsetCardinality('zsetDoesNotExist'));
+        $this->assertEquals(0, $this->redis->zcard('zsetDoesNotExist'));
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->zsetCardinality('foo');
+            $test->redis->zcard('foo');
         });
     }
 
     function testZsetScore() {
         $zset = RC::zsetAddAndReturn($this->redis, 'zset', RC::getZSetArray());
 
-        $this->assertEquals(-10, $this->redis->zsetScore('zset', 'a'));
-        $this->assertEquals(10, $this->redis->zsetScore('zset', 'c'));
-        $this->assertEquals(20, $this->redis->zsetScore('zset', 'e'));
+        $this->assertEquals(-10, $this->redis->zscore('zset', 'a'));
+        $this->assertEquals(10, $this->redis->zscore('zset', 'c'));
+        $this->assertEquals(20, $this->redis->zscore('zset', 'e'));
 
-        $this->assertNull($this->redis->zsetScore('zset', 'x'));
-        $this->assertNull($this->redis->zsetScore('zsetDoesNotExist', 'a'));
+        $this->assertNull($this->redis->zscore('zset', 'x'));
+        $this->assertNull($this->redis->zscore('zsetDoesNotExist', 'a'));
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->zsetScore('foo', 'bar');
+            $test->redis->zscore('foo', 'bar');
         });
     }
 
     function testZsetRemoveRangeByScore() {
         $zset = RC::zsetAddAndReturn($this->redis, 'zset', RC::getZSetArray());
 
-        $this->assertEquals(2, $this->redis->zsetRemoveRangeByScore('zset', -10, 0));
+        $this->assertEquals(2, $this->redis->zremrangebyscore('zset', -10, 0));
         $this->assertEquals(
             array('c', 'd', 'e', 'f'), 
-            $this->redis->zsetRange('zset', 0, -1)
+            $this->redis->zrange('zset', 0, -1)
         );
 
-        $this->assertEquals(1, $this->redis->zsetRemoveRangeByScore('zset', 10, 10));
+        $this->assertEquals(1, $this->redis->zremrangebyscore('zset', 10, 10));
         $this->assertEquals(
             array('d', 'e', 'f'), 
-            $this->redis->zsetRange('zset', 0, -1)
+            $this->redis->zrange('zset', 0, -1)
         );
 
-        $this->assertEquals(0, $this->redis->zsetRemoveRangeByScore('zset', 100, 100));
+        $this->assertEquals(0, $this->redis->zremrangebyscore('zset', 100, 100));
 
-        $this->assertEquals(3, $this->redis->zsetRemoveRangeByScore('zset', 0, 100));
-        $this->assertEquals(0, $this->redis->zsetRemoveRangeByScore('zset', 0, 100));
+        $this->assertEquals(3, $this->redis->zremrangebyscore('zset', 0, 100));
+        $this->assertEquals(0, $this->redis->zremrangebyscore('zset', 0, 100));
 
-        $this->assertEquals(0, $this->redis->zsetRemoveRangeByScore('zsetDoesNotExist', 0, 100));
+        $this->assertEquals(0, $this->redis->zremrangebyscore('zsetDoesNotExist', 0, 100));
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->zsetRemoveRangeByScore('foo', 0, 0);
+            $test->redis->zremrangebyscore('foo', 0, 0);
         });
     }
 
     function testZrank() {
         $zset = RC::zsetAddAndReturn($this->redis, 'zset', RC::getZSetArray());
 
-        $this->assertEquals(0, $this->redis->zsetRank('zset', 'a'));
-        $this->assertEquals(1, $this->redis->zsetRank('zset', 'b'));
-        $this->assertEquals(4, $this->redis->zsetRank('zset', 'e'));
+        $this->assertEquals(0, $this->redis->zrank('zset', 'a'));
+        $this->assertEquals(1, $this->redis->zrank('zset', 'b'));
+        $this->assertEquals(4, $this->redis->zrank('zset', 'e'));
 
-        $this->redis->zsetRemove('zset', 'd');
-        $this->assertEquals(3, $this->redis->zsetRank('zset', 'e'));
+        $this->redis->zrem('zset', 'd');
+        $this->assertEquals(3, $this->redis->zrank('zset', 'e'));
 
-        $this->assertNull($this->redis->zsetRank('zset', 'x'));
+        $this->assertNull($this->redis->zrank('zset', 'x'));
 
         RC::testForServerException($this, RC::EXCEPTION_WRONG_TYPE, function($test) {
             $test->redis->set('foo', 'bar');
-            $test->redis->zsetRank('foo', 'a');
+            $test->redis->zrank('foo', 'a');
         });
     }
 
     /* multiple databases handling commands */
 
     function testSelectDatabase() {
-        $this->assertTrue($this->redis->selectDatabase(0));
-        $this->assertTrue($this->redis->selectDatabase(RC::DEFAULT_DATABASE));
+        $this->assertTrue($this->redis->select(0));
+        $this->assertTrue($this->redis->select(RC::DEFAULT_DATABASE));
 
         RC::testForServerException($this, RC::EXCEPTION_INVALID_DB_IDX, function($test) {
-            $test->redis->selectDatabase(32);
+            $test->redis->select(32);
         });
 
         RC::testForServerException($this, RC::EXCEPTION_INVALID_DB_IDX, function($test) {
-            $test->redis->selectDatabase(-1);
+            $test->redis->select(-1);
         });
     }
 
@@ -1289,9 +1289,9 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
         $otherDb = 5;
         $this->redis->set('foo', 'bar');
 
-        $this->redis->selectDatabase($otherDb);
-        $this->redis->flushDatabase();
-        $this->redis->selectDatabase(RC::DEFAULT_DATABASE);
+        $this->redis->select($otherDb);
+        $this->redis->flushdb();
+        $this->redis->select(RC::DEFAULT_DATABASE);
 
         $this->assertTrue($this->redis->move('foo', $otherDb));
         $this->assertFalse($this->redis->move('foo', $otherDb));
@@ -1304,14 +1304,14 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
         });
     }
 
-    function testFlushDatabase() {
-        $this->assertTrue($this->redis->flushDatabase());
+    function testFlushdb() {
+        $this->assertTrue($this->redis->flushdb());
     }
 
 
     /* sorting */
 
-    function testSort() {
+    function __testSort() {
         $unorderedList = RC::pushTailAndReturn($this->redis, 'unordered', array(2, 100, 3, 1, 30, 10));
 
         // without parameters
@@ -1372,18 +1372,18 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
                 'store' => 'ordered'
             ))
         );
-        $this->assertEquals(array(1, 2, 3, 10, 30, 100),  $this->redis->listRange('ordered', 0, -1));
+        $this->assertEquals(array(1, 2, 3, 10, 30, 100),  $this->redis->lrange('ordered', 0, -1));
 
         // with parameter GET
-        $this->redis->pushTail('uids', 1003);
-        $this->redis->pushTail('uids', 1001);
-        $this->redis->pushTail('uids', 1002);
-        $this->redis->pushTail('uids', 1000);
+        $this->redis->rpush('uids', 1003);
+        $this->redis->rpush('uids', 1001);
+        $this->redis->rpush('uids', 1002);
+        $this->redis->rpush('uids', 1000);
         $sortget = array(
             'uid:1000' => 'foo',  'uid:1001' => 'bar', 
             'uid:1002' => 'hoge', 'uid:1003' => 'piyo'
         );
-        $this->redis->setMultiple($sortget);
+        $this->redis->mset($sortget);
         $this->assertEquals(
             array_values($sortget), 
             $this->redis->sort('uids', array('get' => 'uid:*'))
@@ -1411,19 +1411,19 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
         $masterHost = 'www.google.com';
         $masterPort = 80;
 
-        $this->assertTrue($this->redis->slaveOf($masterHost, $masterPort));
+        $this->assertTrue($this->redis->slaveof($masterHost, $masterPort));
         $serverInfo = $this->redis->info();
         $this->assertEquals('slave', $serverInfo['role']);
         $this->assertEquals($masterHost, $serverInfo['master_host']);
         $this->assertEquals($masterPort, $serverInfo['master_port']);
 
         // slave of NO ONE, the implicit way
-        $this->assertTrue($this->redis->slaveOf());
+        $this->assertTrue($this->redis->slaveof());
         $serverInfo = $this->redis->info();
         $this->assertEquals('master', $serverInfo['role']);
 
         // slave of NO ONE, the explicit way
-        $this->assertTrue($this->redis->slaveOf('NO ONE'));
+        $this->assertTrue($this->redis->slaveof('NO ONE'));
     }
 
 
@@ -1434,24 +1434,15 @@ class RedisCommandTestSuite extends PHPUnit_Framework_TestCase {
     }
 
     function testBackgroundSave() {
-        $this->assertTrue($this->redis->backgroundSave());
+        $this->assertTrue($this->redis->bgsave());
     }
 
     function testBackgroundRewriteAppendOnlyFile() {
-        $this->assertTrue($this->redis->backgroundRewriteAppendOnlyFile());
+        $this->assertTrue($this->redis->bgrewriteaof());
     }
 
     function testLastSave() {
-        $this->assertGreaterThan(0, $this->redis->lastSave());
-    }
-
-    function testShutdown() {
-        // TODO: seriously, we even test shutdown?
-        /*
-        $this->assertNull($this->redis->shutdown());
-        sleep(1);
-        $this->assertFalse($this->redis->isConnected());
-        */
+        $this->assertGreaterThan(0, $this->redis->lastsave());
     }
 }
 ?>