tests/CacheKeyValueOpsTest.php - ignite-php-thin-client - Git at Google

 <?php
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 namespace Apache\Ignite\Tests;

 use PHPUnit\Framework\TestCase;
 use Apache\Ignite\Exception\ClientException;
 use Apache\Ignite\Cache\CacheEntry;
 use Apache\Ignite\Cache\CacheConfiguration;
 use Apache\Ignite\Cache\CacheInterface;

 final class CacheKeyValueOpsTestCase extends TestCase
 {
     const CACHE_NAME = '__php_test_cache';

     public static function setUpBeforeClass(): void
     {
         TestingHelper::init();
         self::cleanUp();
         TestingHelper::$client->getOrCreateCache(self::CACHE_NAME);
     }

     public static function tearDownAfterClass(): void
     {
         self::cleanUp();
         TestingHelper::cleanUp();
     }

     public function testCacheGet(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $value = $cache->get(1);
             $this->assertEquals($value, null);
             $cache->put(1, 2);
             $value = $cache->get(1);
             $this->assertEquals($value, 2);
         } finally {
             $cache->removeAll();
         }
     }

     public function cacheWrongKeys(): array
     {
         return array(
             array(null)
         );
     }

     /**
      * @dataProvider cacheWrongKeys
      */
     public function testCacheGetWrongArgs($cacheKey): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->get($cacheKey);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCacheGetAll(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             for ($i = 0; $i < 5; $i++) {
                 $cache->put($i, $i * 2);
             }
             $entries = $cache->getAll([3, 4, 5, 6, 7]);
             $this->assertCount(2, $entries);
             foreach ($entries as $entry) {
                 $this->assertTrue($entry->getKey() === 3 || $entry->getKey() === 4);
                 $this->assertEquals($entry->getValue(), $entry->getKey() * 2);
             }
             $entries = $cache->getAll([6, 7, 8]);
             $this->assertCount(0, $entries);
         } finally {
             $cache->removeAll();
         }
     }

     public function cacheGetAllWrongKeys(): array
     {
         return array(
             array([])
         );
     }

     /**
      * @dataProvider cacheGetAllWrongKeys
      */
     public function testCacheGetAllWrongArgs($keys): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->getAll($keys);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCachePut(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $value = $cache->get(1);
             $this->assertEquals($value, null);
             $cache->put(1, 2);
             $value = $cache->get(1);
             $this->assertEquals($value, 2);
             $cache->put(1, 4);
             $value = $cache->get(1);
             $this->assertEquals($value, 4);
         } finally {
             $cache->removeAll();
         }
     }

     public function cacheWrongKeyValues(): array
     {
         return array(
             array(null, 1),
             array(1, null),
             array(null, null)
         );
     }

     /**
      * @dataProvider cacheWrongKeyValues
      */
     public function testCachePutWrongArgs($key, $value): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->put($key, $value);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCachePutAll(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $cacheEntries = array();
             for ($i = 0; $i < 5; $i++) {
                 array_push($cacheEntries, new CacheEntry($i, $i * 2));
             }
             $cache->putAll($cacheEntries);
             $entries = $cache->getAll([3, 4, 5, 6, 7]);
             $this->assertCount(2, $entries);
             foreach ($entries as $entry) {
                 $this->assertTrue($entry->getKey() === 3 || $entry->getKey() === 4);
                 $this->assertEquals($entry->getValue(), $entry->getKey() * 2);
             }
             $entries = $cache->getAll([-2, -1, 0, 1, 2, 3, 4, 5, 6, 7]);
             $this->assertCount(5, $entries);
             foreach ($entries as $entry) {
                 $this->assertTrue($entry->getKey() >= 0 && $entry->getKey() <= 4);
                 $this->assertEquals($entry->getValue(), $entry->getKey() * 2);
             }
             $entries = $cache->getAll([6, 7, 8]);
             $this->assertCount(0, $entries);
         } finally {
             $cache->removeAll();
         }
     }

     public function cachePutAllWrongArgs(): array
     {
         return array(
             array([]),
             array([new CacheConfiguration])
         );
     }

     /**
      * @dataProvider cachePutAllWrongArgs
      */
     public function testCachePutAllWrongArgs($entries): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->putAll($entries);
         } finally {
             $cache->removeAll();
         }
     }

     public function testContainsKey(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $result = $cache->containsKey(1);
             $this->assertFalse($result);
             $cache->put(1, 2);
             $result = $cache->containsKey(1);
             $this->assertTrue($result);
         } finally {
             $cache->removeAll();
         }
     }

     /**
      * @dataProvider cacheWrongKeys
      */
     public function testContainsKeyWrongArgs($cacheKey): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->containsKey($cacheKey);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCacheContainsKeys(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $result = $cache->containsKeys([1, 2, 3]);
             $this->assertFalse($result);
             $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4)]);
             $result = $cache->containsKeys([1, 2, 3]);
             $this->assertFalse($result);
             $cache->put(3, 6);
             $result = $cache->containsKeys([1, 2, 3]);
             $this->assertTrue($result);
         } finally {
             $cache->removeAll();
         }
     }

     /**
      * @dataProvider cacheGetAllWrongKeys
      */
     public function testCacheContainsKeysWrongArgs($keys): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->containsKeys($keys);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCacheGetAndPut(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $value = $cache->getAndPut(1, 2);
             $this->assertEquals($value, null);
             $value = $cache->getAndPut(1, 4);
             $this->assertEquals($value, 2);
             $cache->put(1, 6);
             $value = $cache->getAndPut(1, 8);
             $this->assertEquals($value, 6);
             $value = $cache->get(1);
             $this->assertEquals($value, 8);

         } finally {
             $cache->removeAll();
         }
     }

     /**
      * @dataProvider cacheWrongKeyValues
      */
     public function testCacheGetAndPutWrongArgs($key, $value): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->getAndPut($key, $value);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCacheGetAndReplace(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $value = $cache->getAndReplace(1, 2);
             $this->assertEquals($value, null);
             $cache->put(1, 4);
             $value = $cache->getAndReplace(1, 6);
             $this->assertEquals($value, 4);
             $value = $cache->get(1);
             $this->assertEquals($value, 6);
         } finally {
             $cache->removeAll();
         }
     }

     /**
      * @dataProvider cacheWrongKeyValues
      */
     public function testCacheGetAndReplaceWrongArgs($key, $value): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->getAndReplace($key, $value);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCacheGetAndRemove(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $value = $cache->getAndRemove(1);
             $this->assertEquals($value, null);
             $cache->put(1, 2);
             $value = $cache->getAndRemove(1);
             $this->assertEquals($value, 2);
             $value = $cache->get(1);
             $this->assertEquals($value, null);
         } finally {
             $cache->removeAll();
         }
     }

     /**
      * @dataProvider cacheWrongKeys
      */
     public function testCacheGetAndRemoveWrongArgs($cacheKey): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->getAndRemove($cacheKey);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCachePutIfAbsent(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $result = $cache->putIfAbsent(1, 2);
             $this->assertTrue($result);
             $value = $cache->get(1);
             $this->assertEquals($value, 2);
             $result = $cache->putIfAbsent(1, 4);
             $this->assertFalse($result);
             $value = $cache->get(1);
             $this->assertEquals($value, 2);
         } finally {
             $cache->removeAll();
         }
     }

     /**
      * @dataProvider cacheWrongKeyValues
      */
     public function testCachePutIfAbsentWrongArgs($key, $value): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->putIfAbsent($key, $value);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCacheGetAndPutIfAbsent(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $value = $cache->getAndPutIfAbsent(1, 2);
             $this->assertEquals($value, null);
             $value = $cache->get(1);
             $this->assertEquals($value, 2);
             $value = $cache->getAndPutIfAbsent(1, 4);
             $this->assertEquals($value, 2);
             $value = $cache->get(1);
             $this->assertEquals($value, 2);

         } finally {
             $cache->removeAll();
         }
     }

     /**
      * @dataProvider cacheWrongKeyValues
      */
     public function testCacheGetAndPutIfAbsentWrongArgs($key, $value): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->getAndPutIfAbsent($key, $value);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCacheReplace(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $result = $cache->replace(1, 2);
             $this->assertFalse($result);
             $value = $cache->get(1);
             $this->assertEquals($value, null);
             $cache->put(1, 1);
             $result = $cache->replace(1, 4);
             $this->assertTrue($result);
             $value = $cache->get(1);
             $this->assertEquals($value, 4);

         } finally {
             $cache->removeAll();
         }
     }

     /**
      * @dataProvider cacheWrongKeyValues
      */
     public function testCacheReplaceWrongArgs($key, $value): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->replace($key, $value);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCacheReplaceIfEquals(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $result = $cache->replaceIfEquals(1, 2, 3);
             $this->assertFalse($result);
             $cache->put(1, 4);
             $result = $cache->replaceIfEquals(1, 2, 3);
             $this->assertFalse($result);
             $value = $cache->get(1);
             $this->assertEquals($value, 4);
             $result = $cache->replaceIfEquals(1, 4, 3);
             $this->assertTrue($result);
             $value = $cache->get(1);
             $this->assertEquals($value, 3);
         } finally {
             $cache->removeAll();
         }
     }

     public function cacheWrongReplaceIfEqualsArgs(): array
     {
         return array(
             array(null, 1, 1),
             array(null, 1, null),
             array(1, null, 1),
             array(1, null, null),
             array(null, null, null)
         );
     }

     /**
      * @dataProvider cacheWrongReplaceIfEqualsArgs
      */
     public function testCacheReplaceIfEqualsWrongArgs($key, $value, $newValue): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->replaceIfEquals($key, $value, $newValue);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCacheClear(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $cache->clear();
             $result = $cache->getSize();
             $this->assertEquals($result, 0);
             $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
             $result = $cache->getSize();
             $this->assertEquals($result, 3);
             $cache->clear();
             $result = $cache->getSize();
             $this->assertEquals($result, 0);
             $entries = $cache->getAll([1, 2, 3]);
             $this->assertCount(0, $entries);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCacheClearKeys(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $cache->clearKeys([1, 2, 3]);
             $result = $cache->getSize();
             $this->assertEquals($result, 0);
             $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
             $result = $cache->getSize();
             $this->assertEquals($result, 3);
             $cache->clearKeys([1, 2, 7, 8]);
             $result = $cache->getSize();
             $this->assertEquals($result, 1);
             $value = $cache->get(3);
             $this->assertEquals($value, 6);
         } finally {
             $cache->removeAll();
         }
     }

     /**
      * @dataProvider cacheGetAllWrongKeys
      */
     public function testCacheClearKeysWrongArgs($keys): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->clearKeys($keys);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCacheClearKey(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $cache->clearKey(1);
             $result = $cache->getSize();
             $this->assertEquals($result, 0);
             $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
             $result = $cache->getSize();
             $this->assertEquals($result, 3);
             $cache->clearKey(1);
             $result = $cache->getSize();
             $this->assertEquals($result, 2);
             $value = $cache->get(2);
             $this->assertEquals($value, 4);
             $value = $cache->get(3);
             $this->assertEquals($value, 6);
         } finally {
             $cache->removeAll();
         }
     }

     /**
      * @dataProvider cacheWrongKeys
      */
     public function testCacheClearKeyWrongArgs($cacheKey): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->clearKey($cacheKey);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCacheRemoveKey(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $result = $cache->removeKey(1);
             $this->assertFalse($result);
             $result = $cache->getSize();
             $this->assertEquals($result, 0);
             $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
             $result = $cache->getSize();
             $this->assertEquals($result, 3);
             $result = $cache->removeKey(1);
             $this->assertTrue($result);
             $result = $cache->removeKey(1);
             $this->assertFalse($result);
             $result = $cache->getSize();
             $this->assertEquals($result, 2);
             $value = $cache->get(2);
             $this->assertEquals($value, 4);
             $value = $cache->get(3);
             $this->assertEquals($value, 6);
         } finally {
             $cache->removeAll();
         }
     }

     /**
      * @dataProvider cacheWrongKeys
      */
     public function testCacheRemoveKeyWrongArgs($cacheKey): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->removeKey($cacheKey);
         } finally {
             $cache->removeAll();
         }
     }

     public function testRemoveIfEquals(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $result = $cache->removeIfEquals(1, 2);
             $this->assertFalse($result);
             $cache->put(1, 4);
             $result = $cache->removeIfEquals(1, 2);
             $this->assertFalse($result);
             $result = $cache->removeIfEquals(1, 4);
             $this->assertTrue($result);
             $value = $cache->get(1);
             $this->assertEquals($value, null);
         } finally {
             $cache->removeAll();
         }
     }

     /**
      * @dataProvider cacheWrongKeyValues
      */
     public function testRemoveIfEqualsWrongArgs($key, $value): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->removeIfEquals($key, $value);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCacheRemoveKeys(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $cache->removeKeys([1, 2, 3]);
             $result = $cache->getSize();
             $this->assertEquals($result, 0);
             $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
             $result = $cache->getSize();
             $this->assertEquals($result, 3);
             $cache->removeKeys([1, 2, 7, 8]);
             $result = $cache->getSize();
             $this->assertEquals($result, 1);
             $value = $cache->get(3);
             $this->assertEquals($value, 6);
         } finally {
             $cache->removeAll();
         }
     }

     /**
      * @dataProvider cacheGetAllWrongKeys
      */
     public function testCacheRemoveKeysWrongArgs($keys): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->removeKeys($keys);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCacheRemoveAll(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $cache->removeAll();
             $result = $cache->getSize();
             $this->assertEquals($result, 0);
             $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
             $result = $cache->getSize();
             $this->assertEquals($result, 3);
             $cache->removeAll();
             $result = $cache->getSize();
             $this->assertEquals($result, 0);
             $entries = $cache->getAll([1, 2, 3]);
             $this->assertCount(0, $entries);
         } finally {
             $cache->removeAll();
         }
     }

     public function testCacheGetSize(): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $result = $cache->getSize();
             $this->assertEquals($result, 0);
             $cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
             $result = $cache->getSize();
             $this->assertEquals($result, 3);
             $result = $cache->getSize(CacheInterface::PEEK_MODE_ALL);
             $this->assertEquals($result, 3);
             $result = $cache->getSize(CacheInterface::PEEK_MODE_ALL, CacheInterface::PEEK_MODE_ALL);
             $this->assertEquals($result, 3);
         } finally {
             $cache->removeAll();
         }
     }

     public function getSizeWrongArgs(): array
     {
         return array(
             array(-1, -2),
             array(4, 5, 6, 0)
         );
     }

     /**
      * @dataProvider getSizeWrongArgs
      */
     public function testCacheGetSizeWrongArgs($modes): void
     {
         $cache = TestingHelper::$client->getCache(self::CACHE_NAME);
         try {
             $this->expectException(ClientException::class);
             $cache->getSize($modes);
         } finally {
             $cache->removeAll();
         }
     }

     private static function cleanUp(): void
     {
         TestingHelper::destroyCache(self::CACHE_NAME);
     }
 }
	<?php
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	namespace Apache\Ignite\Tests;

	use PHPUnit\Framework\TestCase;
	use Apache\Ignite\Exception\ClientException;
	use Apache\Ignite\Cache\CacheEntry;
	use Apache\Ignite\Cache\CacheConfiguration;
	use Apache\Ignite\Cache\CacheInterface;

	final class CacheKeyValueOpsTestCase extends TestCase
	{
	const CACHE_NAME = '__php_test_cache';

	public static function setUpBeforeClass(): void
	{
	TestingHelper::init();
	self::cleanUp();
	TestingHelper::$client->getOrCreateCache(self::CACHE_NAME);
	}

	public static function tearDownAfterClass(): void
	{
	self::cleanUp();
	TestingHelper::cleanUp();
	}

	public function testCacheGet(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$value = $cache->get(1);
	$this->assertEquals($value, null);
	$cache->put(1, 2);
	$value = $cache->get(1);
	$this->assertEquals($value, 2);
	} finally {
	$cache->removeAll();
	}
	}

	public function cacheWrongKeys(): array
	{
	return array(
	array(null)
	);
	}

	/**
	* @dataProvider cacheWrongKeys
	*/
	public function testCacheGetWrongArgs($cacheKey): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->get($cacheKey);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCacheGetAll(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	for ($i = 0; $i < 5; $i++) {
	$cache->put($i, $i * 2);
	}
	$entries = $cache->getAll([3, 4, 5, 6, 7]);
	$this->assertCount(2, $entries);
	foreach ($entries as $entry) {
	$this->assertTrue($entry->getKey() === 3 \|\| $entry->getKey() === 4);
	$this->assertEquals($entry->getValue(), $entry->getKey() * 2);
	}
	$entries = $cache->getAll([6, 7, 8]);
	$this->assertCount(0, $entries);
	} finally {
	$cache->removeAll();
	}
	}

	public function cacheGetAllWrongKeys(): array
	{
	return array(
	array([])
	);
	}

	/**
	* @dataProvider cacheGetAllWrongKeys
	*/
	public function testCacheGetAllWrongArgs($keys): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->getAll($keys);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCachePut(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$value = $cache->get(1);
	$this->assertEquals($value, null);
	$cache->put(1, 2);
	$value = $cache->get(1);
	$this->assertEquals($value, 2);
	$cache->put(1, 4);
	$value = $cache->get(1);
	$this->assertEquals($value, 4);
	} finally {
	$cache->removeAll();
	}
	}

	public function cacheWrongKeyValues(): array
	{
	return array(
	array(null, 1),
	array(1, null),
	array(null, null)
	);
	}

	/**
	* @dataProvider cacheWrongKeyValues
	*/
	public function testCachePutWrongArgs($key, $value): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->put($key, $value);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCachePutAll(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$cacheEntries = array();
	for ($i = 0; $i < 5; $i++) {
	array_push($cacheEntries, new CacheEntry($i, $i * 2));
	}
	$cache->putAll($cacheEntries);
	$entries = $cache->getAll([3, 4, 5, 6, 7]);
	$this->assertCount(2, $entries);
	foreach ($entries as $entry) {
	$this->assertTrue($entry->getKey() === 3 \|\| $entry->getKey() === 4);
	$this->assertEquals($entry->getValue(), $entry->getKey() * 2);
	}
	$entries = $cache->getAll([-2, -1, 0, 1, 2, 3, 4, 5, 6, 7]);
	$this->assertCount(5, $entries);
	foreach ($entries as $entry) {
	$this->assertTrue($entry->getKey() >= 0 && $entry->getKey() <= 4);
	$this->assertEquals($entry->getValue(), $entry->getKey() * 2);
	}
	$entries = $cache->getAll([6, 7, 8]);
	$this->assertCount(0, $entries);
	} finally {
	$cache->removeAll();
	}
	}

	public function cachePutAllWrongArgs(): array
	{
	return array(
	array([]),
	array([new CacheConfiguration])
	);
	}

	/**
	* @dataProvider cachePutAllWrongArgs
	*/
	public function testCachePutAllWrongArgs($entries): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->putAll($entries);
	} finally {
	$cache->removeAll();
	}
	}

	public function testContainsKey(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$result = $cache->containsKey(1);
	$this->assertFalse($result);
	$cache->put(1, 2);
	$result = $cache->containsKey(1);
	$this->assertTrue($result);
	} finally {
	$cache->removeAll();
	}
	}

	/**
	* @dataProvider cacheWrongKeys
	*/
	public function testContainsKeyWrongArgs($cacheKey): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->containsKey($cacheKey);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCacheContainsKeys(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$result = $cache->containsKeys([1, 2, 3]);
	$this->assertFalse($result);
	$cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4)]);
	$result = $cache->containsKeys([1, 2, 3]);
	$this->assertFalse($result);
	$cache->put(3, 6);
	$result = $cache->containsKeys([1, 2, 3]);
	$this->assertTrue($result);
	} finally {
	$cache->removeAll();
	}
	}

	/**
	* @dataProvider cacheGetAllWrongKeys
	*/
	public function testCacheContainsKeysWrongArgs($keys): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->containsKeys($keys);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCacheGetAndPut(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$value = $cache->getAndPut(1, 2);
	$this->assertEquals($value, null);
	$value = $cache->getAndPut(1, 4);
	$this->assertEquals($value, 2);
	$cache->put(1, 6);
	$value = $cache->getAndPut(1, 8);
	$this->assertEquals($value, 6);
	$value = $cache->get(1);
	$this->assertEquals($value, 8);

	} finally {
	$cache->removeAll();
	}
	}

	/**
	* @dataProvider cacheWrongKeyValues
	*/
	public function testCacheGetAndPutWrongArgs($key, $value): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->getAndPut($key, $value);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCacheGetAndReplace(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$value = $cache->getAndReplace(1, 2);
	$this->assertEquals($value, null);
	$cache->put(1, 4);
	$value = $cache->getAndReplace(1, 6);
	$this->assertEquals($value, 4);
	$value = $cache->get(1);
	$this->assertEquals($value, 6);
	} finally {
	$cache->removeAll();
	}
	}

	/**
	* @dataProvider cacheWrongKeyValues
	*/
	public function testCacheGetAndReplaceWrongArgs($key, $value): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->getAndReplace($key, $value);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCacheGetAndRemove(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$value = $cache->getAndRemove(1);
	$this->assertEquals($value, null);
	$cache->put(1, 2);
	$value = $cache->getAndRemove(1);
	$this->assertEquals($value, 2);
	$value = $cache->get(1);
	$this->assertEquals($value, null);
	} finally {
	$cache->removeAll();
	}
	}

	/**
	* @dataProvider cacheWrongKeys
	*/
	public function testCacheGetAndRemoveWrongArgs($cacheKey): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->getAndRemove($cacheKey);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCachePutIfAbsent(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$result = $cache->putIfAbsent(1, 2);
	$this->assertTrue($result);
	$value = $cache->get(1);
	$this->assertEquals($value, 2);
	$result = $cache->putIfAbsent(1, 4);
	$this->assertFalse($result);
	$value = $cache->get(1);
	$this->assertEquals($value, 2);
	} finally {
	$cache->removeAll();
	}
	}

	/**
	* @dataProvider cacheWrongKeyValues
	*/
	public function testCachePutIfAbsentWrongArgs($key, $value): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->putIfAbsent($key, $value);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCacheGetAndPutIfAbsent(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$value = $cache->getAndPutIfAbsent(1, 2);
	$this->assertEquals($value, null);
	$value = $cache->get(1);
	$this->assertEquals($value, 2);
	$value = $cache->getAndPutIfAbsent(1, 4);
	$this->assertEquals($value, 2);
	$value = $cache->get(1);
	$this->assertEquals($value, 2);

	} finally {
	$cache->removeAll();
	}
	}

	/**
	* @dataProvider cacheWrongKeyValues
	*/
	public function testCacheGetAndPutIfAbsentWrongArgs($key, $value): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->getAndPutIfAbsent($key, $value);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCacheReplace(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$result = $cache->replace(1, 2);
	$this->assertFalse($result);
	$value = $cache->get(1);
	$this->assertEquals($value, null);
	$cache->put(1, 1);
	$result = $cache->replace(1, 4);
	$this->assertTrue($result);
	$value = $cache->get(1);
	$this->assertEquals($value, 4);

	} finally {
	$cache->removeAll();
	}
	}

	/**
	* @dataProvider cacheWrongKeyValues
	*/
	public function testCacheReplaceWrongArgs($key, $value): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->replace($key, $value);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCacheReplaceIfEquals(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$result = $cache->replaceIfEquals(1, 2, 3);
	$this->assertFalse($result);
	$cache->put(1, 4);
	$result = $cache->replaceIfEquals(1, 2, 3);
	$this->assertFalse($result);
	$value = $cache->get(1);
	$this->assertEquals($value, 4);
	$result = $cache->replaceIfEquals(1, 4, 3);
	$this->assertTrue($result);
	$value = $cache->get(1);
	$this->assertEquals($value, 3);
	} finally {
	$cache->removeAll();
	}
	}

	public function cacheWrongReplaceIfEqualsArgs(): array
	{
	return array(
	array(null, 1, 1),
	array(null, 1, null),
	array(1, null, 1),
	array(1, null, null),
	array(null, null, null)
	);
	}

	/**
	* @dataProvider cacheWrongReplaceIfEqualsArgs
	*/
	public function testCacheReplaceIfEqualsWrongArgs($key, $value, $newValue): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->replaceIfEquals($key, $value, $newValue);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCacheClear(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$cache->clear();
	$result = $cache->getSize();
	$this->assertEquals($result, 0);
	$cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
	$result = $cache->getSize();
	$this->assertEquals($result, 3);
	$cache->clear();
	$result = $cache->getSize();
	$this->assertEquals($result, 0);
	$entries = $cache->getAll([1, 2, 3]);
	$this->assertCount(0, $entries);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCacheClearKeys(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$cache->clearKeys([1, 2, 3]);
	$result = $cache->getSize();
	$this->assertEquals($result, 0);
	$cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
	$result = $cache->getSize();
	$this->assertEquals($result, 3);
	$cache->clearKeys([1, 2, 7, 8]);
	$result = $cache->getSize();
	$this->assertEquals($result, 1);
	$value = $cache->get(3);
	$this->assertEquals($value, 6);
	} finally {
	$cache->removeAll();
	}
	}

	/**
	* @dataProvider cacheGetAllWrongKeys
	*/
	public function testCacheClearKeysWrongArgs($keys): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->clearKeys($keys);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCacheClearKey(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$cache->clearKey(1);
	$result = $cache->getSize();
	$this->assertEquals($result, 0);
	$cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
	$result = $cache->getSize();
	$this->assertEquals($result, 3);
	$cache->clearKey(1);
	$result = $cache->getSize();
	$this->assertEquals($result, 2);
	$value = $cache->get(2);
	$this->assertEquals($value, 4);
	$value = $cache->get(3);
	$this->assertEquals($value, 6);
	} finally {
	$cache->removeAll();
	}
	}

	/**
	* @dataProvider cacheWrongKeys
	*/
	public function testCacheClearKeyWrongArgs($cacheKey): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->clearKey($cacheKey);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCacheRemoveKey(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$result = $cache->removeKey(1);
	$this->assertFalse($result);
	$result = $cache->getSize();
	$this->assertEquals($result, 0);
	$cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
	$result = $cache->getSize();
	$this->assertEquals($result, 3);
	$result = $cache->removeKey(1);
	$this->assertTrue($result);
	$result = $cache->removeKey(1);
	$this->assertFalse($result);
	$result = $cache->getSize();
	$this->assertEquals($result, 2);
	$value = $cache->get(2);
	$this->assertEquals($value, 4);
	$value = $cache->get(3);
	$this->assertEquals($value, 6);
	} finally {
	$cache->removeAll();
	}
	}

	/**
	* @dataProvider cacheWrongKeys
	*/
	public function testCacheRemoveKeyWrongArgs($cacheKey): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->removeKey($cacheKey);
	} finally {
	$cache->removeAll();
	}
	}

	public function testRemoveIfEquals(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$result = $cache->removeIfEquals(1, 2);
	$this->assertFalse($result);
	$cache->put(1, 4);
	$result = $cache->removeIfEquals(1, 2);
	$this->assertFalse($result);
	$result = $cache->removeIfEquals(1, 4);
	$this->assertTrue($result);
	$value = $cache->get(1);
	$this->assertEquals($value, null);
	} finally {
	$cache->removeAll();
	}
	}

	/**
	* @dataProvider cacheWrongKeyValues
	*/
	public function testRemoveIfEqualsWrongArgs($key, $value): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->removeIfEquals($key, $value);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCacheRemoveKeys(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$cache->removeKeys([1, 2, 3]);
	$result = $cache->getSize();
	$this->assertEquals($result, 0);
	$cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
	$result = $cache->getSize();
	$this->assertEquals($result, 3);
	$cache->removeKeys([1, 2, 7, 8]);
	$result = $cache->getSize();
	$this->assertEquals($result, 1);
	$value = $cache->get(3);
	$this->assertEquals($value, 6);
	} finally {
	$cache->removeAll();
	}
	}

	/**
	* @dataProvider cacheGetAllWrongKeys
	*/
	public function testCacheRemoveKeysWrongArgs($keys): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->removeKeys($keys);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCacheRemoveAll(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$cache->removeAll();
	$result = $cache->getSize();
	$this->assertEquals($result, 0);
	$cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
	$result = $cache->getSize();
	$this->assertEquals($result, 3);
	$cache->removeAll();
	$result = $cache->getSize();
	$this->assertEquals($result, 0);
	$entries = $cache->getAll([1, 2, 3]);
	$this->assertCount(0, $entries);
	} finally {
	$cache->removeAll();
	}
	}

	public function testCacheGetSize(): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$result = $cache->getSize();
	$this->assertEquals($result, 0);
	$cache->putAll([new CacheEntry(1, 2), new CacheEntry(2, 4), new CacheEntry(3, 6)]);
	$result = $cache->getSize();
	$this->assertEquals($result, 3);
	$result = $cache->getSize(CacheInterface::PEEK_MODE_ALL);
	$this->assertEquals($result, 3);
	$result = $cache->getSize(CacheInterface::PEEK_MODE_ALL, CacheInterface::PEEK_MODE_ALL);
	$this->assertEquals($result, 3);
	} finally {
	$cache->removeAll();
	}
	}

	public function getSizeWrongArgs(): array
	{
	return array(
	array(-1, -2),
	array(4, 5, 6, 0)
	);
	}

	/**
	* @dataProvider getSizeWrongArgs
	*/
	public function testCacheGetSizeWrongArgs($modes): void
	{
	$cache = TestingHelper::$client->getCache(self::CACHE_NAME);
	try {
	$this->expectException(ClientException::class);
	$cache->getSize($modes);
	} finally {
	$cache->removeAll();
	}
	}

	private static function cleanUp(): void
	{
	TestingHelper::destroyCache(self::CACHE_NAME);
	}
	}