<?php defined('PHPREDIS_TESTRUN') or die("Use TestRedis.php to run tests!\n");

require_once(dirname($_SERVER['PHP_SELF'])."/TestSuite.php");

class Redis_Test extends TestSuite

{

const PORT = 6379;

const AUTH = NULL; //replace with a string to use Redis authentication

/**

* @var Redis

*/

public $redis;

public function setUp() {

$this->redis = $this->newInstance();

$info = $this->redis->info();

$this->version = (isset($info['redis_version'])?$info['redis_version']:'0.0.0');

}

protected function newInstance() {

$r = new Redis();

$r->connect($this->getHost(), self::PORT);

if(self::AUTH) {

$this->assertTrue($r->auth(self::AUTH));

}

return $r;

}

public function tearDown() {

if($this->redis) {

$this->redis->close();

}

}

public function reset()

{

$this->setUp();

$this->tearDown();

}

/* Helper function to determine if the clsas has pipeline support */

protected function havePipeline() {

$str_constant = get_class($this->redis) . '::PIPELINE';

return defined($str_constant);

}

public function testMinimumVersion()

{

// Minimum server version required for tests

$this->assertTrue(version_compare($this->version, "2.4.0", "ge"));

}

public function testPing()

{

$this->assertEquals('+PONG', $this->redis->ping());

$count = 1000;

while($count --) {

$this->assertEquals('+PONG', $this->redis->ping());

}

}

public function testPipelinePublish() {

if (!$this->havePipeline()) {

$this->markTestSkipped();

}

$ret = $this->redis->pipeline()

->publish('chan', 'msg')

->exec();

$this->assertTrue(is_array($ret) && count($ret) === 1 && $ret[0] >= 0);

}

// Run some simple tests against the PUBSUB command. This is problematic, as we

// can't be sure what's going on in the instance, but we can do some things.

public function testPubSub() {

// Only available since 2.8.0

if(version_compare($this->version, "2.8.0", "lt")) {

$this->markTestSkipped();

return;

}

// PUBSUB CHANNELS ...

$result = $this->redis->pubsub("channels", "*");

$this->assertTrue(is_array($result));

$result = $this->redis->pubsub("channels");

$this->assertTrue(is_array($result));

// PUBSUB NUMSUB

$c1 = uniqid() . '-' . rand(1,100);

$c2 = uniqid() . '-' . rand(1,100);

$result = $this->redis->pubsub("numsub", Array($c1, $c2));

// Should get an array back, with two elements

$this->assertTrue(is_array($result));

$this->assertEquals(count($result), 2);

// Make sure the elements are correct, and have zero counts

foreach(Array($c1,$c2) as $channel) {

$this->assertTrue(isset($result[$channel]));

$this->assertEquals($result[$channel], 0);

}

// PUBSUB NUMPAT

$result = $this->redis->pubsub("numpat");

$this->assertTrue(is_int($result));

// Invalid calls

$this->assertFalse($this->redis->pubsub("notacommand"));

$this->assertFalse($this->redis->pubsub("numsub", "not-an-array"));

}

public function testBitsets() {

$this->redis->del('key');

$this->assertEquals(0, $this->redis->getBit('key', 0));

$this->assertEquals(FALSE, $this->redis->getBit('key', -1));

$this->assertEquals(0, $this->redis->getBit('key', 100000));

$this->redis->set('key', "\xff");

for($i = 0; $i < 8; $i++) {

$this->assertEquals(1, $this->redis->getBit('key', $i));

}

$this->assertEquals(0, $this->redis->getBit('key', 8));

// change bit 0

$this->assertEquals(1, $this->redis->setBit('key', 0, 0));

$this->assertEquals(0, $this->redis->setBit('key', 0, 0));

$this->assertEquals(0, $this->redis->getBit('key', 0));

$this->assertEquals("\x7f", $this->redis->get('key'));

// change bit 1

$this->assertEquals(1, $this->redis->setBit('key', 1, 0));

$this->assertEquals(0, $this->redis->setBit('key', 1, 0));

$this->assertEquals(0, $this->redis->getBit('key', 1));

$this->assertEquals("\x3f", $this->redis->get('key'));

// change bit > 1

$this->assertEquals(1, $this->redis->setBit('key', 2, 0));

$this->assertEquals(0, $this->redis->setBit('key', 2, 0));

$this->assertEquals(0, $this->redis->getBit('key', 2));

$this->assertEquals("\x1f", $this->redis->get('key'));

// values above 1 are changed to 1 but don't overflow on bits to the right.

$this->assertEquals(0, $this->redis->setBit('key', 0, 0xff));

$this->assertEquals("\x9f", $this->redis->get('key'));

// Verify valid offset ranges

$this->assertFalse($this->redis->getBit('key', -1));

$this->redis->setBit('key', ((2^32)-1), 1);

$this->assertEquals(1, $this->redis->getBit('key', ((2^32)-1)));

}

public function testBitPos() {

if(version_compare($this->version, "2.8.7", "lt")) {

$this->MarkTestSkipped();

return;

}

$this->redis->del('bpkey');

$this->redis->set('bpkey', "\xff\xf0\x00");

$this->assertEquals($this->redis->bitpos('bpkey', 0), 12);

$this->redis->set('bpkey', "\x00\xff\xf0");

$this->assertEquals($this->redis->bitpos('bpkey', 1, 0), 8);

$this->assertEquals($this->redis->bitpos('bpkey', 1, 1), 8);

$this->redis->set('bpkey', "\x00\x00\x00");

$this->assertEquals($this->redis->bitpos('bpkey', 1), -1);

}

public function test1000() {

$s = str_repeat('A', 1000);

$this->redis->set('x', $s);

$this->assertEquals($s, $this->redis->get('x'));

$s = str_repeat('A', 1000000);

$this->redis->set('x', $s);

$this->assertEquals($s, $this->redis->get('x'));

}

public function testEcho() {

$this->assertEquals($this->redis->echo("hello"), "hello");

$this->assertEquals($this->redis->echo(""), "");

$this->assertEquals($this->redis->echo(" 0123 "), " 0123 ");

}

public function testErr() {

$this->redis->set('x', '-ERR');

$this->assertEquals($this->redis->get('x'), '-ERR');

}

public function testSet()

{

$this->assertEquals(TRUE, $this->redis->set('key', 'nil'));

$this->assertEquals('nil', $this->redis->get('key'));

$this->assertEquals(TRUE, $this->redis->set('key', 'val'));

$this->assertEquals('val', $this->redis->get('key'));

$this->assertEquals('val', $this->redis->get('key'));

$this->redis->del('keyNotExist');

$this->assertEquals(FALSE, $this->redis->get('keyNotExist'));

$this->redis->set('key2', 'val');

$this->assertEquals('val', $this->redis->get('key2'));

$value = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA';

$this->redis->set('key2', $value);

$this->assertEquals($value, $this->redis->get('key2'));

$this->assertEquals($value, $this->redis->get('key2'));

$this->redis->del('key');

$this->redis->del('key2');

$i = 66000;

$value2 = 'X';

while($i--) {

$value2 .= 'A';

}

$value2 .= 'X';

$this->redis->set('key', $value2);

$this->assertEquals($value2, $this->redis->get('key'));

$this->redis->del('key');

$this->assertEquals(False, $this->redis->get('key'));

$data = gzcompress('42');

$this->assertEquals(True, $this->redis->set('key', $data));

$this->assertEquals('42', gzuncompress($this->redis->get('key')));

$this->redis->del('key');

$data = gzcompress('value1');

$this->assertEquals(True, $this->redis->set('key', $data));

$this->assertEquals('value1', gzuncompress($this->redis->get('key')));

$this->redis->del('key');

$this->assertEquals(TRUE, $this->redis->set('key', 0));

$this->assertEquals('0', $this->redis->get('key'));

$this->assertEquals(TRUE, $this->redis->set('key', 1));

$this->assertEquals('1', $this->redis->get('key'));

$this->assertEquals(TRUE, $this->redis->set('key', 0.1));

$this->assertEquals('0.1', $this->redis->get('key'));

$this->assertEquals(TRUE, $this->redis->set('key', '0.1'));

$this->assertEquals('0.1', $this->redis->get('key'));

$this->assertEquals(TRUE, $this->redis->set('key', TRUE));

$this->assertEquals('1', $this->redis->get('key'));

$this->assertEquals(True, $this->redis->set('key', ''));

$this->assertEquals('', $this->redis->get('key'));

$this->assertEquals(True, $this->redis->set('key', NULL));

$this->assertEquals('', $this->redis->get('key'));

$this->assertEquals(True, $this->redis->set('key', gzcompress('42')));

$this->assertEquals('42', gzuncompress($this->redis->get('key')));

}

/* Extended SET options for Redis >= 2.6.12 */

public function testExtendedSet() {

// Skip the test if we don't have a new enough version of Redis

if(version_compare($this->version, '2.6.12', 'lt')) {

$this->markTestSkipped();

return;

}

/* Legacy SETEX redirection */

$this->redis->del('foo');

$this->assertTrue($this->redis->set('foo','bar', 20));

$this->assertEquals($this->redis->get('foo'), 'bar');

$this->assertEquals($this->redis->ttl('foo'), 20);

/* Invalid third arguments */

$this->assertFalse($this->redis->set('foo','bar','baz'));

$this->assertFalse($this->redis->set('foo','bar',new StdClass()));

/* Set if not exist */

$this->redis->del('foo');

$this->assertTrue($this->redis->set('foo','bar',Array('nx')));

$this->assertEquals($this->redis->get('foo'), 'bar');

$this->assertFalse($this->redis->set('foo','bar',Array('nx')));

/* Set if exists */

$this->assertTrue($this->redis->set('foo','bar',Array('xx')));

$this->assertEquals($this->redis->get('foo'), 'bar');

$this->redis->del('foo');

$this->assertFalse($this->redis->set('foo','bar',Array('xx')));

/* Set with a TTL */

$this->assertTrue($this->redis->set('foo','bar',Array('ex'=>100)));

$this->assertEquals($this->redis->ttl('foo'), 100);

/* Set with a PTTL */

$this->assertTrue($this->redis->set('foo','bar',Array('px'=>100000)));

$this->assertTrue(100000 - $this->redis->pttl('foo') < 1000);

/* Set if exists, with a TTL */

$this->assertTrue($this->redis->set('foo','bar',Array('xx','ex'=>105)));

$this->assertEquals($this->redis->ttl('foo'), 105);

$this->assertEquals($this->redis->get('foo'), 'bar');

/* Set if not exists, with a TTL */

$this->redis->del('foo');

$this->assertTrue($this->redis->set('foo','bar', Array('nx', 'ex'=>110)));

$this->assertEquals($this->redis->ttl('foo'), 110);

$this->assertEquals($this->redis->get('foo'), 'bar');

$this->assertFalse($this->redis->set('foo','bar', Array('nx', 'ex'=>110)));

/* Throw some nonsense into the array, and check that the TTL came through */

$this->redis->del('foo');

$this->assertTrue($this->redis->set('foo','barbaz', Array('not-valid','nx','invalid','ex'=>200)));

$this->assertEquals($this->redis->ttl('foo'), 200);

$this->assertEquals($this->redis->get('foo'), 'barbaz');

/* Pass NULL as the optional arguments which should be ignored */

$this->redis->del('foo');

$this->redis->set('foo','bar', NULL);

$this->assertEquals($this->redis->get('foo'), 'bar');

$this->assertTrue($this->redis->ttl('foo')<0);

}

public function testGetSet() {

$this->redis->del('key');

$this->assertTrue($this->redis->getSet('key', '42') === FALSE);

$this->assertTrue($this->redis->getSet('key', '123') === '42');

$this->assertTrue($this->redis->getSet('key', '123') === '123');

}

public function testRandomKey() {

for($i = 0; $i < 1000; $i++) {

$k = $this->redis->randomKey();

$this->assertTrue($this->redis->exists($k));

}

}

public function testRename() {

// strings

$this->redis->del('{key}0');

$this->redis->set('{key}0', 'val0');

$this->redis->rename('{key}0', '{key}1');

$this->assertEquals(FALSE, $this->redis->get('{key}0'));

$this->assertEquals('val0', $this->redis->get('{key}1'));

}

public function testRenameNx() {

// strings

$this->redis->del('{key}0', '{key}1');

$this->redis->set('{key}0', 'val0');

$this->redis->set('{key}1', 'val1');

$this->assertTrue($this->redis->renameNx('{key}0', '{key}1') === FALSE);

$this->assertTrue($this->redis->get('{key}0') === 'val0');

$this->assertTrue($this->redis->get('{key}1') === 'val1');

// lists

$this->redis->del('{key}0');

$this->redis->del('{key}1');

$this->redis->lPush('{key}0', 'val0');

$this->redis->lPush('{key}0', 'val1');

$this->redis->lPush('{key}1', 'val1-0');

$this->redis->lPush('{key}1', 'val1-1');

$this->assertTrue($this->redis->renameNx('{key}0', '{key}1') === FALSE);

$this->assertTrue($this->redis->lRange('{key}0', 0, -1) === array('val1', 'val0'));

$this->assertTrue($this->redis->lRange('{key}1', 0, -1) === array('val1-1', 'val1-0'));

$this->redis->del('{key}2');

$this->assertTrue($this->redis->renameNx('{key}0', '{key}2') === TRUE);

$this->assertTrue($this->redis->lRange('{key}0', 0, -1) === array());

$this->assertTrue($this->redis->lRange('{key}2', 0, -1) === array('val1', 'val0'));

}

public function testMultiple() {

$this->redis->del('k1');

$this->redis->del('k2');

$this->redis->del('k3');

$this->redis->set('k1', 'v1');

$this->redis->set('k2', 'v2');

$this->redis->set('k3', 'v3');

$this->redis->set(1, 'test');

$this->assertEquals(array('v1'), $this->redis->mget(array('k1')));

$this->assertEquals(array('v1', 'v3', false), $this->redis->mget(array('k1', 'k3', 'NoKey')));

$this->assertEquals(array('v1', 'v2', 'v3'), $this->redis->mget(array('k1', 'k2', 'k3')));

$this->assertEquals(array('v1', 'v2', 'v3'), $this->redis->mget(array('k1', 'k2', 'k3')));

$this->redis->set('k5', '$1111111111');

$this->assertEquals(array(0 => '$1111111111'), $this->redis->mget(array('k5')));

$this->assertEquals(array(0 => 'test'), $this->redis->mget(array(1))); // non-string

}

public function testMultipleBin() {

$this->redis->del('k1');

$this->redis->del('k2');

$this->redis->del('k3');

$this->redis->set('k1', gzcompress('v1'));

$this->redis->set('k2', gzcompress('v2'));

$this->redis->set('k3', gzcompress('v3'));

$this->assertEquals(array(gzcompress('v1'), gzcompress('v2'), gzcompress('v3')), $this->redis->mget(array('k1', 'k2', 'k3')));

$this->assertEquals(array(gzcompress('v1'), gzcompress('v2'), gzcompress('v3')), $this->redis->mget(array('k1', 'k2', 'k3')));

}

public function testSetTimeout() {

$this->redis->del('key');

$this->redis->set('key', 'value');

$this->assertEquals('value', $this->redis->get('key'));

$this->redis->expire('key', 1);

$this->assertEquals('value', $this->redis->get('key'));

sleep(2);

$this->assertEquals(False, $this->redis->get('key'));

}

public function testExpireAt() {

$this->redis->del('key');

$this->redis->set('key', 'value');

$now = time(NULL);

$this->redis->expireAt('key', $now + 1);

$this->assertEquals('value', $this->redis->get('key'));

sleep(2);

$this->assertEquals(FALSE, $this->redis->get('key'));

}

public function testSetEx() {

$this->redis->del('key');

$this->assertTrue($this->redis->setex('key', 7, 'val') === TRUE);

$this->assertTrue($this->redis->ttl('key') ===7);

$this->assertTrue($this->redis->get('key') === 'val');

}

public function testSetNX() {

$this->redis->set('key', 42);

$this->assertTrue($this->redis->setnx('key', 'err') === FALSE);

$this->assertTrue($this->redis->get('key') === '42');

$this->redis->del('key');

$this->assertTrue($this->redis->setnx('key', '42') === TRUE);

$this->assertTrue($this->redis->get('key') === '42');

}

public function testExpireAtWithLong() {

$longExpiryTimeExceedingInt = 3153600000;

$this->redis->del('key');

$this->assertTrue($this->redis->setex('key', $longExpiryTimeExceedingInt, 'val') === TRUE);

$this->assertTrue($this->redis->ttl('key') === $longExpiryTimeExceedingInt);

}

public function testIncr()

{

$this->redis->set('key', 0);

$this->redis->incr('key');

$this->assertEquals(1, (int)$this->redis->get('key'));

$this->redis->incr('key');

$this->assertEquals(2, (int)$this->redis->get('key'));

$this->redis->incrBy('key', 3);

$this->assertEquals(5, (int)$this->redis->get('key'));

$this->redis->incrBy('key', 1);

$this->assertEquals(6, (int)$this->redis->get('key'));

$this->redis->incrBy('key', -1);

$this->assertEquals(5, (int)$this->redis->get('key'));

$this->redis->incr('key', 5);

$this->assertEquals(10, (int)$this->redis->get('key'));

$this->redis->del('key');

$this->redis->set('key', 'abc');

$this->redis->incr('key');

$this->assertTrue("abc" === $this->redis->get('key'));

$this->redis->incr('key');

$this->assertTrue("abc" === $this->redis->get('key'));

}

public function testIncrByFloat()

{

// incrbyfloat is new in 2.6.0

if (version_compare($this->version, "2.5.0", "lt")) {

$this->markTestSkipped();

}

$this->redis->del('key');

$this->redis->set('key', 0);

$this->redis->incrbyfloat('key', 1.5);

$this->assertEquals('1.5', $this->redis->get('key'));

$this->redis->incrbyfloat('key', 2.25);

$this->assertEquals('3.75', $this->redis->get('key'));

$this->redis->incrbyfloat('key', -2.25);

$this->assertEquals('1.5', $this->redis->get('key'));

$this->redis->set('key', 'abc');

$this->redis->incrbyfloat('key', 1.5);

$this->assertTrue("abc" === $this->redis->get('key'));

$this->redis->incrbyfloat('key', -1.5);

$this->assertTrue("abc" === $this->redis->get('key'));

// Test with prefixing

$this->redis->setOption(Redis::OPT_PREFIX, 'someprefix:');

$this->redis->del('key');

$this->redis->incrbyfloat('key',1.8);

$this->assertEquals('1.8', $this->redis->get('key'));

$this->redis->setOption(Redis::OPT_PREFIX, '');

$this->assertTrue($this->redis->exists('someprefix:key'));

$this->redis->del('someprefix:key');

}

public function testDecr()

{

$this->redis->set('key', 5);

$this->redis->decr('key');

$this->assertEquals(4, (int)$this->redis->get('key'));

$this->redis->decr('key');

$this->assertEquals(3, (int)$this->redis->get('key'));

$this->redis->decrBy('key', 2);

$this->assertEquals(1, (int)$this->redis->get('key'));

$this->redis->decrBy('key', 1);

$this->assertEquals(0, (int)$this->redis->get('key'));

$this->redis->decrBy('key', -10);

$this->assertEquals(10, (int)$this->redis->get('key'));

$this->redis->decr('key', 10);

$this->assertEquals(0, (int)$this->redis->get('key'));

}

public function testExists()

{

$this->redis->del('key');

$this->assertFalse($this->redis->exists('key'));

$this->redis->set('key', 'val');

$this->assertEquals(True, $this->redis->exists('key'));

}

public function testGetKeys()

{

$pattern = 'getKeys-test-';

for($i = 1; $i < 10; $i++) {

$this->redis->set($pattern.$i, $i);

}

$this->redis->del($pattern.'3');

$keys = $this->redis->keys($pattern.'*');

$this->redis->set($pattern.'3', 'something');

$keys2 = $this->redis->keys($pattern.'*');

$this->assertEquals((count($keys) + 1), count($keys2));

// empty array when no key matches

$this->assertEquals(array(), $this->redis->keys(rand().rand().rand().'*'));

}

public function testDelete()

{

$key = 'key' . rand();

$this->redis->set($key, 'val');

$this->assertEquals('val', $this->redis->get($key));

$this->assertEquals(1, $this->redis->del($key));

$this->assertEquals(false, $this->redis->get($key));

// multiple, all existing

$this->redis->set('x', 0);

$this->redis->set('y', 1);

$this->redis->set('z', 2);

$this->assertEquals(3, $this->redis->del('x', 'y', 'z'));

$this->assertEquals(false, $this->redis->get('x'));

$this->assertEquals(false, $this->redis->get('y'));

$this->assertEquals(false, $this->redis->get('z'));

// multiple, none existing

$this->assertEquals(0, $this->redis->del('x', 'y', 'z'));

$this->assertEquals(false, $this->redis->get('x'));

$this->assertEquals(false, $this->redis->get('y'));

$this->assertEquals(false, $this->redis->get('z'));

// multiple, some existing

$this->redis->set('y', 1);

$this->assertEquals(1, $this->redis->del('x', 'y', 'z'));

$this->assertEquals(false, $this->redis->get('y'));

$this->redis->set('x', 0);

$this->redis->set('y', 1);

$this->assertEquals(2, $this->redis->del(array('x', 'y')));

}

public function testType()

{

// 0 => none, (key didn't exist)

// 1=> string,

// 2 => set,

// 3 => list,

// 4 => zset,

// 5 => hash

// string

$this->redis->set('key', 'val');

$this->assertEquals(Redis::REDIS_STRING, $this->redis->type('key'));

// list

$this->redis->lPush('keyList', 'val0');

$this->redis->lPush('keyList', 'val1');

$this->assertEquals(Redis::REDIS_LIST, $this->redis->type('keyList'));

// set

$this->redis->del('keySet');

$this->redis->sAdd('keySet', 'val0');

$this->redis->sAdd('keySet', 'val1');

$this->assertEquals(Redis::REDIS_SET, $this->redis->type('keySet'));

// sadd with numeric key

$this->redis->del(123);

$this->assertTrue(1 === $this->redis->sAdd(123, 'val0'));

$this->assertTrue(array('val0') === $this->redis->sMembers(123));

// zset

$this->redis->del('keyZSet');

$this->redis->zAdd('keyZSet', 0, 'val0');

$this->redis->zAdd('keyZSet', 1, 'val1');

$this->assertEquals(Redis::REDIS_ZSET, $this->redis->type('keyZSet'));

// hash

$this->redis->del('keyHash');

$this->redis->hSet('keyHash', 'key0', 'val0');

$this->redis->hSet('keyHash', 'key1', 'val1');

$this->assertEquals(Redis::REDIS_HASH, $this->redis->type('keyHash'));

//None

$this->assertEquals(Redis::REDIS_NOT_FOUND, $this->redis->type('keyNotExists'));

}

public function testStr() {

$this->redis->set('key', 'val1');

$this->assertTrue($this->redis->append('key', 'val2') === 8);

$this->assertTrue($this->redis->get('key') === 'val1val2');

$this->redis->del('keyNotExist');

$this->assertTrue($this->redis->append('keyNotExist', 'value') === 5);

$this->assertTrue($this->redis->get('keyNotExist') === 'value');

$this->redis->set('key', 'This is a string') ;

$this->assertTrue($this->redis->getRange('key', 0, 3) === 'This');

$this->assertTrue($this->redis->getRange('key', -6, -1) === 'string');

$this->assertTrue($this->redis->getRange('key', -6, 100000) === 'string');

$this->assertTrue($this->redis->get('key') === 'This is a string');

$this->redis->set('key', 'This is a string') ;

$this->assertTrue($this->redis->strlen('key') === 16);

$this->redis->set('key', 10) ;

$this->assertTrue($this->redis->strlen('key') === 2);

$this->redis->set('key', '') ;

$this->assertTrue($this->redis->strlen('key') === 0);

$this->redis->set('key', '000') ;

$this->assertTrue($this->redis->strlen('key') === 3);

}

// PUSH, POP : LPUSH, LPOP

public function testlPop()

{

// rpush => tail

// lpush => head

$this->redis->del('list');

$this->redis->lPush('list', 'val');

$this->redis->lPush('list', 'val2');

$this->redis->rPush('list', 'val3');

// 'list' = [ 'val2', 'val', 'val3']

$this->assertEquals('val2', $this->redis->lPop('list'));

$this->assertEquals('val', $this->redis->lPop('list'));

$this->assertEquals('val3', $this->redis->lPop('list'));

$this->assertEquals(FALSE, $this->redis->lPop('list'));

// testing binary data

$this->redis->del('list');

$this->assertEquals(1, $this->redis->lPush('list', gzcompress('val1')));

$this->assertEquals(2, $this->redis->lPush('list', gzcompress('val2')));

$this->assertEquals(3, $this->redis->lPush('list', gzcompress('val3')));

$this->assertEquals('val3', gzuncompress($this->redis->lPop('list')));

$this->assertEquals('val2', gzuncompress($this->redis->lPop('list')));

$this->assertEquals('val1', gzuncompress($this->redis->lPop('list')));

}

// PUSH, POP : RPUSH, RPOP

public function testrPop()

{

// rpush => tail

// lpush => head

$this->redis->del('list');

$this->redis->rPush('list', 'val');

$this->redis->rPush('list', 'val2');

$this->redis->lPush('list', 'val3');

// 'list' = [ 'val3', 'val', 'val2']

$this->assertEquals('val2', $this->redis->rPop('list'));

$this->assertEquals('val', $this->redis->rPop('list'));

$this->assertEquals('val3', $this->redis->rPop('list'));

$this->assertEquals(FALSE, $this->redis->rPop('list'));

// testing binary data

$this->redis->del('list');

$this->assertEquals(1, $this->redis->rPush('list', gzcompress('val1')));

$this->assertEquals(2, $this->redis->rPush('list', gzcompress('val2')));

$this->assertEquals(3, $this->redis->rPush('list', gzcompress('val3')));

$this->assertEquals('val3', gzuncompress($this->redis->rPop('list')));

$this->assertEquals('val2', gzuncompress($this->redis->rPop('list')));

$this->assertEquals('val1', gzuncompress($this->redis->rPop('list')));

}

public function testblockingPop() {

// non blocking blPop, brPop

$this->redis->del('list');

$this->redis->lPush('list', 'val1');

$this->redis->lPush('list', 'val2');

$this->assertTrue($this->redis->blPop(array('list'), 2) === array('list', 'val2'));

$this->assertTrue($this->redis->blPop(array('list'), 2) === array('list', 'val1'));

$this->redis->del('list');

$this->redis->lPush('list', 'val1');

$this->redis->lPush('list', 'val2');

$this->assertTrue($this->redis->brPop(array('list'), 1) === array('list', 'val1'));

$this->assertTrue($this->redis->brPop(array('list'), 1) === array('list', 'val2'));

// blocking blpop, brpop

$this->redis->del('list');

$this->assertTrue($this->redis->blPop(array('list'), 1) === array());

$this->assertTrue($this->redis->brPop(array('list'), 1) === array());

}

public function testllen()

{

$this->redis->del('list');

$this->redis->lPush('list', 'val');

$this->assertEquals(1, $this->redis->llen('list'));

$this->redis->lPush('list', 'val2');

$this->assertEquals(2, $this->redis->llen('list'));

$this->assertEquals('val2', $this->redis->lPop('list'));

$this->assertEquals(1, $this->redis->llen('list'));

$this->assertEquals('val', $this->redis->lPop('list'));

$this->assertEquals(0, $this->redis->llen('list'));

$this->assertEquals(FALSE, $this->redis->lPop('list'));

$this->assertEquals(0, $this->redis->llen('list')); // empty returns 0

$this->redis->del('list');

$this->assertEquals(0, $this->redis->llen('list')); // non-existent returns 0

$this->redis->set('list', 'actually not a list');

$this->assertEquals(FALSE, $this->redis->llen('list'));// not a list returns FALSE

}

//lInsert, lPopx, rPopx

public function testlPopx() {

//test lPushx/rPushx

$this->redis->del('keyNotExists');

$this->assertTrue($this->redis->lPushx('keyNotExists', 'value') === 0);

$this->assertTrue($this->redis->rPushx('keyNotExists', 'value') === 0);

$this->redis->del('key');

$this->redis->lPush('key', 'val0');

$this->assertTrue($this->redis->lPushx('key', 'val1') === 2);

$this->assertTrue($this->redis->rPushx('key', 'val2') === 3);

$this->assertTrue($this->redis->lrange('key', 0, -1) === array('val1', 'val0', 'val2'));

//test linsert

$this->redis->del('key');

$this->redis->lPush('key', 'val0');

$this->assertTrue($this->redis->lInsert('keyNotExists', Redis::AFTER, 'val1', 'val2') === 0);

$this->assertTrue($this->redis->lInsert('key', Redis::BEFORE, 'valX', 'val2') === -1);

$this->assertTrue($this->redis->lInsert('key', Redis::AFTER, 'val0', 'val1') === 2);

$this->assertTrue($this->redis->lInsert('key', Redis::BEFORE, 'val0', 'val2') === 3);

$this->assertTrue($this->redis->lrange('key', 0, -1) === array('val2', 'val0', 'val1'));

}

// ltrim, lsize, lpop

public function testltrim()

{

$this->redis->del('list');

$this->redis->lPush('list', 'val');

$this->redis->lPush('list', 'val2');

$this->redis->lPush('list', 'val3');

$this->redis->lPush('list', 'val4');

$this->assertEquals(TRUE, $this->redis->ltrim('list', 0, 2));

$this->assertEquals(3, $this->redis->llen('list'));

$this->redis->ltrim('list', 0, 0);

$this->assertEquals(1, $this->redis->llen('list'));

$this->assertEquals('val4', $this->redis->lPop('list'));

$this->assertEquals(TRUE, $this->redis->ltrim('list', 10, 10000));

$this->assertEquals(TRUE, $this->redis->ltrim('list', 10000, 10));

// test invalid type

$this->redis->set('list', 'not a list...');

$this->assertEquals(FALSE, $this->redis->ltrim('list', 0, 2));

}

public function setupSort() {

// people with name, age, salary

$this->redis->set('person:name_1', 'Alice');

$this->redis->set('person:age_1', 27);

$this->redis->set('person:salary_1', 2500);

$this->redis->set('person:name_2', 'Bob');

$this->redis->set('person:age_2', 34);

$this->redis->set('person:salary_2', 2000);

$this->redis->set('person:name_3', 'Carol');

$this->redis->set('person:age_3', 25);

$this->redis->set('person:salary_3', 2800);

$this->redis->set('person:name_4', 'Dave');

$this->redis->set('person:age_4', 41);

$this->redis->set('person:salary_4', 3100);

// set-up

$this->redis->del('person:id');

foreach(array(1,2,3,4) as $id) {

$this->redis->lPush('person:id', $id);

}

}

public function testSortPrefix() {

// Make sure that sorting works with a prefix

$this->redis->setOption(Redis::OPT_PREFIX, 'some-prefix:');

$this->redis->del('some-item');

$this->redis->sadd('some-item', 1);

$this->redis->sadd('some-item', 2);

$this->redis->sadd('some-item', 3);

$this->assertEquals(array('1','2','3'), $this->redis->sortAsc('some-item'));

$this->assertEquals(array('3','2','1'), $this->redis->sortDesc('some-item'));

$this->assertEquals(array('1','2','3'), $this->redis->sort('some-item'));

// Kill our set/prefix

$this->redis->del('some-item');

$this->redis->setOption(Redis::OPT_PREFIX, '');

}

public function testSortAsc() {

$this->setupSort();

$this->assertTrue(FALSE === $this->redis->sortAsc(NULL));

// sort by age and get IDs

$byAgeAsc = array('3','1','2','4');

$this->assertEquals($byAgeAsc, $this->redis->sortAsc('person:id', 'person:age_*'));

$this->assertEquals($byAgeAsc, $this->redis->sort('person:id', array('by' => 'person:age_*', 'sort' => 'asc')));

$this->assertEquals(array('1', '2', '3', '4'), $this->redis->sortAsc('person:id', NULL)); // check that NULL works.

$this->assertEquals(array('1', '2', '3', '4'), $this->redis->sortAsc('person:id', NULL, NULL)); // for all fields.

$this->assertEquals(array('1', '2', '3', '4'), $this->redis->sort('person:id', array('sort' => 'asc')));

// sort by age and get names

$byAgeAsc = array('Carol','Alice','Bob','Dave');

$this->assertEquals($byAgeAsc, $this->redis->sortAsc('person:id', 'person:age_*', 'person:name_*'));

$this->assertEquals($byAgeAsc, $this->redis->sort('person:id', array('by' => 'person:age_*', 'get' => 'person:name_*', 'sort' => 'asc')));

$this->assertEquals(array_slice($byAgeAsc, 0, 2), $this->redis->sortAsc('person:id', 'person:age_*', 'person:name_*', 0, 2));

$this->assertEquals(array_slice($byAgeAsc, 0, 2), $this->redis->sort('person:id', array('by' => 'person:age_*', 'get' => 'person:name_*', 'limit' => array(0, 2), 'sort' => 'asc')));

$this->assertEquals(array_slice($byAgeAsc, 1, 2), $this->redis->sortAsc('person:id', 'person:age_*', 'person:name_*', 1, 2));

$this->assertEquals(array_slice($byAgeAsc, 1, 2), $this->redis->sort('person:id', array('by' => 'person:age_*', 'get' => 'person:name_*', 'limit' => array(1, 2), 'sort' => 'asc')));

$this->assertEquals(array_slice($byAgeAsc, 0, 3), $this->redis->sortAsc('person:id', 'person:age_*', 'person:name_*', NULL, 3)); // NULL is transformed to 0 if there is something after it.

$this->assertEquals($byAgeAsc, $this->redis->sortAsc('person:id', 'person:age_*', 'person:name_*', 0, 4));

$this->assertEquals($byAgeAsc, $this->redis->sort('person:id', array('by' => 'person:age_*', 'get' => 'person:name_*', 'limit' => array(0, 4))));

$this->assertEquals($byAgeAsc, $this->redis->sort('person:id', array('by' => 'person:age_*', 'get' => 'person:name_*', 'limit' => array(0, "4")))); // with strings

$this->assertEquals($byAgeAsc, $this->redis->sort('person:id', array('by' => 'person:age_*', 'get' => 'person:name_*', 'limit' => array("0", 4))));

$this->assertEquals(array(), $this->redis->sortAsc('person:id', 'person:age_*', 'person:name_*', NULL, NULL)); // NULL, NULL is the same as (0,0). That returns no element.

// sort by salary and get ages

$agesBySalaryAsc = array('34', '27', '25', '41');

$this->assertEquals($agesBySalaryAsc, $this->redis->sortAsc('person:id', 'person:salary_*', 'person:age_*'));

$this->assertEquals($agesBySalaryAsc, $this->redis->sort('person:id', array('by' => 'person:salary_*', 'get' => 'person:age_*', 'sort' => 'asc')));

$agesAndSalaries = $this->redis->sort('person:id', array('by' => 'person:salary_*', 'get' => array('person:age_*', 'person:salary_*'), 'sort' => 'asc'));

$this->assertEquals(array('34', '2000', '27', '2500', '25', '2800', '41', '3100'), $agesAndSalaries);

// sort non-alpha doesn't change all-string lists

// list → [ghi, def, abc]

$list = array('abc', 'def', 'ghi');

$this->redis->del('list');

foreach($list as $i) {

$this->redis->lPush('list', $i);

}

// SORT list → [ghi, def, abc]

if (version_compare($this->version, "2.5.0", "lt")) {

$this->assertEquals(array_reverse($list), $this->redis->sortAsc('list'));

$this->assertEquals(array_reverse($list), $this->redis->sort('list', array('sort' => 'asc')));

} else {

// TODO rewrite, from 2.6.0 release notes:

// SORT now will refuse to sort in numerical mode elements that can't be parsed

// as numbers

}

// SORT list ALPHA → [abc, def, ghi]

$this->assertEquals($list, $this->redis->sortAscAlpha('list'));

$this->assertEquals($list, $this->redis->sort('list', array('sort' => 'asc', 'alpha' => TRUE)));

}

public function testSortDesc() {

$this->setupSort();

// sort by age and get IDs

$byAgeDesc = array('4','2','1','3');

$this->assertEquals($byAgeDesc, $this->redis->sortDesc('person:id', 'person:age_*'));

// sort by age and get names

$byAgeDesc = array('Dave', 'Bob', 'Alice', 'Carol');

$this->assertEquals($byAgeDesc, $this->redis->sortDesc('person:id', 'person:age_*', 'person:name_*'));

$this->assertEquals(array_slice($byAgeDesc, 0, 2), $this->redis->sortDesc('person:id', 'person:age_*', 'person:name_*', 0, 2));

$this->assertEquals(array_slice($byAgeDesc, 1, 2), $this->redis->sortDesc('person:id', 'person:age_*', 'person:name_*', 1, 2));

// sort by salary and get ages

$agesBySalaryDesc = array('41', '25', '27', '34');

$this->assertEquals($agesBySalaryDesc, $this->redis->sortDesc('person:id', 'person:salary_*', 'person:age_*'));

// sort non-alpha doesn't change all-string lists

$list = array('def', 'abc', 'ghi');

$this->redis->del('list');

foreach($list as $i) {

$this->redis->lPush('list', $i);

}

// SORT list → [ghi, abc, def]

if (version_compare($this->version, "2.5.0", "lt")) {

$this->assertEquals(array_reverse($list), $this->redis->sortDesc('list'));

} else {

// TODO rewrite, from 2.6.0 release notes:

// SORT now will refuse to sort in numerical mode elements that can't be parsed

// as numbers

}

// SORT list ALPHA → [abc, def, ghi]

$this->assertEquals(array('ghi', 'def', 'abc'), $this->redis->sortDescAlpha('list'));

}

// LINDEX

public function testlGet() {

$this->redis->del('list');