<?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

{

/* City lat/long */

protected $cities = [

'Chico' => [-121.837478, 39.728494],

'Sacramento' => [-121.494400, 38.581572],

'Gridley' => [-121.693583, 39.363777],

'Marysville' => [-121.591355, 39.145725],

'Cupertino' => [-122.032182, 37.322998]

];

protected $serializers = [

Redis::SERIALIZER_NONE,

Redis::SERIALIZER_PHP,

];

/**

* @var Redis

*/

public $redis;

/**

* @var string

*/

protected $sessionPrefix = 'PHPREDIS_SESSION:';

/**

* @var string

*/

protected $sessionSaveHandler = 'redis';

public function setUp() {

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

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

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

if (defined('Redis::SERIALIZER_IGBINARY')) {

$this->serializers[] = Redis::SERIALIZER_IGBINARY;

}

}

protected function minVersionCheck($version) {

return version_compare($this->version, $version) >= 0;

}

protected function mstime() {

return round(microtime(true)*1000);

}

protected function getAuthParts(&$user, &$pass) {

$user = $pass = NULL;

$auth = $this->getAuth();

if ( ! $auth)

return;

if (is_array($auth)) {

if (count($auth) > 1) {

list($user, $pass) = $auth;

} else {

$pass = $auth[0];

}

} else {

$pass = $auth;

}

}

protected function getAuthFragment() {

static $_authidx = 0;

$_authidx++;

$this->getAuthParts($user, $pass);

if ($user && $pass) {

if ($_authidx % 2 == 0)

return "auth[user]=$user&auth[pass]=$pass";

else

return "auth[]=$user&auth[]=$pass";

} else if ($pass) {

if ($_authidx % 3 == 0)

return "auth[pass]=$pass";

if ($_authidx % 2 == 0)

return "auth[]=$pass";

else

return "auth=$pass";

} else {

return NULL;

}

}

protected function getFullHostPath()

{

$fullHostPath = parent::getFullHostPath();

$authFragment = $this->getAuthFragment();

if (isset($fullHostPath) && $authFragment) {

$fullHostPath .= "?$authFragment";

}

return $fullHostPath;

}

protected function newInstance() {

$r = new Redis([

'host' => $this->getHost(),

'port' => $this->getPort(),

]);

if($this->getAuth()) {

$this->assertTrue($r->auth($this->getAuth()));

}

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") >= 0);

}

public function testPing() {

/* Reply literal off */

$this->assertTrue($this->redis->ping());

$this->assertTrue($this->redis->ping(NULL));

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

/* Make sure we're good in MULTI mode */

$this->redis->multi();

$this->redis->ping();

$this->redis->ping('BEEP');

$this->assertEquals([true, 'BEEP'], $this->redis->exec());

}

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") < 0) {

$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", [$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([$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', 0x7fffffff, 1);

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

}

public function testBitPos() {

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

$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') < 0) {

$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);

/* Should coerce doubles into long */

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

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

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

/* 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', ['nx']));

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

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

/* Set if exists */

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

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

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

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

/* Set with a TTL */

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

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

/* Set with a PTTL */

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

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

/* Set if exists, with a TTL */

$this->assertTrue($this->redis->set('foo','bar',['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', ['nx', 'ex'=>110]));

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

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

$this->assertFalse($this->redis->set('foo','bar', ['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', ['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);

/* Make sure we ignore bad/non-string options (regression test for #1835) */

$this->assertTrue($this->redis->set('foo', 'bar', [NULL, 'EX' => 60]));

$this->assertTrue($this->redis->set('foo', 'bar', [NULL, new stdClass(), 'EX' => 60]));

$this->assertFalse(@$this->redis->set('foo', 'bar', [NULL, 'EX' => []]));

if (version_compare($this->version, "6.0.0") < 0)

return;

/* KEEPTTL works by itself */

$this->redis->set('foo', 'bar', ['EX' => 100]);

$this->redis->set('foo', 'bar', ['KEEPTTL']);

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

/* Works with other options */

$this->redis->set('foo', 'bar', ['XX', 'KEEPTTL']);

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

$this->redis->set('foo', 'bar', ['XX']);

$this->assertTrue($this->redis->ttl('foo') == -1);

if (version_compare($this->version, "6.2.0") < 0)

return;

$this->assertTrue($this->redis->set('foo', 'baz', ['GET']) === 'bar');

}

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->assertEquals($this->redis->exists($k), 1);

}

}

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) === ['val1', 'val0']);

