/home/lnzliplg/public_html/alt-php83-pecl-memcache_8.2-1.el8.tar
tests/049.phpt 0000644 00000001305 15173154470 0007125 0 ustar 00 --TEST--
memcache->append(), memcache->prepend()
--SKIPIF--
<?php include 'connect.inc'; if (ini_get('memcache.protocol') == 'binary') die('skip binary protocol doesn\'t support append/prepend'); ?>
--FILE--
<?php
include 'connect.inc';
$result1 = $memcache->set('test_key', 'a');
$result2 = $memcache->get('test_key');
var_dump($result1);
var_dump($result2);
$result1 = $memcache->append('test_key', 'b');
$result2 = $memcache->get('test_key');
var_dump($result1);
var_dump($result2);
$result1 = $memcache->prepend('test_key', 'c');
$result2 = $memcache->get('test_key');
var_dump($result1);
var_dump($result2);
?>
--EXPECT--
bool(true)
string(1) "a"
bool(true)
string(2) "ab"
bool(true)
string(3) "cab" tests/004.phpt 0000644 00000001013 15173154471 0007111 0 ustar 00 --TEST--
memcache_add() & memcache_replace()
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$var = new stdClass;
$var->plain_attribute = 'value';
$var->array_attribute = Array('test1', 'test2');
$result1 = memcache_add($memcache, 'non_existing_test_key', $var, false, 1);
$result2 = memcache_replace($memcache, 'non_existing_test_key', $var, false, 10);
var_dump($result1);
var_dump($result2);
memcache_delete($memcache, 'non_existing_test_key');
?>
--EXPECT--
bool(true)
bool(true)
tests/029.phpt 0000644 00000002507 15173154472 0007132 0 ustar 00 --TEST--
ini_set("memcache.allow_failover")
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$var1 = 'test1';
$var2 = 'test2';
ini_set('memcache.allow_failover', 1);
$memcache = new Memcache();
$memcache->addServer($host, $port);
$memcache->addServer($nonExistingHost, $nonExistingPort);
$result1 = @$memcache->set($balanceKey1, $var1, false, 1); // hashes to $host2
$result2 = $memcache->set($balanceKey2, $var2, false, 1); // hashes to $host1
$result3 = $memcache->get($balanceKey1);
$result4 = $memcache->get($balanceKey2);
var_dump($result1);
var_dump($result2);
var_dump($result3);
var_dump($result4);
$result = $memcache->get(array($balanceKey1, $balanceKey2));
if (is_array($result))
sort($result);
var_dump($result);
ini_set('memcache.allow_failover', 0);
$result1 = $memcache->get($balanceKey1);
$result2 = $memcache->get($balanceKey2);
var_dump($result1);
var_dump($result2);
$result = $memcache->get(array($balanceKey1, $balanceKey2));
if (is_array($result))
sort($result);
var_dump($result);
$result = @ini_set('memcache.allow_failover', "abc");
var_dump($result);
?>
--EXPECTF--
bool(true)
bool(true)
string(5) "test1"
string(5) "test2"
array(2) {
[0]=>
string(5) "test1"
[1]=>
string(5) "test2"
}
bool(false)
string(5) "test2"
array(1) {
[0]=>
string(5) "test2"
}
string(1) "0"
tests/058.phpt 0000644 00000000325 15173154473 0007131 0 ustar 00 --TEST--
memcache->findServer()
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$result = $memcache->findServer('test_key');
var_dump($result);
?>
--EXPECTF--
string(%d) "%s:%d" tests/005.phpt 0000644 00000007224 15173154474 0007127 0 ustar 00 --TEST--
strange keys
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$var = 'test';
$key = "test\r\n\0 - really strange key";
memcache_set($memcache, $key, $var, false);
$result = memcache_get($memcache, $key);
var_dump($result);
$result = memcache_get($memcache, $key."1");
var_dump($result);
$result = memcache_get($memcache, array($key, $key."1"));
var_dump(count($result));
if (is_array($result)) {
$keys = array_keys($result);
var_dump(strtr($keys[0], "\r\n\0", "___"));
}
// Test empty key
$result = memcache_set($memcache, '', 'test1');
var_dump($result);
$result = memcache_get($memcache, '');
var_dump($result);
memcache_set($memcache, 'test_key1', 'test1');
memcache_set($memcache, 'test_key2', 'test2');
$result = memcache_get($memcache, array('test_key1', '', 'test_key2'));
var_dump($result);
$result = memcache_get($memcache, '');
var_dump($result);
$result = memcache_increment($memcache, '');
var_dump($result);
$result = memcache_delete($memcache, '');
var_dump($result);
function test_key_oo($memcache, $key) {
$memcache->set($key, '1');
var_dump($key);
$memcache->get($key);
var_dump($key);
$memcache->get(array($key, 'test_key1'));
var_dump($key);
$memcache->increment($key);
var_dump($key);
$memcache->decrement($key);
var_dump($key);
$memcache->delete($key);
var_dump($key);
}
function test_key_proc($memcache, $key) {
memcache_set($memcache, $key, '1');
var_dump($key);
memcache_get($memcache, $key);
var_dump($key);
memcache_get($memcache, array($key, 'test_key1'));
var_dump($key);
memcache_increment($memcache, $key);
var_dump($key);
memcache_decrement($memcache, $key);
var_dump($key);
memcache_delete($memcache, $key);
var_dump($key);
}
// Test non-string key
$key = 123;
test_key_oo($memcache, $key);
print "\n";
test_key_proc($memcache, $key);
print "\n";
// Test modify key
$key = 'test test';
test_key_oo($memcache, $key);
print "\n";
test_key_proc($memcache, $key);
print "\n";
// Test UTF-8 key
$key = 'abc�abc';
$result = $memcache->set($key, 'test1');
var_dump($result);
$result = $memcache->get($key);
var_dump($result);
$result = $memcache->get(array($key));
var_dump($result);
// Array keys
$memcache->set('test_key', 'value');
$result = $memcache->get(array('test_key'));
var_dump($result['test_key']);
// Long keys
var_dump(memcache_increment($memcache, 'forum_thread.php_55461ANDis_show=1ORDERBYis_topDESC,update_timeDESC_0', 1));
// Whitespace key
$values = array(' ' => 'value', 'test test' => 'value2');
$result = $memcache->set($values);
var_dump($result);
$keys = array_keys($values);
$result = $memcache->get($keys);
var_dump($keys);
var_dump(array_values($result));
?>
--EXPECTF--
string(4) "test"
bool(false)
int(1)
string(28) "%s"
Warning: memcache_set(): %s
bool(false)
Warning: memcache_get(): %s
bool(false)
Warning: memcache_get(): %s
array(2) {
["test_key1"]=>
string(5) "test1"
["test_key2"]=>
string(5) "test2"
}
Warning: memcache_get(): %s
bool(false)
Warning: memcache_increment(): %s
bool(false)
Warning: memcache_delete(): %s
bool(false)
int(123)
int(123)
int(123)
int(123)
int(123)
int(123)
int(123)
int(123)
int(123)
int(123)
int(123)
int(123)
string(9) "test test"
string(9) "test test"
string(9) "test test"
string(9) "test test"
string(9) "test test"
string(9) "test test"
string(9) "test test"
string(9) "test test"
string(9) "test test"
string(9) "test test"
string(9) "test test"
string(9) "test test"
bool(true)
string(5) "test1"
array(1) {
["abc�abc"]=>
string(5) "test1"
}
string(5) "value"
bool(false)
bool(true)
array(2) {
[0]=>
string(1) " "
[1]=>
string(9) "test test"
}
array(2) {
[0]=>
string(5) "value"
[1]=>
string(6) "value2"
}
tests/003.phpt 0000644 00000002217 15173154474 0007122 0 ustar 00 --TEST--
memcache_set()/memcache_get() using compression
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$var = new stdClass;
$var->plain_attribute = 'value';
$var->array_attribute = Array('test1', 'test2');
memcache_set($memcache, 'test_key', $var, MEMCACHE_COMPRESSED, 10);
memcache_set($memcache, 'test_key1', $var, MEMCACHE_COMPRESSED, 10);
$result = memcache_get($memcache, 'test_key');
var_dump($result);
$result = memcache_get($memcache, Array('test_key', 'test_key1'));
var_dump($result);
?>
--EXPECTF--
object(stdClass)%s2) {
["plain_attribute"]=>
string(5) "value"
["array_attribute"]=>
array(2) {
[0]=>
string(5) "test1"
[1]=>
string(5) "test2"
}
}
array(2) {
["test_key"]=>
object(stdClass)%s2) {
["plain_attribute"]=>
string(5) "value"
["array_attribute"]=>
array(2) {
[0]=>
string(5) "test1"
[1]=>
string(5) "test2"
}
}
["test_key1"]=>
object(stdClass)%s2) {
["plain_attribute"]=>
string(5) "value"
["array_attribute"]=>
array(2) {
[0]=>
string(5) "test1"
[1]=>
string(5) "test2"
}
}
}
tests/027a.phpt 0000644 00000004001 15173154475 0007263 0 ustar 00 --TEST--
memcache_set_compress_threshold()
--SKIPIF--
<?php
if (PHP_VERSION_ID < 80000)
die('skip php 8+ only');
include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$var = str_repeat('abc', 5000);
memcache_set_compress_threshold($memcache, 10000);
$result1 = memcache_set($memcache, 'non_existing_test_key', $var, 0, 1);
$result2 = memcache_get($memcache, 'non_existing_test_key');
var_dump($result1);
var_dump(strlen($result2));
memcache_set_compress_threshold($memcache, 10000, 0);
$result3 = memcache_set($memcache, 'non_existing_test_key', $var, 0, 1);
memcache_set_compress_threshold($memcache, 10000, 1);
$result4 = memcache_set($memcache, 'non_existing_test_key', $var, 0, 1);
var_dump($result3);
var_dump($result4);
$result5 = memcache_set($memcache, 'non_existing_test_key', 'abc', MEMCACHE_COMPRESSED, 1);
$result6 = memcache_get($memcache, 'non_existing_test_key');
var_dump($result5);
var_dump($result6);
try {
var_dump(memcache_set_compress_threshold(array(), 10000, 0));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
var_dump(memcache_set_compress_threshold($memcache, -1, -1));
var_dump(memcache_set_compress_threshold($memcache, 1, -1));
var_dump(memcache_set_compress_threshold($memcache, -1, 1));
try {
var_dump(memcache_set_compress_threshold(new stdClass, 1, 1));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
echo "Done\n";
?>
--EXPECTF--
bool(true)
int(15000)
bool(true)
bool(true)
bool(true)
string(3) "abc"
memcache_set_compress_threshold(): Argument #1 ($memcache) must be of type MemcachePool, array given
Warning: memcache_set_compress_threshold()%s threshold must be a positive integer in %s on line %d
bool(false)
Warning: memcache_set_compress_threshold()%s min_savings must be a float in the 0..1 range in %s on line %d
bool(false)
Warning: memcache_set_compress_threshold()%s threshold must be a positive integer in %s on line %d
bool(false)
memcache_set_compress_threshold(): Argument #1 ($memcache) must be of type MemcachePool, stdClass given
Done
tests/018.phpt 0000644 00000000616 15173154477 0007134 0 ustar 00 --TEST--
memcache_set() & memcache_add()
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$var = 'test';
error_reporting(E_ALL);
$result1 = memcache_set($memcache, 'non_existing_test_key', $var, false, 1);
$result2 = @memcache_add($memcache, 'non_existing_test_key', $var, false, 1);
var_dump($result1);
var_dump($result2);
?>
--EXPECT--
bool(true)
bool(false)
tests/021.phpt 0000644 00000002016 15173154500 0007105 0 ustar 00 --TEST--
memcache->set()/memcache->get() with failover
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$var1 = 'test1';
$var2 = 'test2';
$memcache = new Memcache();
$memcache->addServer($host, $port);
$memcache->addServer($nonExistingHost, $nonExistingPort, false, 1, 1, -1);
$result1 = @$memcache->set($balanceKey1, $var1, false, 1);
$result2 = $memcache->set($balanceKey2, $var2, false, 1);
$result3 = $memcache->get($balanceKey1);
$result4 = $memcache->get(array($balanceKey1, $balanceKey2));
var_dump($result1);
var_dump($result2);
var_dump($result3);
var_dump(is_array($result4) ? array_values($result4) : $result4);
$memcache = new Memcache();
$memcache->addServer($nonExistingHost, $nonExistingPort);
$result5 = @$memcache->set($balanceKey1, $var1, false, 1);
$result6 = @$memcache->get($balanceKey1);
var_dump($result5);
var_dump($result6);
?>
--EXPECT--
bool(true)
bool(true)
string(5) "test1"
array(2) {
[0]=>
string(5) "test1"
[1]=>
string(5) "test2"
}
bool(false)
bool(false)
tests/051.phpt 0000644 00000001116 15173154501 0007111 0 ustar 00 --TEST--
memcache->set() with duplicate keys
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$result = $memcache->set('test_key', array('test'));
var_dump($result);
$result = $memcache->set('test_key2', 'test2');
var_dump($result);
$result = $memcache->get(array('test_key', 'test_key'));
var_dump($result);
$result = $memcache->get(array('test_key2', 'test_key2'));
var_dump($result);
?>
--EXPECT--
bool(true)
bool(true)
array(1) {
["test_key"]=>
array(1) {
[0]=>
string(4) "test"
}
}
array(1) {
["test_key2"]=>
string(5) "test2"
}
tests/007.phpt 0000644 00000000705 15173154502 0007116 0 ustar 00 --TEST--
memcache_get_version() & memcache_get_stats()
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$version = memcache_get_version($memcache);
var_dump($version);
$stats = memcache_get_stats($memcache);
if (ini_get('memcache.protocol') == 'binary') {
var_dump($stats === false);
var_dump(1);
}
else {
var_dump(count($stats) > 10);
var_dump(count($stats));
}
?>
--EXPECTF--
string(%d) "%s"
bool(true)
int(%d)
tests/013.phpt 0000644 00000000505 15173154502 0007111 0 ustar 00 --TEST--
memcache->set() & memcache->get() with strange keys
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$var = 'test';
$key = "test\r\n\0 - really strange key";
$memcache->set($key, $var, false, 10);
$result = $memcache->get($key);
var_dump($result);
?>
--EXPECT--
string(4) "test"
tests/024.phpt 0000644 00000001610 15173154503 0007112 0 ustar 00 --TEST--
memcache->close(), memcache->get()
--SKIPIF--
<?php include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); ?>
--FILE--
<?php
include 'connect.inc';
$memcache->addServer($host2, $port2);
$memcache->addServer($nonExistingHost, $nonExistingPort);
$result1 = $memcache->close();
var_dump($result1);
$memcache = new Memcache();
$result2 = $memcache->connect($host, $port);
$result3 = $memcache->set('test_key', 'test', false, 1);
$result4 = $memcache->close();
// This will fail since all servers have been removed
$result5 = $memcache->get('test_key');
// Reconnect server
$result6 = $memcache->connect($host, $port);
$result7 = $memcache->get('test_key');
var_dump($result2);
var_dump($result3);
var_dump($result4);
var_dump($result5);
var_dump($result6);
var_dump($result7);
?>
--EXPECT--
bool(true)
bool(true)
bool(true)
bool(true)
bool(false)
bool(true)
string(4) "test"
tests/023.phpt 0000644 00000003344 15173154505 0007121 0 ustar 00 --TEST--
memcache->delete() with load balancing
--SKIPIF--
<?php include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); ?>
--FILE--
<?php
include 'connect.inc';
$var1 = 'test1';
$var2 = 'test2';
$memcache = new Memcache();
$memcache->addServer($host, $port);
$memcache->addServer($host2, $port2);
$memcache1 = memcache_connect($host, $port);
$memcache2 = memcache_connect($host2, $port2);
$memcache1->set($balanceKey1, '', 0, 10);
$memcache1->set($balanceKey2, '', 0, 10);
$memcache2->set($balanceKey1, '', 0, 10);
$memcache2->set($balanceKey2, '', 0, 10);
$result1 = $memcache->set($balanceKey1, $var1, 0, 10); // hashes to host2
$result2 = $memcache->set($balanceKey2, $var2, 0, 10); // hashes to host1
$result3 = $memcache->get($balanceKey1);
$result4 = $memcache->get($balanceKey2);
var_dump($result1);
var_dump($result2);
var_dump($result3);
var_dump($result4);
print "\r\n";
$result5 = $memcache1->get($balanceKey1);
$result6 = $memcache1->get($balanceKey2);
$result7 = $memcache2->get($balanceKey1);
$result8 = $memcache2->get($balanceKey2);
var_dump($result5);
var_dump($result6);
var_dump($result7);
var_dump($result8);
print "\r\n";
$result9 = $memcache->delete($balanceKey1);
$result10 = $memcache->get($balanceKey1);
$result11 = $memcache2->get($balanceKey1);
var_dump($result9);
var_dump($result10);
var_dump($result11);
$result12 = $memcache->delete($balanceKey2);
$result13 = $memcache->get($balanceKey2);
$result14 = $memcache1->get($balanceKey2);
var_dump($result12);
var_dump($result13);
var_dump($result14);
?>
--EXPECT--
bool(true)
bool(true)
string(5) "test1"
string(5) "test2"
string(0) ""
string(5) "test2"
string(5) "test1"
string(0) ""
bool(true)
bool(false)
bool(false)
bool(true)
bool(false)
bool(false)
tests/026.phpt 0000644 00000001245 15173154505 0007122 0 ustar 00 --TEST--
memcache->delete() with load balancing
--SKIPIF--
<?php include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); ?>
--FILE--
<?php
include 'connect.inc';
$var = 'test';
$memcache->addServer($host2, $port2);
$result1 = $memcache->set('delete_fail_key1', $var, false, 1);
$result2 = $memcache->delete('delete_fail_key1');
$result3 = $memcache->delete('delete_fail_key2');
var_dump($result1);
var_dump($result2);
var_dump($result3);
$memcache = new Memcache();
$memcache->addServer($nonExistingHost, $nonExistingPort);
$result4 = @$memcache->delete('delete_fail_key1');
var_dump($result4);
?>
--EXPECT--
bool(true)
bool(true)
bool(false)
bool(false)
tests/100a.phpt 0000644 00000002315 15173154506 0007254 0 ustar 00 --TEST--
memcache_flush()
--SKIPIF--
<?php
if (PHP_VERSION_ID < 80000)
die('skip php 8+ only');
include 'connect.inc'; ?>
--FILE--
<?php
// This test must be run last or some concurrency problems will occur
// since the "flush_all" seems to be done async and therefore will
// affect subsequent calls to set() done with a second or so.
include 'connect.inc';
$result = @memcache_flush($memcache);
var_dump($result);
memcache_add_server($memcache, $nonExistingHost, $nonExistingPort);
$result = @memcache_flush($memcache);
var_dump($result);
$memcache2 = new Memcache();
$memcache2->addServer($nonExistingHost, $nonExistingPort);
$result = @memcache_flush($memcache2);
var_dump($result);
memcache_close($memcache);
var_dump(memcache_flush($memcache));
try {
var_dump(memcache_flush(new stdClass));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
try {
var_dump(memcache_flush(''));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
echo "Done\n";
?>
--EXPECTF--
bool(true)
bool(false)
bool(false)
bool(true)
memcache_flush(): Argument #1 ($memcache) must be of type MemcachePool, stdClass given
memcache_flush(): Argument #1 ($memcache) must be of type MemcachePool, string given
Done
tests/memcache.sh 0000644 00000000377 15173154507 0010023 0 ustar 00 #!/bin/bash
# basic script to launch memcached for testing
memcached -p11211 -U11211 -d
memcached -p11212 -U11212 -d
# if this fails, make sure your user has permissions
# to write to /var/run/memcached
memcached -s /var/run/memcached/memcached.sock -d
tests/100bphpt 0000644 00000002350 15173154510 0007171 0 ustar 00 --TEST--
memcache_flush()
--SKIPIF--
<?php
if (PHP_VERSION_ID >= 80000)
die('skip php prior to 8 only');
include 'connect.inc'; ?>
--FILE--
<?php
// This test must be run last or some concurrency problems will occur
// since the "flush_all" seems to be done async and therefore will
// affect subsequent calls to set() done with a second or so.
include 'connect.inc';
$result = @memcache_flush($memcache);
var_dump($result);
memcache_add_server($memcache, $nonExistingHost, $nonExistingPort);
$result = @memcache_flush($memcache);
var_dump($result);
$memcache2 = new Memcache();
$memcache2->addServer($nonExistingHost, $nonExistingPort);
$result = @memcache_flush($memcache2);
var_dump($result);
memcache_close($memcache);
var_dump(memcache_flush($memcache));
try {
var_dump(memcache_flush(new stdClass));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
try {
var_dump(memcache_flush(''));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
echo "Done\n";
?>
--EXPECTF--
bool(true)
bool(false)
bool(false)
bool(true)
Argument 1 passed to memcache_flush() must be an instance of MemcachePool, instance of stdClass given
Argument 1 passed to memcache_flush() must be an instance of MemcachePool, string given
Done
tests/githubbug53.phpt 0000644 00000001041 15173154511 0010732 0 ustar 00 --TEST--
Module shouldn't crash on failed serialization
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
class foo {
function __sleep() {
throw new \Exception("fail");
}
}
$oFoo = new foo();
$memcache->set('foobar', $oFoo);
--EXPECTF--
Warning: MemcachePool::set(): Failed to serialize value in %s on line %d
Fatal error: Uncaught Exception: fail in %s:%d
Stack trace:
#0 [internal function]: foo->__sleep()
#1 %s(%d): MemcachePool->set('foobar', Object(foo))
#2 {main}
thrown in %s on line %d
tests/038.phpt 0000644 00000001523 15173154512 0007122 0 ustar 00 --TEST--
memcache->get() over UDP
--SKIPIF--
skip known bug
<?php include 'connect.inc'; if (empty($udpPort)) print 'skip UDP is not enabled in connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$result1 = $memcache->set('test_key1', 'abc', 0, 10);
var_dump($result1);
$result2 = $memcache->set('test_key2', 'def', 0, 10);
var_dump($result2);
$memcacheudp = new MemcachePool();
$memcacheudp->addServer($host, $nonExistingPort, $udpPort);
$result3 = $memcacheudp->get(array('test_key1', 'test_key2'));
var_dump($result3);
$result4 = $memcacheudp->get(array('test_key1'));
var_dump($result4);
$result5 = $memcacheudp->get('test_key2');
var_dump($result5);
?>
--EXPECT--
bool(true)
bool(true)
array(2) {
["test_key1"]=>
string(3) "abc"
["test_key2"]=>
string(3) "def"
}
array(1) {
["test_key1"]=>
string(3) "abc"
}
string(3) "def" tests/056.phpt 0000644 00000003071 15173154513 0007123 0 ustar 00 --TEST--
memcache->addServer() with microsecond timeout
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
function microtime_float()
{
list($usec, $sec) = explode(" ", microtime());
return ((float)$usec + (float)$sec);
}
$memcache = new Memcache();
$memcache->addServer($unreachableHost, $unreachablePort, false, 1, 0.1);
$t1 = microtime_float();
$memcache->set('test_key', '1');
$t2 = microtime_float();
$t = $t2 - $t1;
var_dump($t);
var_dump($t > 0.01 && $t < 0.2);
$memcache = new MemcachePool();
$memcache->addServer($unreachableHost, $unreachablePort, 0, true, 1, 0.1);
$t1 = microtime_float();
$memcache->set('test_key', '1');
$t2 = microtime_float();
$t = $t2 - $t1;
var_dump($t);
var_dump($t > 0.01 && $t < 0.2);
$memcache = new MemcachePool();
$t1 = microtime_float();
$memcache->connect($unreachableHost, $unreachablePort, 0, false, 1, 0.1);
$t2 = microtime_float();
$t = $t2 - $t1;
var_dump($t);
var_dump($t > 0.01 && $t < 0.2);
$memcache = new MemcachePool();
$memcache->addServer($unreachableHost, $unreachablePort, 0, true, 1, 1);
$memcache->setServerParams($unreachableHost, $unreachablePort, 0.1);
$t1 = microtime_float();
$memcache->set('test_key', '1');
$t2 = microtime_float();
$t = $t2 - $t1;
var_dump($t);
var_dump($t > 0.01 && $t < 0.2);
?>
--EXPECTF--
Notice: MemcachePool::set(): %s
float(0.%d)
bool(true)
Notice: MemcachePool::set(): %s
float(0.%d)
bool(true)
Notice: MemcachePool::connect(): %s
Warning: MemcachePool::connect(): %s
float(0.%d)
bool(true)
Notice: MemcachePool::set(): %s
float(0.%d)
bool(true)
tests/006.phpt 0000644 00000000656 15173154514 0007125 0 ustar 00 --TEST--
memcache_increment() & memcache_decrement()
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
memcache_set($memcache, 'new_test', 5);
$result1 = memcache_increment($memcache, 'new_test');
$result2 = memcache_decrement($memcache, 'new_test');
$result3 = memcache_get($memcache, 'new_test');
var_dump($result1);
var_dump($result2);
var_dump($result3);
?>
--EXPECT--
int(6)
int(5)
int(5)
tests/036b.phpt 0000644 00000002723 15173154515 0007270 0 ustar 00 --TEST--
ini_set('session.save_path')
--SKIPIF--
<?php include 'connect.inc'; if (!MEMCACHE_HAVE_SESSION) print 'skip not compiled with session support'; ?>
--FILE--
<?php
include 'connect.inc';
$session_save_path = "tcp://$host:$port?persistent=1&udp_port=0&weight=2&timeout=2&retry_interval=10,tcp://$host2:$port2";
ini_set('session.save_handler', 'memcache');
session_save_path($session_save_path);
$result1 = session_start();
$id = session_id();
$_SESSION['_test_key'] = 'Test';
$result2 = $memcache->get($id);
session_write_close();
$result3 = $memcache->get($id);
// Test destroy
$result4 = session_start();
$result5 = session_destroy();
$result6 = $memcache->get($id);
// Test large session
$session_save_path = "tcp://$host:$port";
session_save_path($session_save_path);
session_start();
$largeval = str_repeat('a', 1024*2048);
$_SESSION['_test_key']= $largeval;
session_write_close();
// test large cookie lifetime
ini_set('session.gc_maxlifetime', 1209600);
$result7 = session_start();
$id = session_id();
$_SESSION['_test_key'] = 'Test';
$result8 = $memcache->get($id);
session_write_close();
$result9 = $memcache->get($id);
var_dump($result1);
var_dump($id);
var_dump($result2);
var_dump($result3);
var_dump($result4);
var_dump($result5);
var_dump($result6);
var_dump($result7);
var_dump($result8);
var_dump($result9);
?>
--EXPECTF--
bool(true)
string(%d) "%s"
bool(false)
string(%d) "%s"
bool(true)
bool(true)
bool(false)
bool(true)
string(%d) "%s"
string(%d) "%s"
tests/pecl17518.phpt 0000644 00000001233 15173154516 0010143 0 ustar 00 --TEST--
PECL bug #17518 (Strange behavior in increment on non integer and after)
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$m = new Memcache();
$m->connect('localhost', 11211);
$m->delete('a');
$m->delete('b');
$m->delete('c');
var_dump($m->increment('a', 42));
var_dump($m->get('a'));
$m->set('b', 'bar');
var_dump($m->increment('b', 42));
var_dump($m->get('b'));
$m->set('c', 1);
var_dump($m->increment('c', 42));
var_dump($m->get('c'));
--EXPECTF--
bool(false)
bool(false)
Notice: MemcachePool::increment(): Server localhost (tcp 11211, udp 0) failed with: %s (%d) in %s
bool(false)
string(3) "bar"
int(43)
int(43)
tests/019b.phpt 0000644 00000001602 15173154517 0007266 0 ustar 00 --TEST--
memcache_add_server()
--SKIPIF--
<?php
if (PHP_VERSION_ID >= 80000)
die('skip php prior to 8 only');
include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); ?>
--FILE--
<?php
include 'connect.inc';
var_dump(memcache_add_server($memcache, $host2, $port2));
var_dump(memcache_add_server($memcache, $nonExistingHost, $nonExistingPort));
try {
var_dump(memcache_add_server(new stdclass, $host2, $port2));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
try {
var_dump(memcache_add_server($memcache, new stdclass, array()));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
echo "Done\n";
?>
--EXPECTF--
bool(true)
bool(true)
Argument 1 passed to memcache_add_server() must be an instance of MemcachePool, instance of stdClass given
Warning: memcache_add_server() expects parameter 2 to be string, object given in %s on line %d
NULL
Done tests/050.phpt 0000644 00000001302 15173154520 0007106 0 ustar 00 --TEST--
failure callback throws exception
--SKIPIF--
<?php include 'connect.inc'; if (version_compare(phpversion(), '5.0.0', '<')) die('skip requires PHP >= 5.0.0'); ?>
--FILE--
<?php
include 'connect.inc';
function _callback_server_failure($host, $tcp_port, $udp_port, $error, $errnum) {
var_dump($host);
throw new Exception('Test2');
}
$memcache = new Memcache();
$memcache->addServer($nonExistingHost, $nonExistingPort, false, 1, 1, 15, true, '_callback_server_failure');
$result = 'Test1';
try {
$result = @$memcache->set('test_key', 'test-032-01');
}
catch (Exception $e) {
var_dump($e->getMessage());
}
var_dump($result);
?>
--EXPECTF--
string(%d) "%s"
string(5) "Test2"
string(5) "Test1"
tests/011.phpt 0000644 00000001052 15173154521 0007106 0 ustar 00 --TEST--
memcache->set()/memcache->get() using compression
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$var = new stdClass;
$var->plain_attribute = 'value';
$var->array_attribute = Array('test1', 'test2');
$memcache->set('test_key', $var, MEMCACHE_COMPRESSED, 10);
$result = $memcache->get('test_key');
var_dump($result);
?>
--EXPECTF--
object(stdClass)%s2) {
["plain_attribute"]=>
string(5) "value"
["array_attribute"]=>
array(2) {
[0]=>
string(5) "test1"
[1]=>
string(5) "test2"
}
}
tests/pecl17566.phpt 0000644 00000000541 15173154522 0010144 0 ustar 00 --TEST--
PECL bug #17566 (3.0.4 cache delete bug)
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$m1 = new Memcache;
$m1->connect($host, $port);
$m1->set("test", "123");
$m1->delete("test");
$m2 = new Memcache;
$m2->connect($host, $port);
var_dump($m2->get("test"));
echo "Done\n";
?>
--EXPECTF--
bool(false)
Done
tests/pecl16536.phpt 0000644 00000000526 15173154523 0010144 0 ustar 00 --TEST--
PECL bug #16536 (Weight of 0 causes SegFault on memcache_add_server)
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$mmc = new Memcache;
var_dump(@$mmc->addServer($host, $port, true, 0));
var_dump(@$mmc->set('TEST_KEY', 'test_value'));
echo "Done\n";
?>
--EXPECTF--
bool(false)
bool(false)
Done
tests/019a.phpt 0000644 00000001524 15173154524 0007266 0 ustar 00 --TEST--
memcache_add_server()
--SKIPIF--
<?php
if (PHP_VERSION_ID < 80000)
die('skip php 8+ only');
include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); ?>
--FILE--
<?php
include 'connect.inc';
var_dump(memcache_add_server($memcache, $host2, $port2));
var_dump(memcache_add_server($memcache, $nonExistingHost, $nonExistingPort));
try {
var_dump(memcache_add_server(new stdclass, $host2, $port2));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
try {
var_dump(memcache_add_server($memcache, new stdclass, array()));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
echo "Done\n";
?>
--EXPECTF--
bool(true)
bool(true)
memcache_add_server(): Argument #1 ($memcache) must be of type Memcache, stdClass given
memcache_add_server(): Argument #2 ($host) must be of type string, stdClass given
Done
tests/010.phpt 0000644 00000001145 15173154525 0007114 0 ustar 00 --TEST--
memcache->get() function
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$value = new stdClass;
$value->plain_attribute = 'value';
$value->array_attribute = array('test1', 'test2');
$memcache->set('test_key', $value);
$result = $memcache->get('test_key');
var_dump($result);
$result = $memcache->get(array('unset_test_key', 'unset_test_key1'));
var_dump($result);
?>
--EXPECTF--
object(stdClass)%s2) {
["plain_attribute"]=>
string(5) "value"
["array_attribute"]=>
array(2) {
[0]=>
string(5) "test1"
[1]=>
string(5) "test2"
}
}
array(0) {
}
tests/054.phpt 0000644 00000001075 15173154525 0007126 0 ustar 00 --TEST--
memcache->set() with value larger than MTU
--SKIPIF--
<?php include 'connect.inc'; if (!MEMCACHE_HAVE_SESSION) print 'skip not compiled with session support'; if (empty($domainsocket)) print 'skip $domainsocket not set'; ?>
--FILE--
<?php
include 'connect.inc';
ini_set('memcache.chunk_size', 32768);
$memcache->setCompressThreshold(1000000, 1.0);
$value = str_repeat('a', 64 * 1024);
$result = $memcache->set('test_key', $value, 0, 2);
var_dump($result);
$result2 = $memcache->get('test_key');
var_dump(strlen($result2));
?>
--EXPECTF--
bool(true)
int(65536) tests/052.phpt 0000644 00000001143 15173154526 0007121 0 ustar 00 --TEST--
memcache->connect() and memcache->close() in loop
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$start = time();
$count = 100;
$memcache = new Memcache();
$memcache->connect($host, $port);
$key = 'test_key';
$memcache->set($key, 'test');
$memcache->close();
for ($i=0; $i<$count; $i++) {
$memcache->connect($host, $port);
$result = $memcache->get($key);
if (!$result) {
printf('Failed to fetch value for iteration %d', $i);
}
$memcache->close();
}
$end = time();
if (($end - $start) < 2) {
echo "true";
} else {
echo "false";
}
?>
--EXPECT--
true
tests/036.phpt 0000644 00000002776 15173154527 0007141 0 ustar 00 --TEST--
ini_set('session.save_handler')
--SKIPIF--
<?php include 'connect.inc'; if (!MEMCACHE_HAVE_SESSION) print 'skip not compiled with session support'; ?>
--FILE--
<?php
include 'connect.inc';
$session_save_path = "tcp://$host:$port?persistent=1&udp_port=0&weight=2&timeout=2&retry_interval=10,tcp://$host2:$port2";
ini_set('session.save_handler', 'memcache');
ini_set('memcache.session_save_path', $session_save_path);
$result1 = session_start();
$id = session_id();
$_SESSION['_test_key'] = 'Test';
$result2 = $memcache->get($id);
session_write_close();
$result3 = $memcache->get($id);
// Test destroy
$result4 = session_start();
$result5 = session_destroy();
$result6 = $memcache->get($id);
// Test large session
$session_save_path = "tcp://$host:$port";
ini_set('memcache.session_save_path', $session_save_path);
session_start();
$largeval = str_repeat('a', 1024*2048);
$_SESSION['_test_key']= $largeval;
session_write_close();
// test large cookie lifetime
ini_set('session.gc_maxlifetime', 1209600);
$result7 = session_start();
$id = session_id();
$_SESSION['_test_key'] = 'Test';
$result8 = $memcache->get($id);
session_write_close();
$result9 = $memcache->get($id);
var_dump($result1);
var_dump($id);
var_dump($result2);
var_dump($result3);
var_dump($result4);
var_dump($result5);
var_dump($result6);
var_dump($result7);
var_dump($result8);
var_dump($result9);
?>
--EXPECTF--
bool(true)
string(%d) "%s"
bool(false)
string(%d) "%s"
bool(true)
bool(true)
bool(false)
bool(true)
string(%d) "%s"
string(%d) "%s"
tests/024a.phpt 0000644 00000002474 15173154530 0007264 0 ustar 00 --TEST--
memcache_close(), memcache_get()
--SKIPIF--
<?php
if (PHP_VERSION_ID < 80000)
die('skip php 8+ only');
include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); ?>
--FILE--
<?php
include 'connect.inc';
memcache_add_server($memcache, $host2, $port2);
memcache_add_server($memcache, $nonExistingHost, $nonExistingPort);
$result1 = memcache_close($memcache);
var_dump($result1);
$memcache = new Memcache();
$result2 = $memcache->connect($host, $port);
$result3 = memcache_set($memcache, 'test_key', 'test', false, 1);
$result4 = memcache_close($memcache);
// This will fail since all servers have been removed
$result5 = memcache_get($memcache, 'test_key');
var_dump($result2);
var_dump($result3);
var_dump($result4);
var_dump($result5);
var_dump(memcache_close($memcache));
var_dump(memcache_close($memcache));
try {
var_dump(memcache_close(new stdClass));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
try {
var_dump(memcache_close(""));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
echo "Done\n";
?>
--EXPECTF--
bool(true)
bool(true)
bool(true)
bool(true)
bool(false)
bool(true)
bool(true)
memcache_close(): Argument #1 ($memcache) must be of type MemcachePool, stdClass given
memcache_close(): Argument #1 ($memcache) must be of type MemcachePool, string given
Done
tests/015.phpt 0000644 00000000665 15173154531 0007124 0 ustar 00 --TEST--
memcache->getVersion() & memcache->getStats()
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$version = $memcache->getVersion();
var_dump($version);
$stats = $memcache->getStats();
if (ini_get('memcache.protocol') == 'binary') {
var_dump($stats === false);
var_dump(1);
}
else {
var_dump(count($stats) > 10);
var_dump(count($stats));
}
?>
--EXPECTF--
string(%d) "%s"
bool(true)
int(%d)
tests/035.phpt 0000644 00000001407 15173154533 0007123 0 ustar 00 --TEST--
memcache::connect() with unix domain socket
--SKIPIF--
<?php include 'connect.inc'; if (!isset($domainsocket)) die('skip $domainsocket not set'); if (ini_get('memcache.protocol') == 'binary') die('skip binary protocol does not support unix domain sockets'); ?>
--FILE--
<?php
include 'connect.inc';
$memcache = new Memcache();
$result = $memcache->addServer($domainsocket, 0);
var_dump($result);
$result1 = $memcache->set('test_key', 'abc');
$result2 = $memcache->get('test_key');
var_dump($result1);
var_dump($result2);
$memcache = new Memcache();
$result = $memcache->connect($domainsocket, 0);
var_dump($result);
$memcache = memcache_connect($domainsocket, null);
var_dump($result);
?>
--EXPECTF--
bool(true)
bool(true)
string(3) "abc"
bool(true)
bool(true) tests/100.phpt 0000644 00000001672 15173154534 0007121 0 ustar 00 --TEST--
memcache->flush()
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
// This test must be run last or some concurrency problems will occur
// since the "flush_all" seems to be done async and therefore will
// affect subsequent calls to set() done with a second or so.
include 'connect.inc';
// Test flush in future
$memcache = new Memcache();
$memcache->addServer($host, $port);
$result1 = $memcache->set('test_key', 'abc');
$result2 = $memcache->get('test_key');
var_dump($result1);
var_dump($result2);
// Test partly failing flush
$memcache = new Memcache();
$memcache->addServer($host, $port);
$memcache->addServer($nonExistingHost, $nonExistingPort);
$result = @$memcache->flush();
var_dump($result);
// Test failing flush
$memcache = new Memcache();
$memcache->addServer($nonExistingHost, $nonExistingPort);
$result = @$memcache->flush();
var_dump($result);
?>
--EXPECT--
bool(true)
string(3) "abc"
bool(false)
bool(false)
tests/019.phpt 0000644 00000003166 15173154535 0007133 0 ustar 00 --TEST--
memcache->addServer()
--SKIPIF--
<?php include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); ?>
--FILE--
<?php
include 'connect.inc';
$var = 'test';
$memcache = new Memcache();
$result1 = @$memcache->set('test_key', 'test');
$result2 = @$memcache->get('test_key');
var_dump($result1);
var_dump($result2);
$result1 = $memcache->addServer($host, $port, true, 1, 1, 15);
$result2 = $memcache->connect($host2, $port2);
$result3 = $memcache->set('non_existing_test_key', $var, false, 1);
$result4 = $memcache->get('non_existing_test_key');
$result5 = $memcache->getExtendedStats();
var_dump($result1);
var_dump($result2);
var_dump($result3);
var_dump($result4);
var_dump(count($result5));
// Test default port
$memcache = new Memcache();
ini_set('memcache.default_port', $port);
$result1 = $memcache->addServer($host);
ini_set('memcache.default_port', $port2);
$result2 = $memcache->connect($host2);
$result3 = $memcache->set($balanceKey1, 'a');
$result4 = $memcache->set($balanceKey2, 'b');
var_dump($result1);
var_dump($result2);
var_dump($result3);
var_dump($result4);
// Test empty connection
$memcache = new Memcache();
$memcache->set('test_key', '1');
// Test bad connection id
$memcache = new Memcache();
$memcache->connect($host, $port);
var_dump($memcache->connection);
$memcache->connection = true;
$memcache->set('test_key', '1');
?>
--EXPECTF--
bool(false)
bool(false)
bool(true)
bool(true)
bool(true)
string(4) "test"
int(2)
bool(true)
bool(true)
bool(true)
bool(true)
Warning: %s::set(): No servers added %s
resource(%d) of type (memcache connection)
Warning: %s::set(): Invalid %s member variable %s
tests/037.phpt 0000644 00000000746 15173154536 0007135 0 ustar 00 --TEST--
ini_set('memcache.hash_strategy')
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
ini_set('memcache.hash_strategy', 'standard');
var_dump(ini_get('memcache.hash_strategy'));
ini_set('memcache.hash_strategy', 'consistent');
var_dump(ini_get('memcache.hash_strategy'));
@ini_set('memcache.hash_strategy', 'abs');
var_dump(ini_get('memcache.hash_strategy'));
?>
--EXPECTF--
string(8) "standard"
string(10) "consistent"
string(10) "consistent" tests/048.phpt 0000644 00000001330 15173154537 0007126 0 ustar 00 --TEST--
memcache->get(), set() with CAS
--SKIPIF--
<?php include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); ?>
--FILE--
<?php
include 'connect.inc';
$result = $memcache->set('test_key', 'a');
var_dump($result);
$cas = null;
$flags = null;
$result = $memcache->get('test_key', $flags, $cas);
var_dump($result);
var_dump($cas);
$result1 = $memcache->cas('test_key', 'b', 0, 0, $cas + 1);
$result2 = $memcache->get('test_key');
var_dump($result1);
var_dump($result2);
$result1 = $memcache->cas('test_key', 'b', 0, 0, $cas);
$result2 = $memcache->get('test_key');
var_dump($result1);
var_dump($result2);
?>
--EXPECTF--
bool(true)
string(1) "a"
int(%s%d)
bool(false)
string(1) "a"
bool(true)
string(1) "b"
tests/027b.phpt 0000644 00000004034 15173154540 0007263 0 ustar 00 --TEST--
memcache_set_compress_threshold()
--SKIPIF--
<?php
if (PHP_VERSION_ID >= 80000)
die('skip php prior to 8 only');
include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$var = str_repeat('abc', 5000);
memcache_set_compress_threshold($memcache, 10000);
$result1 = memcache_set($memcache, 'non_existing_test_key', $var, 0, 1);
$result2 = memcache_get($memcache, 'non_existing_test_key');
var_dump($result1);
var_dump(strlen($result2));
memcache_set_compress_threshold($memcache, 10000, 0);
$result3 = memcache_set($memcache, 'non_existing_test_key', $var, 0, 1);
memcache_set_compress_threshold($memcache, 10000, 1);
$result4 = memcache_set($memcache, 'non_existing_test_key', $var, 0, 1);
var_dump($result3);
var_dump($result4);
$result5 = memcache_set($memcache, 'non_existing_test_key', 'abc', MEMCACHE_COMPRESSED, 1);
$result6 = memcache_get($memcache, 'non_existing_test_key');
var_dump($result5);
var_dump($result6);
try {
var_dump(memcache_set_compress_threshold(array(), 10000, 0));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
var_dump(memcache_set_compress_threshold($memcache, -1, -1));
var_dump(memcache_set_compress_threshold($memcache, 1, -1));
var_dump(memcache_set_compress_threshold($memcache, -1, 1));
try {
var_dump(memcache_set_compress_threshold(new stdClass, 1, 1));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
echo "Done\n";
?>
--EXPECTF--
bool(true)
int(15000)
bool(true)
bool(true)
bool(true)
string(3) "abc"
Argument 1 passed to memcache_set_compress_threshold() must be an instance of MemcachePool, array given
Warning: memcache_set_compress_threshold()%s threshold must be a positive integer in %s on line %d
bool(false)
Warning: memcache_set_compress_threshold()%s min_savings must be a float in the 0..1 range in %s on line %d
bool(false)
Warning: memcache_set_compress_threshold()%s threshold must be a positive integer in %s on line %d
bool(false)
Argument 1 passed to memcache_set_compress_threshold() must be an instance of MemcachePool, instance of stdClass given
Done
tests/001b.phpt 0000644 00000001405 15173154541 0007253 0 ustar 00 --TEST--
memcache_set() function
--SKIPIF--
<?php
if (PHP_VERSION_ID >= 80000)
die('skip php prior to 8 only');
include 'connect.inc';
--FILE--
<?php
include 'connect.inc';
$value = new stdClass;
$value->plain_attribute = 'value';
$value->array_attribute = array('test1', 'test2');
memcache_set($memcache, 'test_key', $value, false, 10);
$key = 123;
$value = 123;
memcache_set($memcache, $key, $value, false, 10);
var_dump($key);
var_dump($value);
try {
memcache_set($memcache, $key);
} catch (ArgumentCountError $e) {
echo "{$e->getMessage()}\n";
}
try {
$memcache->set($key);
} catch (ArgumentCountError $e) {
echo "{$e->getMessage()}\n";
}
echo "Done\n";
?>
--EXPECTF--
int(123)
int(123)
Warning: %s parameter%s
Warning: %s parameter%s
Done tests/041.phpt 0000644 00000002002 15173154541 0007107 0 ustar 00 --TEST--
memcache->delete() with multiple keys
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$memcache = test_connect_pool();
$memcache->set($balanceKey1, 'abc');
$memcache->set($balanceKey2, 'def');
$result1 = $memcache->get($balanceKey1);
$result2 = $memcache->get($balanceKey2);
var_dump($result1);
var_dump($result2);
$result = $memcache->delete(array($balanceKey1, $balanceKey2));
var_dump($result);
$result1 = $memcache->get($balanceKey1);
$result2 = $memcache->get($balanceKey2);
var_dump($result1);
var_dump($result2);
print "\n";
$key = 'test_key';
$values = array();
for ($i=0; $i<250; $i++) {
$values[$key.$i] = $key.'_value_'.$i;
}
$result1 = $memcache->set($values, null, 0, 10);
var_dump($result1);
$result2 = memcache_delete($memcache, array_keys($values));
var_dump($result1);
$result3 = $memcache->get(array_keys($values));
var_dump($result3);
?>
--EXPECT--
string(3) "abc"
string(3) "def"
bool(true)
bool(false)
bool(false)
bool(true)
bool(true)
array(0) {
}
tests/pecl16442.phpt 0000644 00000000551 15173154542 0010137 0 ustar 00 --TEST--
PECL bug #16442 (memcache_set fail with integer value)
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$memcache_obj = memcache_connect('localhost', 11211);
memcache_set($memcache_obj, 'test123112', 1, MEMCACHE_COMPRESSED, 30);
$ret = memcache_get($memcache_obj, 'test123112');
var_dump($ret);
?>
--EXPECTF--
int(1)
tests/pecl77900.phpt 0000644 00000000655 15173154543 0010153 0 ustar 00 --TEST--
PECL Bug #77900 (Memcache session handling, zend_mm_heap corrupted)
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
ini_set('session.save_handler', 'memcache');
ini_set('session.save_path', "tcp://$host:$port");
session_start();
$_SESSION['test']=true;
session_write_close();
session_start();
var_dump($_SESSION);
session_write_close();
--EXPECT--
array(1) {
["test"]=>
bool(true)
} tests/032.phpt 0000644 00000004017 15173154544 0007122 0 ustar 00 --TEST--
memcache->getServerStatus(), memcache->setServerParams()
--SKIPIF--
<?php include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); ?>
--FILE--
<?php
include 'connect.inc';
// Run hash destination test
$memcache = new Memcache();
$memcache->addServer($host, $port, false);
$memcache->addServer($host2, $port2, false);
$memcache1 = memcache_connect($host, $port);
$memcache2 = memcache_pconnect($host2, $port2);
$memcache1->set($balanceKey1, '', false, 2);
$memcache1->set($balanceKey2, '', false, 2);
$memcache2->set($balanceKey1, '', false, 2);
$memcache2->set($balanceKey2, '', false, 2);
$result1 = $memcache->set($balanceKey1, 'test-030-01', false, 2); // hashes to $host2
$result2 = $memcache->set($balanceKey2, 'test-030-02', false, 2); // hashes to $host1
var_dump($result1);
var_dump($result2);
$result4 = $memcache1->get($balanceKey1); // return false; key1 is at $host2
$result5 = $memcache1->get($balanceKey2);
$result6 = $memcache2->get($balanceKey1);
$result7 = $memcache2->get($balanceKey2); // return false; key2 is at $host1
var_dump($result4);
var_dump($result5);
var_dump($result6);
var_dump($result7);
// Add server in failed mode
$memcache = new Memcache();
$memcache->addServer($host, $port, false);
$memcache->addServer($host2, $port2, false, 1, 1, -1, false);
$result8 = $memcache->getServerStatus($host, $port);
$result9 = $memcache->getServerStatus($host2, $port2);
var_dump($result8);
var_dump($result9);
// Hot-add failed server
$result10 = $memcache->setServerParams($host2, $port2, 1, 15, true);
$result11 = $memcache->getServerStatus($host2, $port2);
var_dump($result10);
var_dump($result11);
$result12 = $memcache->set($balanceKey1, 'test-030-03', false, 1); // hashes to $host2
$result13 = $memcache2->get($balanceKey1); // key should be at $host2 (reconnected $host2)
var_dump($result12);
var_dump($result13);
?>
--EXPECT--
bool(true)
bool(true)
string(0) ""
string(11) "test-030-02"
string(11) "test-030-01"
string(0) ""
int(1)
int(0)
bool(true)
int(1)
bool(true)
string(11) "test-030-03"
tests/039.phpt 0000644 00000001426 15173154545 0007133 0 ustar 00 --TEST--
memcache->get() over multi-datagram UDP
--SKIPIF--
<?php include 'connect.inc'; if (empty($udpPort)) print 'skip UDP is not enabled in connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$key = 'test_key';
$keys = array();
// About 4 datagrams or so
for ($i=0; $i < $udpPacketSize/strlen($key)*3; $i++) {
$memcache->set($key.$i, $key.'_value_'.$i, 0, 10);
$keys[] = $key.$i;
}
$memcacheudp = new MemcachePool();
$memcacheudp->addServer($host, $nonExistingPort, $udpPort);
$result1 = $memcacheudp->get($keys);
ksort($result1);
var_dump(count($result1));
var_dump(count($result1) == count($keys));
var_dump(reset($result1));
$result2 = array_keys($result1);
var_dump(reset($result2));
?>
--EXPECTF--
int(%d)
bool(true)
string(16) "test_key_value_0"
string(9) "test_key0" tests/012.phpt 0000644 00000000763 15173154545 0007125 0 ustar 00 --TEST--
memcache_add() & memcache_replace()
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$var = new stdClass;
$var->plain_attribute = 'value';
$var->array_attribute = Array('test1', 'test2');
$result1 = $memcache->add('non_existing_test_key2', $var, false, 2);
$result2 = $memcache->replace('non_existing_test_key2', $var, false, 10);
var_dump($result1);
var_dump($result2);
$memcache->delete('non_existing_test_key2');
?>
--EXPECT--
bool(true)
bool(true)
tests/033.phpt 0000644 00000007606 15173154546 0007134 0 ustar 00 --TEST--
memcache->addServer() with server failure callback
--SKIPIF--
<?php include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); ?>
--FILE--
<?php
include 'connect.inc';
function _callback_server_failure($host, $tcp_port, $udp_port, $error, $errnum) {
var_dump($host);
var_dump($tcp_port);
var_dump($udp_port);
var_dump($error);
var_dump($errnum);
global $memcache;
$memcache->setServerParams($host, $tcp_port, 1, -1, false, '_callback_server_failure');
}
// Test function callback using addServer()
$memcache = new Memcache();
$memcache->addServer($nonExistingHost, $nonExistingPort, false, 1, 1, 15, true, '_callback_server_failure');
$result1 = $memcache->set('test_key', 'test-032-01');
var_dump($result1);
class MemcachedFailureHandler {
function _callback_server_failure($host, $tcp_port, $udp_port, $error, $errnum) {
var_dump($host);
var_dump($tcp_port);
var_dump($udp_port);
var_dump($error);
var_dump($errnum);
}
}
// Test OO callback using setServerParams()
$memcache = new Memcache();
$memcache->addServer($nonExistingHost, $nonExistingPort, false);
$result2 = $memcache->setServerParams($nonExistingHost, $nonExistingPort, 1, 15, true,
array(new MemcachedFailureHandler(), '_callback_server_failure'));
var_dump($result2);
$result3 = $memcache->set('test_key', 'test-032-01');
var_dump($result3);
// Test giving non-existing callback to addServer()
$memcache = new Memcache();
$result4 = @$memcache->addServer($nonExistingHost, $nonExistingPort, false, 1, 1, 15, true, 'non_existing_user_function');
var_dump($result4);
// Test giving non-existing callback to setServerParams()
$memcache = new Memcache();
$memcache->addServer($nonExistingHost, $nonExistingPort, false);
$result5 = @$memcache->setServerParams($nonExistingHost, $nonExistingPort, 1, 15, true, 'non_existing_user_function');
var_dump($result5);
// Test self-referencing callback
class MyMemcache extends Memcache {
function _callback_server_failure($host, $tcp_port, $udp_port, $error, $errnum) {
var_dump($host);
}
}
$memcache = new MyMemcache();
$memcache->addServer($nonExistingHost, $nonExistingPort, false);
$result6 = $memcache->setServerParams($nonExistingHost, $nonExistingPort, 1, 15, true,
array($memcache, '_callback_server_failure'));
$result7 = @$memcache->set('test_key', 'test-032-01');
var_dump($result6);
var_dump($result7);
// Test resetting callback to null
$memcache = new Memcache();
$memcache->addServer($nonExistingHost, $nonExistingPort, false, 1, 1, 15, true, '_callback_server_failure');
$result8 = $memcache->setServerParams($nonExistingHost, $nonExistingPort, 1, 15, true, null);
$result9 = @$memcache->set('test_key', 'test-032-01');
var_dump($result8);
var_dump($result9);
// Test MemcachePool::setFailureCallback()
function _callback_server_failure2($host, $tcp_port, $udp_port, $error, $errnum) {
var_dump($error);
}
$memcache = new MemcachePool();
$memcache->addServer($nonExistingHost, $nonExistingPort);
$result8 = $memcache->setFailureCallback('_callback_server_failure2');
$result9 = @$memcache->set('test_key', 'test-032-01');
var_dump($result8);
var_dump($result9);
$result8 = $memcache->setFailureCallback(null);
$result9 = @$memcache->set('test_key', 'test-032-01');
var_dump($result8);
var_dump($result9);
// Test refcount
function test_connect() {
global $mc, $nonExistingHost, $nonExistingPort;
$mc = new Memcache();
$mc->addServer($nonExistingHost, $nonExistingPort, false, 1, 1, 15, true, '_callback_server_failure2');
}
test_connect();
$result10 = $mc->set('test_key', 'test-032-02');
var_dump($result10);
?>
--EXPECTF--
string(%d) "%s"
int(%d)
int(%d)
string(%d) "Connection %s"
int(%d)
bool(false)
bool(true)
string(%d) "%s"
int(%d)
int(%d)
string(%d) "Connection %s"
int(%d)
bool(false)
bool(false)
bool(false)
string(%d) "%s"
bool(true)
bool(false)
bool(true)
bool(false)
string(%d) "%s"
bool(true)
bool(false)
bool(true)
bool(false)
string(%d) "Connection %s"
bool(false)
tests/008.phpt 0000644 00000000456 15173154547 0007133 0 ustar 00 --TEST--
memcache_delete()
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
memcache_set($memcache, 'test', 'test');
memcache_delete($memcache, 'test', 10);
/* the item should be still there */
memcache_delete($memcache, 'test');
echo "Done\n";
?>
--EXPECT--
Done
tests/022a.phpt 0000644 00000002461 15173154550 0007260 0 ustar 00 --TEST--
memcache_get_extended_stats()
--SKIPIF--
<?php
if (PHP_VERSION_ID < 80000)
die('skip php 8+ only');
include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); if (ini_get('memcache.protocol') == 'binary') die('skip binary protocol does not support stats');
--FILE--
<?php
include 'connect.inc';
$memcache = new Memcache();
memcache_add_server($memcache, $nonExistingHost, $nonExistingPort);
memcache_add_server($memcache, $host, $port);
memcache_add_server($memcache, $host2, $port2);
$result1 = @memcache_get_stats($memcache);
$result2 = @memcache_get_extended_stats($memcache);
try {
var_dump(memcache_get_extended_stats(array()));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
try {
var_dump(memcache_get_extended_stats(new stdClass));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
var_dump($result1['pid']);
var_dump(count($result2));
var_dump($result2["$host:$port"]['pid']);
var_dump($result2["$host2:$port2"]['pid']);
var_dump($result2["$nonExistingHost:$nonExistingPort"]);
?>
--EXPECTF--
memcache_get_extended_stats(): Argument #1 ($memcache) must be of type MemcachePool, array given
memcache_get_extended_stats(): Argument #1 ($memcache) must be of type MemcachePool, stdClass given
string(%d) "%d"
int(3)
string(%d) "%d"
string(%d) "%d"
bool(false)
tests/100c.phpt 0000644 00000002444 15173154550 0007260 0 ustar 00 --TEST--
memcache->flush() with time in future
--SKIPIF--
<?php include 'connect.inc'; if (ini_get('memcache.protocol') == 'binary') die('skip binary protocol doesn\'t support append/prepend'); ?>
--FILE--
<?php
// This test must be run last or some concurrency problems will occur
// since the "flush_all" seems to be done async and therefore will
// affect subsequent calls to set() done with a second or so.
include 'connect.inc';
// Test flush in future
$memcache = new Memcache();
$memcache->addServer($host, $port);
$result1 = $memcache->set('test_key', 'abc');
$result2 = $memcache->get('test_key');
var_dump($result1);
var_dump($result2);
$result = $memcache->flush(time()+3);
var_dump($result);
sleep(1);
$result = $memcache->get('test_key');
var_dump($result);
sleep(3);
$result = $memcache->get('test_key');
var_dump($result);
// Test partly failing flush
$memcache = new Memcache();
$memcache->addServer($host, $port);
$memcache->addServer($nonExistingHost, $nonExistingPort);
$result = @$memcache->flush();
var_dump($result);
// Test failing flush
$memcache = new Memcache();
$memcache->addServer($nonExistingHost, $nonExistingPort);
$result = @$memcache->flush();
var_dump($result);
?>
--EXPECT--
bool(true)
string(3) "abc"
bool(true)
string(3) "abc"
bool(false)
bool(false)
bool(false)
tests/022.phpt 0000644 00000002041 15173154551 0007112 0 ustar 00 --TEST--
memcache->getExtendedStats()
--SKIPIF--
<?php include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); if (ini_get('memcache.protocol') == 'binary') die('skip binary protocol does not support stats'); ?>
--FILE--
<?php
include 'connect.inc';
$memcache = new MemcachePool();
$memcache->addServer($nonExistingHost, $nonExistingPort);
$memcache->addServer($host, $port);
$memcache->addServer($host2, $port2);
$result1 = @$memcache->getStats();
$result2 = @$memcache->getExtendedStats();
$result3 = @$memcache->getExtendedStats();
var_dump($result1['pid']);
var_dump(count($result2));
var_dump($result2["$host:$port"]['pid']);
var_dump($result2["$host2:$port2"]['pid']);
var_dump($result2["$nonExistingHost:$nonExistingPort"]);
var_dump(count($result3));
var_dump($result3["$host:$port"]['pid']);
var_dump($result3["$host2:$port2"]['pid']);
var_dump($result3["$nonExistingHost:$nonExistingPort"]);
?>
--EXPECTF--
string(%d) "%d"
int(3)
string(%d) "%d"
string(%d) "%d"
bool(false)
int(3)
string(%d) "%d"
string(%d) "%d"
bool(false)
tests/githubbug13.phpt 0000644 00000000721 15173154552 0010737 0 ustar 00 --TEST--
session_regenerate_id() should not cause fatal error
--SKIPIF--
<?php include 'connect.inc'; if (!MEMCACHE_HAVE_SESSION) print 'skip not compiled with session support'; ?>
--FILE--
<?php
include 'connect.inc';
$session_save_path = "tcp://$host:$port,tcp://$host2:$port2";
ini_set('session.save_handler', 'memcache');
ini_set('memcache.session_save_path', $session_save_path);
session_start();
var_dump(session_regenerate_id());
?>
--EXPECTF--
bool(true) tests/055.phpt 0000644 00000001401 15173154553 0007121 0 ustar 00 --TEST--
memcache->set()/get() datatype preservation
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$memcache->set('test_key', '1');
$result = $memcache->get('test_key');
var_dump($result);
$memcache->set('test_key', 1);
$result = $memcache->get('test_key');
var_dump($result);
$memcache->set('test_key', true);
$result = $memcache->get('test_key');
var_dump($result);
$memcache->set('test_key', false);
$result = $memcache->get('test_key');
var_dump($result);
$memcache->set('test_key', 1.1);
$result = $memcache->get('test_key');
var_dump($result);
$memcache->set('test_key', '1', 0x10);
?>
--EXPECTF--
string(1) "1"
int(1)
bool(true)
bool(false)
float(1.1)
Warning: MemcachePool::set(): The lowest two bytes of the flags %s tests/044.phpt 0000644 00000003464 15173154554 0007133 0 ustar 00 --TEST--
ini_set('memcache.session_redundancy')
--SKIPIF--
<?php
include 'connect.inc';
?>
--FILE--
<?php
ob_start();
include 'connect.inc';
ini_set('session.use_strict_mode', 0);
ini_set('memcache.session_redundancy', 2);
ini_set('session.save_handler', 'memcache');
ini_set('memcache.session_save_path', "tcp://$host:$port?udp_port=$udpPort, tcp://$host2:$port2?udp_port=$udpPort2");
$memcache1 = test_connect1();
$memcache2 = test_connect2();
$memcache1->delete($balanceKey1);
$memcache1->delete($balanceKey2);
$memcache2->delete($balanceKey1);
$memcache2->delete($balanceKey2);
// Test set
session_id($balanceKey1);
session_start();
$_SESSION['key'] = 'Test1';
session_write_close();
$result1 = $memcache1->get($balanceKey1);
$result2 = $memcache2->get($balanceKey1);
var_dump($result1);
var_dump($result2);
// Test delete
session_id($balanceKey1);
session_start();
session_destroy();
$result1 = $memcache1->get($balanceKey1);
$result2 = $memcache2->get($balanceKey1);
var_dump($result1);
var_dump($result2);
// Test lost session on server1
session_id($balanceKey1);
session_start();
$_SESSION['key'] = 'Test2';
session_write_close();
unset($_SESSION['key']);
$result = $memcache1->delete($balanceKey1);
var_dump($result);
session_id($balanceKey1);
@session_start();
var_dump($_SESSION);
session_write_close();
// Test lost session on server2
session_id($balanceKey2);
session_start();
$_SESSION['key'] = 'Test3';
session_write_close();
unset($_SESSION['key']);
$result = $memcache2->delete($balanceKey1);
var_dump($result);
session_id($balanceKey2);
session_start();
var_dump($_SESSION);
session_write_close();
ob_flush();
?>
--EXPECTF--
string(16) "key%sTest1%s"
string(16) "key%sTest1%s"
bool(false)
bool(false)
bool(true)
array(1) {
["key"]=>
string(5) "Test2"
}
bool(true)
array(1) {
["key"]=>
string(5) "Test3"
}
tests/connect.inc 0000644 00000004544 15173154554 0010053 0 ustar 00 <?php
if (!extension_loaded("memcache")) {
die("skip memcache module not loaded");
}
error_reporting(E_ALL);
/*
* Please change host & port to match your configuration
*/
$host = "localhost";
$port = 11211;
//$udpPort = 11211;
$host2 = "localhost";
$port2 = 11212;
//$udpPort2 = 11212;
//ini_set('memcache.hash_strategy', 'standard');
//ini_set('memcache.hash_function', 'fnv');
ini_set('memcache.protocol', getenv('MEMCACHE_PROTOCOL') ?: 'ascii');
if (ini_get('memcache.protocol') == 'binary') {
$udpPort = 0;
$udpPort2 = 0;
}
/* Start a server listening to a unix domain socket
*
* mkdir /var/run/memcached
* chown memcached:memcached /var/run/memcached
* memcached -d -u memcached -s /var/run/memcached/memcached.sock
* chmod a+w /var/run/memcached/memcached.sock
*/
$domainsocket = 'unix:///var/run/memcached/memcached.sock';
// A server which is guaranteed to fail immediatly
$nonExistingHost = "localhost";
$nonExistingPort = 11213;
// A server which times out when attempting to connect to
$unreachableHost = '10.254.254.254';
$unreachablePort = 11211;
$udpPacketSize = 1400;
$balanceKeys = array(
'consistent' => array(
'crc32' => array('key1_abc', 'key2_abcde'),
'fnv' => array('key1_a', 'key2_2534534'),
),
'standard' => array(
'crc32' => array('load_test_key1', 'load_test_key2'),
'fnv' => array('key1_ab', 'key2_a'),
),
);
$strat = strtolower(ini_get('memcache.hash_strategy'));
$func = strtolower(ini_get('memcache.hash_function'));
list ($balanceKey1, $balanceKey2) = $balanceKeys[$strat][$func];
if (!isset($udpPort))
$udpPort = 0;
if (!isset($udpPort2))
$udpPort2 = 0;
$memcache = memcache_connect($host, $port);
function test_connect1() {
global $host, $port, $udpPort;
$memcache = new MemcachePool();
$memcache->connect($host, $port, isset($udpPort) ? $udpPort : 0);
return $memcache;
}
function test_connect2() {
global $host2, $port2, $udpPort2;
$memcache = new MemcachePool();
$memcache->connect($host2, $port2, isset($udpPort2) ? $udpPort2 : 0);
return $memcache;
}
function test_connect_pool() {
global $host, $port, $udpPort, $host2, $port2, $udpPort2;
$memcache = new MemcachePool();
$memcache->addServer($host, $port, isset($udpPort) ? $udpPort : 0);
$memcache->addServer($host2, $port2, isset($udpPort2) ? $udpPort2 : 0);
return $memcache;
}
if (!$memcache) {
die('skip Connection to memcached failed');
}
tests/001.phpt 0000644 00000001441 15173154555 0007116 0 ustar 00 --TEST--
memcache_set() function
--SKIPIF--
<?php
if (PHP_VERSION_ID < 80000)
die('skip php 8+ only');
include 'connect.inc';
--FILE--
<?php
include 'connect.inc';
$value = new stdClass;
$value->plain_attribute = 'value';
$value->array_attribute = array('test1', 'test2');
memcache_set($memcache, 'test_key', $value, false, 10);
$key = 123;
$value = 123;
memcache_set($memcache, $key, $value, false, 10);
var_dump($key);
var_dump($value);
try {
memcache_set($memcache, $key);
} catch (ArgumentCountError $e) {
echo "{$e->getMessage()}\n";
}
try {
$memcache->set($key);
} catch (ArgumentCountError $e) {
echo "{$e->getMessage()}\n";
}
echo "Done\n";
?>
--EXPECTF--
int(123)
int(123)
Wrong parameter count for memcache_set()
Wrong parameter count for MemcachePool::set()
Done tests/030.phpt 0000644 00000001055 15173154556 0007122 0 ustar 00 --TEST--
ini_set("memcache.chunk_size")
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$result1 = ini_set("memcache.chunk_size", 16384);
var_dump($result1);
$result2 = ini_set("memcache.chunk_size", 32768);
var_dump($result2);
$result3 = ini_get("memcache.chunk_size");
var_dump($result3);
$result4 = @ini_set("memcache.chunk_size", 0);
var_dump($result4);
$result5 = @ini_set("memcache.chunk_size", -1);
var_dump($result5);
?>
--EXPECTF--
string(%d) "%d"
string(5) "16384"
string(5) "32768"
bool(false)
bool(false)
tests/pecl11221.phpt 0000644 00000000752 15173154557 0010136 0 ustar 00 --TEST--
PECL bug #11221 (Double free when returning cached object with __sleep)
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
class block
{
var $waa = 'meukee';
function __sleep() { return array('waa'); }
}
function cache_failure()
{
$block = new block();
var_dump($GLOBALS['cache']->set('block', $block));
return $block;
}
$cache = new memcache;
$cache->connect($host, $port);
cache_failure();
echo "Done\n";
?>
--EXPECTF--
bool(true)
Done
tests/pecl63272.phpt 0000644 00000001465 15173154557 0010155 0 ustar 00 --TEST--
PECL bug #63272 (Explicitly reserve range of flags in php_memcache.h so application code can use)
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$user_flags = array(
MEMCACHE_USER1,
MEMCACHE_USER2,
MEMCACHE_USER3,
MEMCACHE_USER4,
);
$m = new Memcache;
$m->addServer($host, $port);
foreach ($user_flags as $user_flag) {
$m->set("testkey", "testvalue", $user_flag);
$m->set("testkey_compressed", "testvalue", $user_flag | MEMCACHE_COMPRESSED);
$getflags = 0;
var_dump($m->get("testkey", $getflags));
var_dump($m->get("testkey_compressed", $getflags));
}
echo "Done\n";
?>
--EXPECT--
string(9) "testvalue"
string(9) "testvalue"
string(9) "testvalue"
string(9) "testvalue"
string(9) "testvalue"
string(9) "testvalue"
string(9) "testvalue"
string(9) "testvalue"
Done
tests/034.phpt 0000644 00000003204 15173154560 0007117 0 ustar 00 --TEST--
memcache->getStats() with arguments
--SKIPIF--
<?php include 'connect.inc'; if (ini_get('memcache.protocol') == 'binary') die('skip binary protocol does not support stats'); ?>
--FILE--
<?php
include 'connect.inc';
$result = $memcache->set('test_key', 'abc');
var_dump($result);
$result = $memcache->getStats();
var_dump($result['pid']);
$version = $result['version'];
$result = $memcache->getStats('abc');
var_dump($result);
$result = $memcache->getStats('reset');
var_dump($result);
// malloc was removed in memcached 1.4.0
if ($version >= '1.4.0') {
var_dump("0");
} else {
$result = $memcache->getStats('malloc');
var_dump($result['arena_size']);
}
$result = $memcache->getStats('slabs');
var_dump($result[key($result)]['chunk_size']);
var_dump($result[key($result)]['free_chunks_end']);
$slab = key($result);
$result = $memcache->getStats('cachedump', $slab, 10);
var_dump($result[key($result)][0]);
var_dump($result[key($result)][1]);
$result = $memcache->getStats('items');
var_dump($result['items'][$slab]['number']);
//$result = $memcache->getStats('sizes');
//var_dump($result['64']);
$result = $memcache->getExtendedStats('abc');
// adding "@" to suppress new behaviour in PHP 7.4+, see: https://wiki.php.net/rfc/notice-for-non-valid-array-container
@var_dump($result["$host:$port"]);
$result = $memcache->getExtendedStats('items');
var_dump(isset($result["$host:$port"]['items']));
?>
--EXPECTF--
bool(true)
string(%d) "%d"
Warning: %s: Invalid stats type %s
bool(false)
bool(true)
string(%d) "%d"
string(%d) "%d"
string(%d) "%d"
string(%d) "%d"
string(%d) "%d"
string(%d) "%d"
Warning: %s: Invalid stats type %s
NULL
bool(true)
tests/027.phpt 0000644 00000001562 15173154561 0007127 0 ustar 00 --TEST--
memcache->setCompressThreshold()
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$var = str_repeat('abc', 5000);
$memcache->setCompressThreshold(10000);
$result1 = $memcache->set('non_existing_test_key', $var, 0, 1);
$result2 = $memcache->get('non_existing_test_key');
var_dump($result1);
var_dump(strlen($result2));
$memcache->setCompressThreshold(10000, 0);
$result3 = $memcache->set('non_existing_test_key', $var, 0, 1);
$memcache->setCompressThreshold(10000, 1);
$result4 = $memcache->set('non_existing_test_key', $var, 0, 1);
var_dump($result3);
var_dump($result4);
$result5 = $memcache->set('non_existing_test_key', 'abc', MEMCACHE_COMPRESSED, 1);
$result6 = $memcache->get('non_existing_test_key');
var_dump($result5);
var_dump($result6);
?>
--EXPECT--
bool(true)
int(15000)
bool(true)
bool(true)
bool(true)
string(3) "abc"
tests/031.phpt 0000644 00000004415 15173154562 0007123 0 ustar 00 --TEST--
memcache->addServer() adding server in failed mode
--SKIPIF--
<?php include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); ?>
--FILE--
<?php
include 'connect.inc';
// Run hash destination test
$memcache = new Memcache();
$memcache->addServer($host, $port, false);
$memcache->addServer($host2, $port2, false);
$memcache1 = memcache_connect($host, $port);
$memcache2 = memcache_connect($host2, $port2);
$memcache1->set($balanceKey1, '', false, 2);
$memcache1->set($balanceKey1, '', false, 2);
$memcache2->set($balanceKey1, '', false, 2);
$memcache2->set($balanceKey2, '', false, 2);
$result1 = $memcache->set($balanceKey1, 'test-030-01', false, 2); // hashes to $host2
$result2 = $memcache->set($balanceKey2, 'test-030-02', false, 2); // hashes to $host1
var_dump($result1);
var_dump($result2);
$result4 = $memcache1->get($balanceKey1); // return false; key1 is at $host2
$result5 = $memcache1->get($balanceKey2);
$result6 = $memcache2->get($balanceKey1);
$result7 = $memcache2->get($balanceKey2); // return false; key2 is at $host1
var_dump($result4);
var_dump($result5);
var_dump($result6);
var_dump($result7);
// Add server in failed mode
$memcache = new Memcache();
$memcache->addServer($host, $port, false);
$memcache->addServer($host2, $port2, false, 1, 1, -1, false);
$result8 = $memcache->set($balanceKey1, 'test-030-03', false, 1); // hashes to $host2
$result9 = $memcache->set($balanceKey2, 'test-030-04', false, 1); // hashes to $host1
var_dump($result8);
var_dump($result9);
$result10 = $memcache1->get($balanceKey1); // key should be $host1 (failed over from $host2)
$result11 = $memcache1->get($balanceKey2); // key should always be at $host1
var_dump($result10);
var_dump($result11);
// Single server in failed mode
function _callback_server_failure($host, $port) {
print "_callback_server_failure()\n";
}
$memcache = new Memcache();
$memcache->addServer($host, $port, true, 1, 1, -1, false, '_callback_server_failure');
$result13 = $memcache->add('test_key', 'Test');
$result14 = $memcache->get('test_key');
var_dump($result13);
var_dump($result14);
?>
--EXPECT--
bool(true)
bool(true)
string(0) ""
string(11) "test-030-02"
string(11) "test-030-01"
string(0) ""
bool(true)
bool(true)
string(11) "test-030-03"
string(11) "test-030-04"
bool(false)
bool(false)
tests/020.phpt 0000644 00000002455 15173154563 0007124 0 ustar 00 --TEST--
memcache->set()/memcache->get() with multiple keys and load balancing
--SKIPIF--
<?php include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); ?>
--FILE--
<?php
include 'connect.inc';
$var1 = 'test1';
$var2 = 'test2';
$memcache = test_connect_pool();
$memcache1 = test_connect1();
$memcache2 = test_connect2();
$memcache1->set($balanceKey1, '', false, 2);
$memcache1->set($balanceKey2, '', false, 2);
$memcache2->set($balanceKey1, '', false, 2);
$memcache2->set($balanceKey2, '', false, 2);
$result1 = $memcache->set($balanceKey1, $var1, false, 2); // hashes to $host2
$result2 = $memcache->set($balanceKey2, $var2, false, 2); // hashes to $host1
$result3 = $memcache->get(array($balanceKey1, $balanceKey2));
if (is_array($result3))
sort($result3);
var_dump($result1);
var_dump($result2);
var_dump($result3);
$result4 = $memcache1->get($balanceKey1); // return ""; key1 is at $host2
$result5 = $memcache1->get($balanceKey2);
$result6 = $memcache2->get($balanceKey1);
$result7 = $memcache2->get($balanceKey2); // return ""; key2 is at $host1
var_dump($result4);
var_dump($result5);
var_dump($result6);
var_dump($result7);
?>
--EXPECT--
bool(true)
bool(true)
array(2) {
[0]=>
string(5) "test1"
[1]=>
string(5) "test2"
}
string(0) ""
string(5) "test2"
string(5) "test1"
string(0) ""
tests/pecl63142.phpt 0000644 00000001322 15173154564 0010137 0 ustar 00 --TEST--
PECL bug #63142 (memcache 3.0.7 segfaults with object (un)serialization)
--SKIPIF--
<?php include 'connect.inc'; ?>
--INI--
;fix me later
report_memleaks=0
--FILE--
<?php
include 'connect.inc';
$obj = new StdClass;
$obj->obj = $obj;
$memcache = new Memcache;
$memcache->connect('127.0.0.1', 11211);
$memcache->set('x', $obj, false, 300);
$x = $memcache->get('x'); echo ".";
$x = $memcache->get('x'); echo ".";
$x = $memcache->get('x'); echo ".";
$x = $memcache->get('x'); echo ".";
$x = $memcache->get('x'); echo ".";
$x = $memcache->get('x'); echo ".";
$x = $memcache->get('x'); echo ".";
$x = $memcache->get('x'); echo ".";
$x = $memcache->get('x'); echo ".\n";
echo "Done\n";
?>
--EXPECTF--
.........
Done
tests/053.phpt 0000644 00000001734 15173154565 0007133 0 ustar 00 --TEST--
ini_set('session.save_handler') with unix domain socket
--SKIPIF--
<?php include 'connect.inc'; if (!MEMCACHE_HAVE_SESSION) print 'skip not compiled with session support'; if (empty($domainsocket)) print 'skip $domainsocket not set'; ?>
--FILE--
<?php
include 'connect.inc';
$memcache = new Memcache();
$memcache->connect($domainsocket, 0);
$session_save_path = ", $domainsocket:0?weight=1, ";
ini_set('session.save_handler', 'memcache');
ini_set('memcache.session_save_path', $session_save_path);
$result1 = session_start();
$id = session_id();
$_SESSION['_test_key'] = 'Test';
$result2 = $memcache->get($id);
session_write_close();
$result3 = $memcache->get($id);
// Test destroy
session_start();
$result4 = session_destroy();
$result5 = $memcache->get($id);
var_dump($result1);
var_dump($id);
var_dump($result2);
var_dump($result3);
var_dump($result4);
var_dump($result5);
?>
--EXPECTF--
bool(true)
string(%d) "%s"
bool(false)
string(%d) "%s"
bool(true)
bool(false)
tests/045.phpt 0000644 00000001544 15173154566 0007134 0 ustar 00 --TEST--
Nested get's in __wakeup()
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
class testclass {
public $result = null;
function __wakeup() {
global $memcache;
$this->result = $memcache->get('_test_key3');
var_dump($this->result);
}
}
$a1 = new testclass();
$memcache->set('_test_key1', $a1);
$memcache->set('_test_key2', array(123));
$memcache->set('_test_key3', 'test3');
$a2 = $memcache->get('_test_key1');
var_dump($a2);
$result = $memcache->get(array('_test_key1', '_test_key2'));
if (is_array($result))
ksort($result);
var_dump($result);
?>
--EXPECTF--
string(5) "test3"
object(testclass)%s {
["result"]=>
string(5) "test3"
}
string(5) "test3"
array(2) {
["_test_key1"]=>
object(testclass)%s {
["result"]=>
string(5) "test3"
}
["_test_key2"]=>
array(1) {
[0]=>
int(123)
}
}
tests/022b.phpt 0000644 00000002513 15173154567 0007267 0 ustar 00 --TEST--
memcache_get_extended_stats()
--SKIPIF--
<?php
if (PHP_VERSION_ID >= 80000)
die('skip php prior to 8 only');
include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); if (ini_get('memcache.protocol') == 'binary') die('skip binary protocol does not support stats');
--FILE--
<?php
include 'connect.inc';
$memcache = new Memcache();
memcache_add_server($memcache, $nonExistingHost, $nonExistingPort);
memcache_add_server($memcache, $host, $port);
memcache_add_server($memcache, $host2, $port2);
$result1 = @memcache_get_stats($memcache);
$result2 = @memcache_get_extended_stats($memcache);
try {
var_dump(memcache_get_extended_stats(array()));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
try {
var_dump(memcache_get_extended_stats(new stdClass));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
var_dump($result1['pid']);
var_dump(count($result2));
var_dump($result2["$host:$port"]['pid']);
var_dump($result2["$host2:$port2"]['pid']);
var_dump($result2["$nonExistingHost:$nonExistingPort"]);
?>
--EXPECTF--
Argument 1 passed to memcache_get_extended_stats() must be an instance of MemcachePool, array given
Argument 1 passed to memcache_get_extended_stats() must be an instance of MemcachePool, instance of stdClass given
string(%d) "%d"
int(3)
string(%d) "%d"
string(%d) "%d"
bool(false) tests/017.phpt 0000644 00000000612 15173154567 0007127 0 ustar 00 --TEST--
Memcache class should be inheritable
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
class test extends Memcache {
function foo() {
echo "foo\n";
}
}
$t = new test;
$t->connect($host, $port);
$t->foo();
var_dump($t);
echo "Done\n";
?>
--EXPECTF--
foo
object(test)%s%d) {
["connection"]=>
resource(%d) of type (memcache connection)
}
Done
tests/028.phpt 0000644 00000000546 15173154570 0007131 0 ustar 00 --TEST--
memcache->addServer() and memcache->close()
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
// Test for bug #6595
include 'connect.inc';
$memcache2 = new Memcache();
$result1 = $memcache2->addServer($host, $port, true, 50);
$result2 = $memcache2->close();
var_dump($result1);
var_dump($result2);
?>
--EXPECTF--
bool(true)
bool(true)
tests/043.phpt 0000644 00000003274 15173154571 0007130 0 ustar 00 --TEST--
ini_set('memcache.redundancy')
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
ini_set('memcache.redundancy', 1);
$memcache = test_connect_pool();
$memcache1 = test_connect1();
$memcache2 = test_connect2();
$memcache1->delete($balanceKey1);
$memcache2->delete($balanceKey1);
$result = $memcache->get($balanceKey1);
var_dump($result);
$memcache->set($balanceKey1, 'Test1');
$result1 = $memcache1->get($balanceKey1);
$result2 = $memcache2->get($balanceKey1);
var_dump($result1);
var_dump($result2);
ini_set('memcache.redundancy', 10);
$memcache = test_connect_pool();
// Test set
$memcache->set($balanceKey1, 'Test2');
$result1 = $memcache1->get($balanceKey1);
$result2 = $memcache2->get($balanceKey1);
var_dump($result1);
var_dump($result2);
// Test increment
$memcache->set($balanceKey1, '1');
$memcache->increment($balanceKey1);
$result1 = $memcache1->get($balanceKey1);
$result2 = $memcache2->get($balanceKey1);
var_dump($result1);
var_dump($result2);
// Test delete
$memcache->delete($balanceKey1);
$result1 = $memcache1->get($balanceKey1);
$result2 = $memcache2->get($balanceKey1);
var_dump($result1);
var_dump($result2);
// Test invalid values
ini_set('memcache.redundancy', 0);
ini_set('memcache.redundancy', -1);
ini_set('memcache.redundancy', 'Test');
?>
--EXPECTF--
bool(false)
bool(false)
string(5) "Test1"
string(5) "Test2"
string(5) "Test2"
string(1) "2"
string(1) "2"
bool(false)
bool(false)
Warning: ini_set(): memcache.redundancy must be a positive integer ('0' given) in %s
Warning: ini_set(): memcache.redundancy must be a positive integer ('-1' given) in %s
Warning: ini_set(): memcache.redundancy must be a positive integer ('Test' given) in %s
tests/024b.phpt 0000644 00000002527 15173154572 0007272 0 ustar 00 --TEST--
memcache_close(), memcache_get()
--SKIPIF--
<?php
if (PHP_VERSION_ID >= 80000)
die('skip php prior to 8 only');
include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); ?>
--FILE--
<?php
include 'connect.inc';
memcache_add_server($memcache, $host2, $port2);
memcache_add_server($memcache, $nonExistingHost, $nonExistingPort);
$result1 = memcache_close($memcache);
var_dump($result1);
$memcache = new Memcache();
$result2 = $memcache->connect($host, $port);
$result3 = memcache_set($memcache, 'test_key', 'test', false, 1);
$result4 = memcache_close($memcache);
// This will fail since all servers have been removed
$result5 = memcache_get($memcache, 'test_key');
var_dump($result2);
var_dump($result3);
var_dump($result4);
var_dump($result5);
var_dump(memcache_close($memcache));
var_dump(memcache_close($memcache));
try {
var_dump(memcache_close(new stdClass));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
try {
var_dump(memcache_close(""));
} catch (TypeError $e) {
echo "{$e->getMessage()}\n";
}
echo "Done\n";
?>
--EXPECTF--
bool(true)
bool(true)
bool(true)
bool(true)
bool(false)
bool(true)
bool(true)
Argument 1 passed to memcache_close() must be an instance of MemcachePool, instance of stdClass given
Argument 1 passed to memcache_close() must be an instance of MemcachePool, string given
Done
tests/057.phpt 0000644 00000002254 15173154573 0007134 0 ustar 00 --TEST--
session locking
--SKIPIF--
<?php include 'connect.inc'; if (!MEMCACHE_HAVE_SESSION) print 'skip not compiled with session support'; else if (!function_exists('pcntl_fork')) print 'skip not compiled with pcntl_fork() support'; ?>
--FILE--
<?php
include 'connect.inc';
$childcount = 50;
$sid = md5(rand());
ini_set('session.save_handler', 'memcache');
ini_set('memcache.session_save_path', "tcp://$host:$port?udp_port=$udpPort;tcp://$host2:$host2?udp_port=$udpPort2;tcp://$nonExistingHost:$nonExistingPort");
ini_set('memcache.session_redundancy', 10);
$pids = array();
for ($i = 0; $i < $childcount; $i++) {
$pid = pcntl_fork();
if (!$pid) {
// In child process
session_id($sid);
session_start();
if (!isset($_SESSION['counter']))
$_SESSION['counter'] = 0;
$_SESSION['counter'] += 1;
session_write_close();
exit(0);
}
else {
// In parent process
$pids[] = $pid;
}
}
// Wait for children to exit
foreach ($pids as $pid) {
$status = 0;
pcntl_waitpid($pid, $status);
if ($status != 0) {
//print "Child exited abnormally ($status)\n";
}
}
session_id($sid);
session_start();
var_dump($_SESSION);
?>
--EXPECT--
array(1) {
["counter"]=>
int(50)
}
tests/047.phpt 0000644 00000002561 15173154574 0007135 0 ustar 00 --TEST--
memcache->get() with flags
--SKIPIF--
<?php include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); ?>
--FILE--
<?php
include 'connect.inc';
$flag1 = 0x10000;
$flag2 = 0x20000;
$memcache->set('test_key1', 'test1', $flag1);
$memcache->set('test_key2', 'test2', $flag2);
// Test OO
$result1 = null;
$result2 = $memcache->get('test_key1', $result1);
var_dump($result1);
var_dump($result2);
$result3 = null;
$result4 = $memcache->get(array('test_key1', 'test_key2'), $result3);
if (is_array($result3))
ksort($result3);
if (is_array($result4))
ksort($result4);
var_dump($result3);
var_dump($result4);
// Test procedural
$result1 = null;
$result2 = memcache_get($memcache, 'test_key1', $result1);
var_dump($result1);
var_dump($result2);
$result3 = null;
$result4 = memcache_get($memcache, array('test_key1', 'test_key2'), $result3);
if (is_array($result3))
ksort($result3);
if (is_array($result4))
ksort($result4);
var_dump($result3);
var_dump($result4);
?>
--EXPECT--
int(65536)
string(5) "test1"
array(2) {
["test_key1"]=>
int(65536)
["test_key2"]=>
int(131072)
}
array(2) {
["test_key1"]=>
string(5) "test1"
["test_key2"]=>
string(5) "test2"
}
int(65536)
string(5) "test1"
array(2) {
["test_key1"]=>
int(65536)
["test_key2"]=>
int(131072)
}
array(2) {
["test_key1"]=>
string(5) "test1"
["test_key2"]=>
string(5) "test2"
}
tests/025.phpt 0000644 00000002352 15173154574 0007127 0 ustar 00 --TEST--
memcache->increment() with load balancing
--SKIPIF--
<?php include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); ?>
--FILE--
<?php
include 'connect.inc';
$var1 = 10;
$var2 = 20;
$memcache = new Memcache();
$memcache->addServer($host, $port);
$memcache->addServer($host2, $port2);
$memcache1 = memcache_connect($host, $port);
$memcache2 = memcache_connect($host2, $port2);
$memcache1->set($balanceKey1, '', false, 2);
$memcache1->set($balanceKey2, '', false, 2);
$memcache2->set($balanceKey1, '', false, 2);
$memcache2->set($balanceKey2, '', false, 2);
$result1 = $memcache->set($balanceKey1, $var1, false, 2); // hashes to host2
$result2 = $memcache->set($balanceKey2, $var2, false, 2); // hashes to host1
$result3 = $memcache->increment($balanceKey1);
$result4 = $memcache->increment($balanceKey2);
var_dump($result1);
var_dump($result2);
var_dump($result3);
var_dump($result4);
$result5 = $memcache1->get($balanceKey1);
$result6 = $memcache1->get($balanceKey2);
$result7 = $memcache2->get($balanceKey1);
$result8 = $memcache2->get($balanceKey2);
var_dump($result5);
var_dump($result6);
var_dump($result7);
var_dump($result8);
?>
--EXPECT--
bool(true)
bool(true)
int(11)
int(21)
string(0) ""
int(21)
int(11)
string(0) ""
tests/009.phpt 0000644 00000001044 15173154576 0007130 0 ustar 00 --TEST--
memcache->set() method
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$var = new stdClass;
$var->plain_attribute = 'value';
$var->array_attribute = Array('test1', 'test2');
$result = $memcache->set('test_key', $var, false, 10);
var_dump($result);
// Should generate a "SERVER_ERROR: out of memory"
$var = str_repeat('a', 1500000);
$memcache->setCompressThreshold(0);
$result = @$memcache->set('test_key', $var, false, 10);
var_dump($result);
echo "Done\n";
?>
--EXPECT--
bool(true)
bool(false)
Done
tests/042.phpt 0000644 00000002176 15173154576 0007134 0 ustar 00 --TEST--
memcache->set() with multiple values
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$memcache = test_connect_pool();
$memcache->set($balanceKey1, '');
$memcache->set($balanceKey2, '');
$result1 = $memcache->get($balanceKey1);
$result2 = $memcache->get($balanceKey2);
var_dump($result1);
var_dump($result2);
$values = array(
$balanceKey1 => 'abc',
$balanceKey2 => 'def');
$result = $memcache->set($values);
var_dump($result);
$result1 = $memcache->get($balanceKey1);
$result2 = $memcache->get($balanceKey2);
var_dump($result1);
var_dump($result2);
print "\n";
$key = 'test_key';
$values = array();
for ($i=0; $i<250; $i++) {
$values[$key.$i] = $key.'_value_'.$i;
}
$memcache->delete(array_keys($values));
$result1 = memcache_set($memcache, $values, null, 0, 10);
var_dump($result1);
$result2 = $memcache->get(array_keys($values));
ksort($result2);
var_dump(count($result2));
var_dump(count($result2) == count($values));
var_dump(reset($result2));
?>
--EXPECT--
string(0) ""
string(0) ""
bool(true)
string(3) "abc"
string(3) "def"
bool(true)
int(250)
bool(true)
string(16) "test_key_value_0" tests/bug73539.phpt 0000644 00000002133 15173154577 0010011 0 ustar 00 --TEST--
memcache multi host save path function
--SKIPIF--
<?php
include 'connect.inc';
?>
--FILE--
<?php
ob_start();
include 'connect.inc';
$session_save_path = "tcp://$host:$port,tcp://$host2:$port2";
ini_set('session.save_handler', 'memcache');
ini_set('memcache.session_save_path', $session_save_path);
session_id('abcdef');
session_start();
$_SESSION['bof.test'] = 42;
session_write_close();
$_SESSION = array();
function test() {
session_name('SID_bof');
session_id('abcdef');
if (!session_start()) {
var_dump('session_start failed');
exit(1);
}
var_dump($_SESSION);
$_SESSION['bof.test'] = 42;
session_write_close();
}
ini_set('memcache.session_save_path', "tcp://$host:$port");
test();
ini_set('memcache.session_save_path', "tcp://$host2:$port2");
test();
ini_set('memcache.session_save_path', "tcp://$host:$port, tcp://$host2:$port2");
test();
echo "Done\n";
ob_flush();
?>
--EXPECTF--
array(1) {
["bof.test"]=>
int(42)
}
array(1) {
["bof.test"]=>
int(42)
}
array(1) {
["bof.test"]=>
int(42)
}
Done
tests/014.phpt 0000644 00000000614 15173154600 0007112 0 ustar 00 --TEST--
memcache->increment() & memcache->decrement()
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$memcache->set('new_test', 5);
$result1 = $memcache->increment('new_test');
$result2 = $memcache->decrement('new_test');
$result3 = $memcache->get('new_test');
var_dump($result1);
var_dump($result2);
var_dump($result3);
?>
--EXPECT--
int(6)
int(5)
int(5)
tests/046.phpt 0000644 00000003224 15173154601 0007120 0 ustar 00 --TEST--
hash strategies and functions
--SKIPIF--
<?php include 'connect.inc'; if (!isset($host2)) die('skip $host2 not set'); ?>
--FILE--
<?php
include 'connect.inc';
$var1 = 'test1';
$var2 = 'test2';
$memcache1 = memcache_connect($host, $port);
$memcache2 = memcache_pconnect($host2, $port2);
foreach ($balanceKeys as $strategy => $functions) {
foreach ($functions as $function => $keys) {
ini_set('memcache.hash_strategy', $strategy);
ini_set('memcache.hash_function', $function);
list ($balanceKey1, $balanceKey2) = $keys;
print "\n$strategy:$function\n";
$memcache = new Memcache();
$memcache->addServer($host, $port);
$memcache->addServer($host2, $port2);
$memcache1->set($balanceKey1, '', false, 2);
$memcache1->set($balanceKey2, '', false, 2);
$memcache2->set($balanceKey1, '', false, 2);
$memcache2->set($balanceKey2, '', false, 2);
$memcache->set($balanceKey1, $var1, false, 2); // hashes to $host2
$memcache->set($balanceKey2, $var2, false, 2); // hashes to $host1
$result4 = $memcache1->get($balanceKey1); // return false; key1 is at $host2
$result5 = $memcache1->get($balanceKey2);
$result6 = $memcache2->get($balanceKey1);
$result7 = $memcache2->get($balanceKey2); // return false; key2 is at $host1
var_dump($result4);
var_dump($result5);
var_dump($result6);
var_dump($result7);
}
}
?>
--EXPECT--
consistent:crc32
string(0) ""
string(5) "test2"
string(5) "test1"
string(0) ""
consistent:fnv
string(0) ""
string(5) "test2"
string(5) "test1"
string(0) ""
standard:crc32
string(0) ""
string(5) "test2"
string(5) "test1"
string(0) ""
standard:fnv
string(0) ""
string(5) "test2"
string(5) "test1"
string(0) ""
tests/002.phpt 0000644 00000002330 15173154601 0007105 0 ustar 00 --TEST--
memcache_get() function
--FILE--
<?php
include 'connect.inc';
$var = new stdClass;
$var->plain_attribute = 'value';
$var->array_attribute = Array('test1', 'test2');
$result = memcache_set($memcache, 'test_key', $var);
var_dump($result);
$result = memcache_set($memcache, 'test_key1', $var);
var_dump($result);
$result = memcache_get($memcache, 'test_key');
var_dump($result);
$result = memcache_get($memcache, array('test_key', 'test_key1'));
var_dump($result);
$result = memcache_get($memcache, array('unset_test_key', 'unset_test_key1'));
var_dump($result);
?>
--EXPECTF--
bool(true)
bool(true)
object(stdClass)%s2) {
["plain_attribute"]=>
string(5) "value"
["array_attribute"]=>
array(2) {
[0]=>
string(5) "test1"
[1]=>
string(5) "test2"
}
}
array(2) {
["test_key"]=>
object(stdClass)%s2) {
["plain_attribute"]=>
string(5) "value"
["array_attribute"]=>
array(2) {
[0]=>
string(5) "test1"
[1]=>
string(5) "test2"
}
}
["test_key1"]=>
object(stdClass)%s2) {
["plain_attribute"]=>
string(5) "value"
["array_attribute"]=>
array(2) {
[0]=>
string(5) "test1"
[1]=>
string(5) "test2"
}
}
}
array(0) {
} tests/016.phpt 0000644 00000000424 15173154602 0007115 0 ustar 00 --TEST--
memcache->delete()
--SKIPIF--
<?php include 'connect.inc'; ?>
--FILE--
<?php
include 'connect.inc';
$memcache->set('test', 'test');
$memcache->delete('test', 10);
/* the item should be still there */
$memcache->delete('test');
echo "Done\n";
?>
--EXPECT--
Done
