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

require_once __DIR__ . '/TestSuite.php';

require_once __DIR__ . '/SessionHelpers.php';

class Redis_Test extends TestSuite {

/**

* @var Redis

*/

public $redis;

/* 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,

];

protected function getNilValue() {

return FALSE;

}

protected function getSerializers() {

$result = [Redis::SERIALIZER_NONE, Redis::SERIALIZER_PHP];

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

$result[] = Redis::SERIALIZER_IGBINARY;

if (defined('Redis::SERIALIZER_JSON'))

$result[] = Redis::SERIALIZER_JSON;

if (defined('Redis::SERIALIZER_MSGPACK'))

$result[] = Redis::SERIALIZER_MSGPACK;

return $result;

}

protected function getCompressors() {

$result['none'] = Redis::COMPRESSION_NONE;

if (defined('Redis::COMPRESSION_LZF'))

$result['lzf'] = Redis::COMPRESSION_LZF;

if (defined('Redis::COMPRESSION_LZ4'))

$result['lz4'] = Redis::COMPRESSION_LZ4;

if (defined('Redis::COMPRESSION_ZSTD'))

$result['zstd'] = Redis::COMPRESSION_ZSTD;

return $result;

}

/* Overridable left/right constants */

protected function getLeftConstant() {

return Redis::LEFT;

}

protected function getRightConstant() {

return Redis::RIGHT;

}

protected function detectKeyDB(array $info) {

return strpos($info['executable'] ?? '', 'keydb') !== false ||

isset($info['keydb']) ||

isset($info['mvcc_depth']);

}

protected function detectValkey(array $info) {

return isset($info['server_name']) && $info['server_name'] === 'valkey';

}

public function setUp() {

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

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

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

$this->is_keydb = $this->detectKeyDB($info);

$this->is_valkey = $this->detectValKey($info);

$this->valkey_version = $info['valkey_version'] ?? '0.0.0';

}

protected function haveCommand(string $cmd): bool {

$info = $this->redis->command('info', $cmd);

$name = $info[0][0] ?? null;

return $name && strcasecmp($cmd, $name) === 0;

}

protected function minVersionCheck($version) {

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

}

protected function minValkeyVersionCheck($version) {

return $this->is_valkey && version_compare($this->valkey_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 sessionPrefix(): string {

return 'PHPREDIS_SESSION:';

}

protected function sessionSaveHandler(): string {

return 'redis';

}

protected function sessionSavePath(): string {

return sprintf('tcp://%s:%d?%s', $this->getHost(), $this->getPort(),

$this->getAuthFragment());

}

protected function getAuthFragment() {

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

if ($user && $pass) {

return sprintf('auth[user]=%s&auth[pass]=%s', $user, $pass);

} else if ($pass) {

return sprintf('auth[pass]=%s', $pass);

} else {

return '';

}

}

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 class has pipeline support */

protected function havePipeline() {

return defined(get_class($this->redis) . '::PIPELINE');

}

protected function haveMulti() {

return defined(get_class($this->redis) . '::MULTI');

}

public function testMinimumVersion() {

$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 */

if ($this->haveMulti()) {

$this->assertEquals(

[true, 'BEEP'],

$this->redis->multi()

->ping()

->ping('BEEP')

->exec()

);

}

}

public function testPipelinePublish() {

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

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

->exec();

$this->assertIsArray($ret, 1);

$this->assertGT(-1, $ret[0] ?? -1);

}

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

// PUBSUB CHANNELS ...

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

$this->assertIsArray($result);

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

$this->assertIsArray($result);

// PUBSUB NUMSUB

$c1 = uniqid();

$c2 = uniqid();

$result = $this->redis->pubsub('numsub', [$c1, $c2]);

// Should get an array back, with two elements

$this->assertIsArray($result);

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

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

foreach ([$c1,$c2] as $channel) {

$this->assertArrayKeyEquals($result, $channel, 0);

}

// PUBSUB NUMPAT

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

$this->assertIsInt($result);

// Invalid calls

$this->assertFalse(@$this->redis->pubsub('notacommand'));

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

}

/* These test cases were generated randomly. We're just trying to test

that PhpRedis handles all combination of arguments correctly. */

public function testBitcount() {

/* key */

$this->redis->set('bitcountkey', hex2bin('bd906b854ca76cae'));

$this->assertEquals(33, $this->redis->bitcount('bitcountkey'));

/* key, start */

$this->redis->set('bitcountkey', hex2bin('400aac171382a29bebaab554f178'));

$this->assertEquals(4, $this->redis->bitcount('bitcountkey', 13));

/* key, start, end */

$this->redis->set('bitcountkey', hex2bin('b1f32405'));

$this->assertEquals(2, $this->redis->bitcount('bitcountkey', 3, 3));

/* key, start, end BYTE */

$this->redis->set('bitcountkey', hex2bin('10eb8939e68bfdb640260f0629f3'));

$this->assertEquals(1, $this->redis->bitcount('bitcountkey', 8, 8, false));

if ( ! $this->is_keydb && $this->minVersionCheck('7.0')) {

/* key, start, end, BIT */

$this->redis->set('bitcountkey', hex2bin('cd0e4c80f9e4590d888a10'));

$this->assertEquals(5, $this->redis->bitcount('bitcountkey', 0, 9, true));

}

}

public function testBitop() {

if ( ! $this->minVersionCheck('2.6.0'))

$this->markTestSkipped();

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

$this->redis->set('{key}2', 'abcdef');

// Regression test for GitHub issue #2210

$this->assertEquals(6, $this->redis->bitop('AND', '{key}1', '{key}2'));

// Make sure RedisCluster doesn't even send the command. We don't care

// about what Redis returns

@$this->redis->bitop('AND', 'key1', 'key2', 'key3');

$this->assertNull($this->redis->getLastError());

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

}

public function testBitsets() {

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

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

$this->assertFalse($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->assertKeyEquals("\x7f", '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->assertKeyEquals("\x3f", '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->assertKeyEquals("\x1f", '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->assertKeyEquals("\x9f", '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 testLcs() {

if ( ! $this->minVersionCheck('7.0.0') || $this->is_keydb)

$this->markTestSkipped();

$key1 = '{lcs}1'; $key2 = '{lcs}2';

$this->assertTrue($this->redis->set($key1, '12244447777777'));

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

$this->assertEquals('224444', $this->redis->lcs($key1, $key2));

$this->assertEquals(

['matches', [[[1, 6], [6, 11]]], 'len', 6],

$this->redis->lcs($key1, $key2, ['idx'])

);

$this->assertEquals(

['matches', [[[1, 6], [6, 11], 6]], 'len', 6],

$this->redis->lcs($key1, $key2, ['idx', 'withmatchlen'])

);

$this->assertEquals(6, $this->redis->lcs($key1, $key2, ['len']));

$this->redis->del([$key1, $key2]);

}

public function testLmpop() {

if (version_compare($this->version, '7.0.0') < 0)

$this->markTestSkipped();

$key1 = '{l}1';

$key2 = '{l}2';

$this->redis->del($key1, $key2);

$this->assertEquals(6, $this->redis->rpush($key1, 'A', 'B', 'C', 'D', 'E', 'F'));

$this->assertEquals(6, $this->redis->rpush($key2, 'F', 'E', 'D', 'C', 'B', 'A'));

$this->assertEquals([$key1, ['A']], $this->redis->lmpop([$key1, $key2], 'LEFT'));

$this->assertEquals([$key1, ['F']], $this->redis->lmpop([$key1, $key2], 'RIGHT'));

$this->assertEquals([$key1, ['B', 'C', 'D']], $this->redis->lmpop([$key1, $key2], 'LEFT', 3));

$this->assertEquals(2, $this->redis->del($key1, $key2));

}

public function testBLmpop() {

if (version_compare($this->version, '7.0.0') < 0)

$this->markTestSkipped();

$key1 = '{bl}1';

$key2 = '{bl}2';

$this->redis->del($key1, $key2);

$this->assertEquals(2, $this->redis->rpush($key1, 'A', 'B'));

$this->assertEquals(2, $this->redis->rpush($key2, 'C', 'D'));

$this->assertEquals([$key1, ['B', 'A']], $this->redis->blmpop(.2, [$key1, $key2], 'RIGHT', 2));

$this->assertEquals([$key2, ['C']], $this->redis->blmpop(.2, [$key1, $key2], 'LEFT'));

$this->assertEquals([$key2, ['D']], $this->redis->blmpop(.2, [$key1, $key2], 'LEFT'));

$st = microtime(true);

$this->assertFalse($this->redis->blmpop(.2, [$key1, $key2], 'LEFT'));

$et = microtime(true);

// Very loose tolerance because CI is run on a potato

$this->assertBetween($et - $st, .05, .75);

}

function testZmpop() {

if (version_compare($this->version, '7.0.0') < 0)

$this->markTestSkipped();

$key1 = '{z}1';

$key2 = '{z}2';

$this->redis->del($key1, $key2);

$this->assertEquals(4, $this->redis->zadd($key1, 0, 'zero', 2, 'two', 4, 'four', 6, 'six'));

$this->assertEquals(4, $this->redis->zadd($key2, 1, 'one', 3, 'three', 5, 'five', 7, 'seven'));

$this->assertEquals([$key1, ['zero' => 0.0]], $this->redis->zmpop([$key1, $key2], 'MIN'));

$this->assertEquals([$key1, ['six' => 6.0]], $this->redis->zmpop([$key1, $key2], 'MAX'));

$this->assertEquals([$key1, ['two' => 2.0, 'four' => 4.0]], $this->redis->zmpop([$key1, $key2], 'MIN', 3));

$this->assertEquals(

[$key2, ['one' => 1.0, 'three' => 3.0, 'five' => 5.0, 'seven' => 7.0]],

$this->redis->zmpop([$key1, $key2], 'MIN', 128)

);

$this->assertFalse($this->redis->zmpop([$key1, $key2], 'MIN'));

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

$this->assertNull($this->redis->zmpop([$key1, $key2], 'MIN'));

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

}

function testBZmpop() {

if (version_compare($this->version, '7.0.0') < 0)

$this->markTestSkipped();

$key1 = '{z}1';

$key2 = '{z}2';

$this->redis->del($key1, $key2);

$this->assertEquals(2, $this->redis->zadd($key1, 0, 'zero', 2, 'two'));

$this->assertEquals(2, $this->redis->zadd($key2, 1, 'one', 3, 'three'));

$this->assertEquals(

[$key1, ['zero' => 0.0, 'two' => 2.0]],

$this->redis->bzmpop(.1, [$key1, $key2], 'MIN', 2)

);

$this->assertEquals([$key2, ['three' => 3.0]], $this->redis->bzmpop(.1, [$key1, $key2], 'MAX'));

$this->assertEquals([$key2, ['one' => 1.0]], $this->redis->bzmpop(.1, [$key1, $key2], 'MAX'));

$st = microtime(true);

$this->assertFalse($this->redis->bzmpop(.2, [$key1, $key2], 'MIN'));

$et = microtime(true);

$this->assertBetween($et - $st, .05, .75);

}

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(12, $this->redis->bitpos('bpkey', 0));

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

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

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

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

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

if ( ! $this->minVersionCheck('7.0.0'))

return;

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

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

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

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

}

public function testSetLargeKeys() {

foreach ([1000, 100000, 1000000] as $size) {

$value = str_repeat('A', $size);

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

$this->assertKeyEquals($value, 'x');

}

}

public function testEcho() {

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

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

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

}

public function testErr() {

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

$this->assertKeyEquals('-ERR', 'x');

}

public function testSet() {

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

$this->assertKeyEquals('nil', 'key');

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

$this->assertKeyEquals('val', 'key');

$this->assertKeyEquals('val', 'key');

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

$this->assertKeyMissing('keyNotExist');

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

$this->assertKeyEquals('val', 'key2');

$value1 = bin2hex(random_bytes(rand(64, 128)));

$value2 = random_bytes(rand(65536, 65536 * 2));;

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

$this->assertKeyEquals($value1, 'key2');

$this->assertKeyEquals($value1, 'key2');

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

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

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

$this->assertKeyEquals($value2, 'key');

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

$this->assertKeyMissing('key');

$data = gzcompress('42');

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

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

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

$data = gzcompress('value1');

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

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

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

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

$this->assertKeyEquals('0', 'key');

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

$this->assertKeyEquals('1', 'key');

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

$this->assertKeyEquals('0.1', 'key');

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

$this->assertKeyEquals('0.1', 'key');

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

$this->assertKeyEquals('1', 'key');

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

$this->assertKeyEquals('', 'key');

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

$this->assertKeyEquals('', 'key');

$this->assertTrue($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();

/* Legacy SETEX redirection */

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

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

$this->assertKeyEquals('bar', 'foo');

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

/* Should coerce doubles into long */

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

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

$this->assertKeyEquals('bar-20.5', 'foo');

/* 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->assertKeyEquals('bar', 'foo');

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

/* Set if exists */

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

$this->assertKeyEquals('bar', 'foo');

$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(100, $this->redis->ttl('foo'));

/* Set with a PTTL */

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

$this->assertBetween($this->redis->pttl('foo'), 99000, 100001);

/* Set if exists, with a TTL */

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

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

$this->assertKeyEquals('bar', 'foo');

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

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

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

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

$this->assertKeyEquals('bar', 'foo');

$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(200, $this->redis->ttl('foo'));

$this->assertKeyEquals('barbaz', 'foo');

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

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

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

$this->assertKeyEquals('bar', 'foo');

$this->assertLT(0, $this->redis->ttl('foo'));

/* 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->assertBetween($this->redis->ttl('foo'), 90, 100);

/* Works with other options */

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

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

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

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

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

return;

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

}

/* Test Valkey >= 8.1 IFEQ SET option */

public function testValkeyIfEq() {

if ( ! $this->is_valkey || ! $this->minVersionCheck('8.1.0'))

$this->markTestSkipped();

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

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

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

$this->assertFalse($this->redis->set('foo', 'bar4', ['IFEQ' => 'bar3']));

$this->assertEquals('bar2', $this->redis->set('foo', 'bar3', ['IFEQ' => 'bar2', 'GET']));

}

public function testGetSet() {

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

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

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

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

}

public function testGetDel() {

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

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

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

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

}

public function testRandomKey() {

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

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

$this->assertKeyExists($k);

}

}

public function testRename() {

// strings

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

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

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

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

$this->assertKeyEquals('val0', '{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->assertFalse($this->redis->renameNx('{key}0', '{key}1'));

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

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

// 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->assertFalse($this->redis->renameNx('{key}0', '{key}1'));

$this->assertEquals(['val1', 'val0'], $this->redis->lRange('{key}0', 0, -1));

$this->assertEquals(['val1-1', 'val1-0'], $this->redis->lRange('{key}1', 0, -1));

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

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

$this->assertEquals([], $this->redis->lRange('{key}0', 0, -1));

$this->assertEquals(['val1', 'val0'], $this->redis->lRange('{key}2', 0, -1));

}

public function testMultiple() {

$kvals = [

'mget1' => 'v1',

'mget2' => 'v2',

'mget3' => 'v3'

];

$this->redis->mset($kvals);

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

$this->assertEquals([$kvals['mget1']], $this->redis->mget(['mget1']));

$this->assertEquals(['v1', 'v2', false], $this->redis->mget(['mget1', 'mget2', 'NoKey']));

$this->assertEquals(['v1', 'v2', 'v3'], $this->redis->mget(['mget1', 'mget2', 'mget3']));

$this->assertEquals(['v1', 'v2', 'v3'], $this->redis->mget(['mget1', 'mget2', 'mget3']));

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

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

$this->assertEquals(['test'], $this->redis->mget([1])); // non-string

}

public function testMultipleBin() {

$kvals = [

'binkey-1' => random_bytes(16),

'binkey-2' => random_bytes(16),

'binkey-3' => random_bytes(16),

];

foreach ($kvals as $k => $v) {

$this->redis->set($k, $v);

}

$this->assertEquals(array_values($kvals),

$this->redis->mget(array_keys($kvals)));

}

public function testExpireMember() {

if ( ! $this->is_keydb)

$this->markTestSkipped();

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

$this->redis->hmset('h', ['f1' => 'v1', 'f2' => 'v2', 'f3' => 'v3', 'f4' => 'v4']);

$this->assertEquals(1, $this->redis->expiremember('h', 'f1', 1));

$this->assertEquals(1, $this->redis->expiremember('h', 'f2', 1000, 'ms'));

$this->assertEquals(1, $this->redis->expiremember('h', 'f3', 1000, null));

$this->assertEquals(0, $this->redis->expiremember('h', 'nk', 10));

$this->assertEquals(1, $this->redis->expirememberat('h', 'f4', time() + 1));

$this->assertEquals(0, $this->redis->expirememberat('h', 'nk', time() + 1));

}

public function testExpire() {

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

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

$this->assertKeyEquals('value', 'key');

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

$this->assertKeyEquals('value', 'key');

sleep(2);

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

}

function testExpireOptions() {

if ( ! $this->minVersionCheck('7.0.0'))

$this->markTestSkipped();

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

/* NX -- Only if expiry isn't set so success, then failure */

$this->assertTrue($this->redis->expire('eopts', 1000, 'NX'));

$this->assertFalse($this->redis->expire('eopts', 1000, 'NX'));

/* XX -- Only set if the key has an existing expiry */

$this->assertTrue($this->redis->expire('eopts', 1000, 'XX'));

$this->assertTrue($this->redis->persist('eopts'));

$this->assertFalse($this->redis->expire('eopts', 1000, 'XX'));

/* GT -- Only set when new expiry > current expiry */

$this->assertTrue($this->redis->expire('eopts', 200));

$this->assertTrue($this->redis->expire('eopts', 300, 'GT'));

$this->assertFalse($this->redis->expire('eopts', 100, 'GT'));

/* LT -- Only set when expiry < current expiry */

$this->assertTrue($this->redis->expire('eopts', 200));

$this->assertTrue($this->redis->expire('eopts', 100, 'LT'));

$this->assertFalse($this->redis->expire('eopts', 300, 'LT'));

/* Sending a nonsensical mode fails without sending a command */

$this->redis->clearLastError();

$this->assertFalse(@$this->redis->expire('eopts', 999, 'nonsense'));

$this->assertNull($this->redis->getLastError());

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

}

public function testExpiretime() {

if (version_compare($this->version, '7.0.0') < 0)

$this->markTestSkipped();

$now = time();

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

$this->assertTrue($this->redis->expireat('key1', $now + 10));

$this->assertEquals($now + 10, $this->redis->expiretime('key1'));

$this->assertEquals(1000 * ($now + 10), $this->redis->pexpiretime('key1'));

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

}

public function testGetEx() {

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

$this->markTestSkipped();

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

$this->assertEquals('value', $this->redis->getEx('key', ['EX' => 100]));

$this->assertBetween($this->redis->ttl('key'), 95, 100);

$this->assertEquals('value', $this->redis->getEx('key', ['PX' => 100000]));

$this->assertBetween($this->redis->pttl('key'), 95000, 100000);

$this->assertEquals('value', $this->redis->getEx('key', ['EXAT' => time() + 200]));

$this->assertBetween($this->redis->ttl('key'), 195, 200);

$this->assertEquals('value', $this->redis->getEx('key', ['PXAT' => (time()*1000) + 25000]));

$this->assertBetween($this->redis->pttl('key'), 24000, 25000);

$this->assertEquals('value', $this->redis->getEx('key', ['PERSIST' => true]));

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

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

$this->assertBetween($this->redis->ttl('key'), 95, 100);

$this->assertEquals('value', $this->redis->getEx('key', ['PERSIST']));

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

}

public function testSetEx() {

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

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

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

$this->assertKeyEquals('val', 'key');

}

public function testPSetEx() {

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

$this->assertTrue($this->redis->psetex('key', 7 * 1000, 'val'));

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

$this->assertKeyEquals('val', 'key');

}

public function testSetNX() {

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

$this->assertFalse($this->redis->setnx('key', 'err'));

$this->assertKeyEquals('42', 'key');

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

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

$this->assertKeyEquals('42', 'key');

}

public function testExpireAtWithLong() {

if (PHP_INT_SIZE != 8)

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

$large_expiry = 3153600000;

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

$this->assertTrue($this->redis->setex('key', $large_expiry, 'val'));

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

}

public function testIncr() {

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

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

$this->assertKeyEqualsWeak(1, 'key');

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

$this->assertKeyEqualsWeak(2, 'key');

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

$this->assertKeyEqualsWeak(5, 'key');

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

$this->assertKeyEqualsWeak(6, 'key');

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

$this->assertKeyEqualsWeak(5, 'key');

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

$this->assertKeyEqualsWeak(10, 'key');

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

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

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

$this->assertKeyEquals('abc', 'key');

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

$this->assertKeyEquals('abc', '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->assertKeyEquals('1.5', 'key');

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

$this->assertKeyEquals('3.75', 'key');

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

$this->assertKeyEquals('1.5', 'key');

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

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

$this->assertKeyEquals('abc', 'key');

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

$this->assertKeyEquals('abc', 'key');

// Test with prefixing

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

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

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

$this->assertKeyEqualsWeak(1.8, 'key');

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

$this->assertKeyExists('someprefix:key');

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

}

public function testDecr() {

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

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

$this->assertKeyEqualsWeak(4, 'key');

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

$this->assertKeyEqualsWeak(3, 'key');

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

$this->assertKeyEqualsWeak(1, 'key');

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

$this->assertKeyEqualsWeak(0, 'key');

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

$this->assertKeyEqualsWeak(10, 'key');

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

$this->assertKeyEqualsWeak(0, 'key');

}