ÿØÿà JFIF    ÿÛ „ ( %!1!%*+...983,7(-.- tests/054.phpt000064400000001075152343313650007123 0ustar00--TEST-- memcache->set() with value larger than MTU --SKIPIF-- --FILE-- 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/027a.phpt000064400000003535152343313650007267 0ustar00--TEST-- memcache_set_compress_threshold() --SKIPIF-- --FILE-- --EXPECTF-- bool(true) int(15000) bool(true) bool(true) bool(true) string(3) "abc" Warning: memcache_set_compress_threshold() expects parameter 1 to be MemcachePool, array given in %s on line %d NULL 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) Warning: memcache_set_compress_threshold() expects parameter 1 to be MemcachePool, object given in %s on line %d NULL Done tests/003.phpt000064400000002217152343313650007114 0ustar00--TEST-- memcache_set()/memcache_get() using compression --SKIPIF-- --FILE-- 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/036.phpt000064400000002776152343313650007134 0ustar00--TEST-- ini_set('session.save_handler') --SKIPIF-- --FILE-- 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/053.phpt000064400000001734152343313650007124 0ustar00--TEST-- ini_set('session.save_handler') with unix domain socket --SKIPIF-- --FILE-- 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/058.phpt000064400000000325152343313650007124 0ustar00--TEST-- memcache->findServer() --SKIPIF-- --FILE-- findServer('test_key'); var_dump($result); ?> --EXPECTF-- string(%d) "%s:%d"tests/049.phpt000064400000001305152343313650007123 0ustar00--TEST-- memcache->append(), memcache->prepend() --SKIPIF-- --FILE-- 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/025.phpt000064400000002352152343313650007120 0ustar00--TEST-- memcache->increment() with load balancing --SKIPIF-- --FILE-- 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/pecl17518.phpt000064400000001312152343313650010136 0ustar00--TEST-- PECL bug #17518 (Strange behavior in increment on non integer and after) --SKIPIF-- --FILE-- connect('localhost', 11211); 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')); $m->flush(); ?> --EXPECTF-- bool(false) bool(false) Notice: MemcachePool::increment(): Server localhost (tcp 11211, udp 0) failed with: CLIENT_ERROR cannot increment or decrement non-numeric value (6) in %s/pecl17518.php on line 12 bool(false) string(3) "bar" int(43) int(43) tests/pecl17566.phpt000064400000000541152343313650010144 0ustar00--TEST-- PECL bug #17566 (3.0.4 cache delete bug) --SKIPIF-- --FILE-- 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/030.phpt000064400000001055152343313650007113 0ustar00--TEST-- ini_set("memcache.chunk_size") --SKIPIF-- --FILE-- --EXPECTF-- string(%d) "%d" string(5) "16384" string(5) "32768" bool(false) bool(false) tests/023.phpt000064400000003344152343313650007120 0ustar00--TEST-- memcache->delete() with load balancing --SKIPIF-- --FILE-- 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/bug73539.phpt000064400000001612152343313650010000 0ustar00--TEST-- memcache multi host save path function --SKIPIF-- 70000) { die("skip not relevant for php 7.1+ "); } ?> --FILE-- --EXPECTF-- array(1) { 'bof.test' => int(42) } array(1) { 'bof.test' => int(42) } array(1) { 'bof.test' => int(42) } Done tests/050.phpt000064400000001302152343313650007110 0ustar00--TEST-- failure callback throws exception --SKIPIF-- = 5.0.0'); ?> --FILE-- 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/022a.phpt000064400000002215152343313650007254 0ustar00--TEST-- memcache_get_extended_stats() --SKIPIF-- --FILE-- --EXPECTF-- Warning: memcache_get_extended_stats() expects parameter 1 to be MemcachePool, array given in %s on line %d NULL Warning: memcache_get_extended_stats() expects parameter 1 to be MemcachePool, object given in %s on line %d NULL string(%d) "%d" int(3) string(%d) "%d" string(%d) "%d" bool(false) tests/010.phpt000064400000001145152343313650007111 0ustar00--TEST-- memcache->get() function --SKIPIF-- --FILE-- 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/028.phpt000064400000000546152343313650007126 0ustar00--TEST-- memcache->addServer() and memcache->close() --SKIPIF-- --FILE-- addServer($host, $port, true, 50); $result2 = $memcache2->close(); var_dump($result1); var_dump($result2); ?> --EXPECTF-- bool(true) bool(true) tests/007.phpt000064400000000705152343313650007120 0ustar00--TEST-- memcache_get_version() & memcache_get_stats() --SKIPIF-- --FILE-- 10); var_dump(count($stats)); } ?> --EXPECTF-- string(%d) "%s" bool(true) int(%d) tests/pecl16442.phpt000064400000000551152343313650010135 0ustar00--TEST-- PECL bug #16442 (memcache_set fail with integer value) --SKIPIF-- --FILE-- --EXPECTF-- int(1) tests/009.phpt000064400000001044152343313650007117 0ustar00--TEST-- memcache->set() method --SKIPIF-- --FILE-- 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/014.phpt000064400000000614152343313650007115 0ustar00--TEST-- memcache->increment() & memcache->decrement() --SKIPIF-- --FILE-- 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/038.phpt000064400000001523152343313650007123 0ustar00--TEST-- memcache->get() over UDP --SKIPIF-- skip known bug --FILE-- 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/043.phpt000064400000003274152343313650007124 0ustar00--TEST-- ini_set('memcache.redundancy') --SKIPIF-- --FILE-- 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/033.phpt000064400000007606152343313650007126 0ustar00--TEST-- memcache->addServer() with server failure callback --SKIPIF-- --FILE-- 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/020.phpt000064400000002455152343313650007117 0ustar00--TEST-- memcache->set()/memcache->get() with multiple keys and load balancing --SKIPIF-- --FILE-- 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/057.phpt000064400000002254152343313650007126 0ustar00--TEST-- session locking --SKIPIF-- --FILE-- --EXPECT-- array(1) { ["counter"]=> int(50) } tests/006.phpt000064400000000656152343313650007124 0ustar00--TEST-- memcache_increment() & memcache_decrement() --SKIPIF-- --FILE-- --EXPECT-- int(6) int(5) int(5) tests/045.phpt000064400000001512152343313650007117 0ustar00--TEST-- Nested get's in __wakeup() --SKIPIF-- --FILE-- 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/047.phpt000064400000002561152343313650007126 0ustar00--TEST-- memcache->get() with flags --SKIPIF-- --FILE-- 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/048.phpt000064400000001330152343313650007120 0ustar00--TEST-- memcache->get(), set() with CAS --SKIPIF-- --FILE-- 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/100b.phpt000064400000002444152343313650007256 0ustar00--TEST-- memcache->flush() with time in future --SKIPIF-- --FILE-- 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/008.phpt000064400000000456152343313650007124 0ustar00--TEST-- memcache_delete() --SKIPIF-- --FILE-- --EXPECT-- Done tests/044.phpt000064400000003535152343313650007125 0ustar00--TEST-- ini_set('memcache.session_redundancy') --SKIPIF-- --FILE-- delete($balanceKey1); $memcache2->delete($balanceKey1); // 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/memcache.sh000064400000000377152343313650010020 0ustar00#!/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/004.phpt000064400000001013152343313650007106 0ustar00--TEST-- memcache_add() & memcache_replace() --SKIPIF-- --FILE-- 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/035.phpt000064400000001407152343313650007121 0ustar00--TEST-- memcache::connect() with unix domain socket --SKIPIF-- --FILE-- 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/034.phpt000064400000003204152343313650007115 0ustar00--TEST-- memcache->getStats() with arguments --SKIPIF-- --FILE-- 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/037.phpt000064400000000746152343313650007130 0ustar00--TEST-- ini_set('memcache.hash_strategy') --SKIPIF-- --FILE-- --EXPECTF-- string(8) "standard" string(10) "consistent" string(10) "consistent"tests/017.phpt000064400000000612152343313650007116 0ustar00--TEST-- Memcache class should be inheritable --SKIPIF-- --FILE-- 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/036b.phpt000064400000002723152343313650007266 0ustar00--TEST-- ini_set('session.save_path') --SKIPIF-- --FILE-- 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/019a.phpt000064400000001257152343313650007267 0ustar00--TEST-- memcache_add_server() --SKIPIF-- --FILE-- --EXPECTF-- bool(true) bool(true) Warning: memcache_add_server() expects parameter 1 to be Memcache, object given in %s on line %d NULL Warning: memcache_add_server() expects parameter 2 to be string, object given in %s on line %d NULL Done tests/041.phpt000064400000002002152343313650007106 0ustar00--TEST-- memcache->delete() with multiple keys --SKIPIF-- --FILE-- 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/031.phpt000064400000004415152343313650007117 0ustar00--TEST-- memcache->addServer() adding server in failed mode --SKIPIF-- --FILE-- 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/pecl11221.phpt000064400000000752152343313650010126 0ustar00--TEST-- PECL bug #11221 (Double free when returning cached object with __sleep) --SKIPIF-- --FILE-- set('block', $block)); return $block; } $cache = new memcache; $cache->connect($host, $port); cache_failure(); echo "Done\n"; ?> --EXPECTF-- bool(true) Done tests/connect.inc000064400000004461152343313650010044 0ustar00 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/013.phpt000064400000000505152343313650007113 0ustar00--TEST-- memcache->set() & memcache->get() with strange keys --SKIPIF-- --FILE-- set($key, $var, false, 10); $result = $memcache->get($key); var_dump($result); ?> --EXPECT-- string(4) "test" tests/046.phpt000064400000003224152343313650007122 0ustar00--TEST-- hash strategies and functions --SKIPIF-- --FILE-- $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/019.phpt000064400000003166152343313650007127 0ustar00--TEST-- memcache->addServer() --SKIPIF-- --FILE-- 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/026.phpt000064400000001245152343313650007121 0ustar00--TEST-- memcache->delete() with load balancing --SKIPIF-- --FILE-- 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/022.phpt000064400000002041152343313650007110 0ustar00--TEST-- memcache->getExtendedStats() --SKIPIF-- --FILE-- 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/100a.phpt000064400000002050152343313650007246 0ustar00--TEST-- memcache_flush() --SKIPIF-- --FILE-- addServer($nonExistingHost, $nonExistingPort); $result = @memcache_flush($memcache2); var_dump($result); memcache_close($memcache); var_dump(memcache_flush($memcache)); var_dump(memcache_flush(new stdClass)); var_dump(memcache_flush('')); echo "Done\n"; ?> --EXPECTF-- bool(true) bool(false) bool(false) bool(true) Warning: memcache_flush() expects parameter 1 to be MemcachePool, object given in %s on line %d NULL Warning: memcache_flush() expects parameter 1 to be MemcachePool, string given in %s on line %d NULL Done tests/024a.phpt000064400000002227152343313650007261 0ustar00--TEST-- memcache_close(), memcache_get() --SKIPIF-- --FILE-- 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)); var_dump(memcache_close(new stdClass)); var_dump(memcache_close("")); echo "Done\n"; ?> --EXPECTF-- bool(true) bool(true) bool(true) bool(true) bool(false) bool(true) bool(true) Warning: memcache_close() expects parameter 1 to be MemcachePool, object given in %s on line %d NULL Warning: memcache_close() expects parameter 1 to be MemcachePool, string given in %s on line %d NULL Done tests/024.phpt000064400000001610152343313650007113 0ustar00--TEST-- memcache->close(), memcache->get() --SKIPIF-- --FILE-- 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/002.phpt000064400000002330152343313650007107 0ustar00--TEST-- memcache_get() function --FILE-- 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/029.phpt000064400000002506152343313650007125 0ustar00--TEST-- ini_set("memcache.allow_failover") --SKIPIF-- --FILE-- 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/027.phpt000064400000001562152343313650007124 0ustar00--TEST-- memcache->setCompressThreshold() --SKIPIF-- --FILE-- 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/055.phpt000064400000001401152343313650007115 0ustar00--TEST-- memcache->set()/get() datatype preservation --SKIPIF-- --FILE-- 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 %stests/100.phpt000064400000001672152343313650007116 0ustar00--TEST-- memcache->flush() --SKIPIF-- --FILE-- 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/pecl16536.phpt000064400000000526152343313650010143 0ustar00--TEST-- PECL bug #16536 (Weight of 0 causes SegFault on memcache_add_server) --SKIPIF-- --FILE-- addServer($host, $port, true, 0)); var_dump(@$mmc->set('TEST_KEY', 'test_value')); echo "Done\n"; ?> --EXPECTF-- bool(false) bool(false) Done tests/018.phpt000064400000000616152343313650007123 0ustar00--TEST-- memcache_set() & memcache_add() --SKIPIF-- --FILE-- --EXPECT-- bool(true) bool(false) tests/051.phpt000064400000001116152343313650007114 0ustar00--TEST-- memcache->set() with duplicate keys --SKIPIF-- --FILE-- 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/021.phpt000064400000002016152343313650007111 0ustar00--TEST-- memcache->set()/memcache->get() with failover --SKIPIF-- --FILE-- 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/001.phpt000064400000001047152343313650007112 0ustar00--TEST-- memcache_set() function --SKIPIF-- --FILE-- 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); memcache_set($memcache, $key); $memcache->set($key); echo "Done\n"; ?> --EXPECTF-- int(123) int(123) Warning: %s parameter%s Warning: %s parameter%s Donetests/githubbug13.phpt000064400000000721152343313650010734 0ustar00--TEST-- session_regenerate_id() should not cause fatal error --SKIPIF-- --FILE-- --EXPECTF-- bool(true)tests/005.phpt000064400000007224152343313650007121 0ustar00--TEST-- strange keys --SKIPIF-- --FILE-- 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/042.phpt000064400000002176152343313650007123 0ustar00--TEST-- memcache->set() with multiple values --SKIPIF-- --FILE-- 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/039.phpt000064400000001426152343313650007126 0ustar00--TEST-- memcache->get() over multi-datagram UDP --SKIPIF-- --FILE-- 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/pecl63142.phpt000064400000001322152343313650010131 0ustar00--TEST-- PECL bug #63142 (memcache 3.0.7 segfaults with object (un)serialization) --SKIPIF-- --INI-- ;fix me later report_memleaks=0 --FILE-- 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/012.phpt000064400000000763152343313650007120 0ustar00--TEST-- memcache_add() & memcache_replace() --SKIPIF-- --FILE-- 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/056.phpt000064400000003071152343313650007123 0ustar00--TEST-- memcache->addServer() with microsecond timeout --SKIPIF-- --FILE-- 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/015.phpt000064400000000665152343313650007124 0ustar00--TEST-- memcache->getVersion() & memcache->getStats() --SKIPIF-- --FILE-- 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/011.phpt000064400000001052152343313650007107 0ustar00--TEST-- memcache->set()/memcache->get() using compression --SKIPIF-- --FILE-- 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/016.phpt000064400000000424152343313650007116 0ustar00--TEST-- memcache->delete() --SKIPIF-- --FILE-- set('test', 'test'); $memcache->delete('test', 10); /* the item should be still there */ $memcache->delete('test'); echo "Done\n"; ?> --EXPECT-- Done tests/032.phpt000064400000004017152343313650007116 0ustar00--TEST-- memcache->getServerStatus(), memcache->setServerParams() --SKIPIF-- --FILE-- 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/052.phpt000064400000001143152343313650007115 0ustar00--TEST-- memcache->connect() and memcache->close() in loop --SKIPIF-- --FILE-- 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