$this->assertTrue($this->redis->lRange('{key}1', 0, -1) === ['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) === []);

$this->assertTrue($this->redis->lRange('{key}2', 0, -1) === ['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(['v1'], $this->redis->mget(['k1']));

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

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

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

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

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

$this->assertEquals([0 => 'test'], $this->redis->mget([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([gzcompress('v1'), gzcompress('v2'), gzcompress('v3')], $this->redis->mget(['k1', 'k2', 'k3']));

$this->assertEquals([gzcompress('v1'), gzcompress('v2'), gzcompress('v3')], $this->redis->mget(['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'));

}

/* This test is prone to failure in the Travis container, so attempt to mitigate this by running more than once */

public function testExpireAt() {

$success = false;

for ($i = 0; !$success && $i < 3; $i++) {

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

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

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

usleep(1500000);

$success = FALSE === $this->redis->get('key');

}

$this->assertTrue($success);

}

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 testPSetEx() {

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

$this->assertTrue($this->redis->psetex('key', 7 * 1000, '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() {

if (PHP_INT_SIZE != 8) {

$this->markTestSkipped('64 bits only');

}

$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'));

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

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

}

public function testIncrByFloat()

{

// incrbyfloat is new in 2.6.0

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

$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, floatval($this->redis->get('key'))); // convert to float to avoid rounding issue on arm

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

$this->assertEquals(1, $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()

{

/* Single key */

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

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

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

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

/* Add multiple keys */

$mkeys = [];

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

if (rand(1, 2) == 1) {

$mkey = "{exists}key:$i";

$this->redis->set($mkey, $i);

$mkeys[] = $mkey;

}

}

/* Test passing an array as well as the keys variadic */

$this->assertEquals(count($mkeys), $this->redis->exists($mkeys));

$this->assertEquals(count($mkeys), call_user_func_array([$this->redis, 'exists'], $mkeys));

}

public function testKeys()

{

$pattern = 'keys-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([], $this->redis->keys(rand().rand().rand().'*'));

}

protected function genericDelUnlink($cmd) {

$key = 'key' . rand();

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

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

$this->assertEquals(1, $this->redis->$cmd($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->$cmd('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->$cmd('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->$cmd('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->$cmd(['x', 'y']));

}

public function testDelete() {

$this->genericDelUnlink("DEL");

}

public function testUnlink() {

if (version_compare($this->version, "4.0.0") < 0) {

$this->markTestSkipped();

return;

}

$this->genericDelUnlink("UNLINK");

}

public function testType()

{

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

// 1=> string,

// 2 => set,

// 3 => list,

// 4 => zset,

// 5 => hash

// 6 => stream

// 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(['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'));

// stream

if ($this->minVersionCheck("5.0")) {

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

$this->redis->xAdd('stream', '*', ['foo' => 'bar']);

$this->assertEquals(Redis::REDIS_STREAM, $this->redis->type('stream'));

}

// None

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

$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(['list'], 2) === ['list', 'val2']);

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

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

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

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

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

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

// blocking blpop, brpop

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

/* Also test our option that we want *-1 to be returned as NULL */

foreach ([false => [], true => NULL] as $opt => $val) {

$this->redis->setOption(Redis::OPT_NULL_MULTIBULK_AS_NULL, $opt);

$this->assertEquals($val, $this->redis->blPop(['list'], 1));

$this->assertEquals($val, $this->redis->brPop(['list'], 1));

}

$this->redis->setOption(Redis::OPT_NULL_MULTIBULK_AS_NULL, false);

}

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) === ['val1', 'val0', 'val2']);

//test linsert

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