| <?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 \DateTime; |
| use Ds\Map; |
| use Ds\Set; |
| use PHPUnit\Framework\TestCase; |
| use Apache\Ignite\Type\ObjectType; |
| use Apache\Ignite\Type\MapObjectType; |
| use Apache\Ignite\Type\CollectionObjectType; |
| use Apache\Ignite\Type\ObjectArrayType; |
| use Apache\Ignite\Type\ComplexObjectType; |
| use Apache\Ignite\Data\BinaryObject; |
| use Apache\Ignite\Data\Date; |
| use Apache\Ignite\Data\Timestamp; |
| use Apache\Ignite\Data\EnumItem; |
| use Apache\Ignite\Exception\ClientException; |
| |
| class TstComplObjectWithPrimitiveFields |
| { |
| public $field1; |
| public $field2; |
| public $field3; |
| public $field4; |
| public $field5; |
| public $field6; |
| public $field7; |
| public $field8; |
| public $field9; |
| public $field10; |
| public $field11; |
| public $field30; |
| public $field33; |
| public $field36; |
| } |
| |
| class TstComplObjectWithDefaultFieldTypes |
| { |
| public $field3; |
| public $field6; |
| public $field8; |
| public $field9; |
| public $field11; |
| public $field30; |
| public $field33; |
| public $field36; |
| } |
| |
| final class CachePutGetTestCase extends TestCase |
| { |
| const CACHE_NAME = '__php_test_cache'; |
| |
| private static $cache; |
| |
| public static function setUpBeforeClass(): void |
| { |
| TestingHelper::init(); |
| self::cleanUp(); |
| self::$cache = TestingHelper::$client->getOrCreateCache(self::CACHE_NAME); |
| } |
| |
| public static function tearDownAfterClass(): void |
| { |
| self::cleanUp(); |
| TestingHelper::cleanUp(); |
| } |
| |
| public function testPutGetPrimitiveValues(): void |
| { |
| foreach (TestingHelper::$primitiveValues as $typeCode1 => $typeInfo1) { |
| foreach (TestingHelper::$primitiveValues as $typeCode2 => $typeInfo2) { |
| foreach ($typeInfo1['values'] as $value1) { |
| foreach ($typeInfo2['values'] as $value2) { |
| $this->putGetPrimitiveValues($typeCode1, $typeCode2, $value1, $value2); |
| if (array_key_exists('typeOptional', $typeInfo1)) { |
| $this->putGetPrimitiveValues(null, $typeCode2, $value1, $value2); |
| } |
| if (array_key_exists('typeOptional', $typeInfo2)) { |
| $this->putGetPrimitiveValues($typeCode1, null, $value1, $value2); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| public function testPutGetArraysOfPrimitives(): void |
| { |
| foreach (TestingHelper::$arrayValues as $type => $typeInfo) { |
| $primitiveType = $typeInfo['elemType']; |
| $values = TestingHelper::$primitiveValues[$primitiveType]['values']; |
| $this->putGetArrays($primitiveType, $type, $values[0], $values); |
| $this->putGetArrays($primitiveType, $type, $values[0], []); |
| if (array_key_exists('typeOptional', $typeInfo)) { |
| $this->putGetArrays($primitiveType, $type, $values[0], $values); |
| } |
| } |
| } |
| |
| public function testPutGetMaps(): void |
| { |
| foreach (TestingHelper::$primitiveValues as $type1 => $typeInfo1) { |
| if (!$typeInfo1['isMapKey']) { |
| continue; |
| } |
| foreach (TestingHelper::$primitiveValues as $type2 => $typeInfo2) { |
| $map = new Map(); |
| $index2 = 0; |
| foreach ($typeInfo1['values'] as $value1) { |
| $value2 = $typeInfo2['values'][$index2]; |
| $index2++; |
| if ($index2 >= count($typeInfo2['values'])) { |
| $index2 = 0; |
| } |
| $map->put($value1, $value2); |
| } |
| $this->putGetMaps(new MapObjectType(MapObjectType::HASH_MAP, $type1, $type2), $map); |
| $this->putGetMaps(new MapObjectType(MapObjectType::LINKED_HASH_MAP, $type1, $type2), $map); |
| if (array_key_exists('typeOptional', $typeInfo1)) { |
| $this->putGetMaps(new MapObjectType(MapObjectType::LINKED_HASH_MAP, null, $type2), $map); |
| } |
| if (array_key_exists('typeOptional', $typeInfo2)) { |
| $this->putGetMaps(new MapObjectType(MapObjectType::LINKED_HASH_MAP, $type1), $map); |
| } |
| if (array_key_exists('typeOptional', $typeInfo1) && array_key_exists('typeOptional', $typeInfo2)) { |
| $this->putGetMaps(new MapObjectType(MapObjectType::LINKED_HASH_MAP), $map); |
| $this->putGetMaps(null, $map); |
| } |
| } |
| } |
| } |
| |
| public function testPutGetArrayMaps(): void |
| { |
| foreach (TestingHelper::$primitiveValues as $type1 => $typeInfo1) { |
| if (!$typeInfo1['isArrayKey']) { |
| continue; |
| } |
| foreach (TestingHelper::$primitiveValues as $type2 => $typeInfo2) { |
| $map = []; |
| $index2 = 0; |
| foreach ($typeInfo1['values'] as $value1) { |
| $value2 = $typeInfo2['values'][$index2]; |
| $index2++; |
| if ($index2 >= count($typeInfo2['values'])) { |
| $index2 = 0; |
| } |
| $map[$value1] = $value2; |
| } |
| $this->putGetArrayMaps(new MapObjectType(MapObjectType::HASH_MAP, $type1, $type2), $map); |
| $this->putGetArrayMaps(new MapObjectType(MapObjectType::LINKED_HASH_MAP, $type1, $type2), $map); |
| if (array_key_exists('typeOptional', $typeInfo1)) { |
| $this->putGetArrayMaps(new MapObjectType(MapObjectType::LINKED_HASH_MAP, null, $type2), $map); |
| } |
| if (array_key_exists('typeOptional', $typeInfo2)) { |
| $this->putGetArrayMaps(new MapObjectType(MapObjectType::LINKED_HASH_MAP, $type1), $map); |
| } |
| if (array_key_exists('typeOptional', $typeInfo1) && array_key_exists('typeOptional', $typeInfo2)) { |
| $this->putGetArrayMaps(new MapObjectType(MapObjectType::LINKED_HASH_MAP), $map); |
| $this->putGetArrayMaps(null, $map); |
| } |
| } |
| } |
| } |
| |
| public function testPutGetMapsWithArrays(): void |
| { |
| foreach (TestingHelper::$primitiveValues as $type1 => $typeInfo1) { |
| if (!$typeInfo1['isMapKey']) { |
| continue; |
| } |
| foreach (TestingHelper::$arrayValues as $type2 => $typeInfo2) { |
| $primitiveType2 = $typeInfo2['elemType']; |
| $values2 = TestingHelper::$primitiveValues[$primitiveType2]['values']; |
| $map = new Map(); |
| $index2 = 0; |
| $arrayValues2 = [$values2, null, array_reverse($values2)]; |
| foreach ($typeInfo1['values'] as $value1) { |
| $map->put($value1, $arrayValues2[$index2]); |
| $index2++; |
| if ($index2 >= count($arrayValues2)) { |
| $index2 = 0; |
| } |
| } |
| $this->putGetMaps(new MapObjectType(MapObjectType::HASH_MAP, $type1, $type2), $map); |
| $this->putGetMaps(new MapObjectType(MapObjectType::LINKED_HASH_MAP, $type1, $type2), $map); |
| if (array_key_exists('typeOptional', $typeInfo1)) { |
| $this->putGetMaps(new MapObjectType(MapObjectType::LINKED_HASH_MAP, null, $type2), $map); |
| } |
| if (array_key_exists('typeOptional', $typeInfo2)) { |
| $this->putGetMaps(new MapObjectType(MapObjectType::LINKED_HASH_MAP, $type1), $map); |
| } |
| if (array_key_exists('typeOptional', $typeInfo1) && array_key_exists('typeOptional', $typeInfo2)) { |
| $this->putGetMaps(new MapObjectType(MapObjectType::LINKED_HASH_MAP), $map); |
| $this->putGetMaps(null, $map); |
| } |
| } |
| } |
| } |
| |
| public function testPutGetArrayMapsWithArrays(): void |
| { |
| foreach (TestingHelper::$primitiveValues as $type1 => $typeInfo1) { |
| if (!$typeInfo1['isArrayKey']) { |
| continue; |
| } |
| foreach (TestingHelper::$arrayValues as $type2 => $typeInfo2) { |
| $primitiveType2 = $typeInfo2['elemType']; |
| $values2 = TestingHelper::$primitiveValues[$primitiveType2]['values']; |
| $map = []; |
| $index2 = 0; |
| $arrayValues2 = [$values2, null, array_reverse($values2)]; |
| foreach ($typeInfo1['values'] as $value1) { |
| $map[$value1] = $arrayValues2[$index2]; |
| $index2++; |
| if ($index2 >= count($arrayValues2)) { |
| $index2 = 0; |
| } |
| } |
| $this->putGetArrayMaps(new MapObjectType(MapObjectType::HASH_MAP, $type1, $type2), $map); |
| $this->putGetArrayMaps(new MapObjectType(MapObjectType::LINKED_HASH_MAP, $type1, $type2), $map); |
| if (array_key_exists('typeOptional', $typeInfo1)) { |
| $this->putGetArrayMaps(new MapObjectType(MapObjectType::LINKED_HASH_MAP, null, $type2), $map); |
| } |
| if (array_key_exists('typeOptional', $typeInfo2)) { |
| $this->putGetArrayMaps(new MapObjectType(MapObjectType::LINKED_HASH_MAP, $type1), $map); |
| } |
| if (array_key_exists('typeOptional', $typeInfo1) && array_key_exists('typeOptional', $typeInfo2)) { |
| $this->putGetArrayMaps(new MapObjectType(MapObjectType::LINKED_HASH_MAP), $map); |
| $this->putGetArrayMaps(null, $map); |
| } |
| } |
| } |
| } |
| |
| public function testPutGetSets(): void |
| { |
| foreach (TestingHelper::$primitiveValues as $type => $typeInfo) { |
| $set = new Set(); |
| foreach ($typeInfo['values'] as $value) { |
| $set->add($value); |
| } |
| $this->putGetSets(new CollectionObjectType(CollectionObjectType::USER_SET, $type), $set); |
| $this->putGetSets(new CollectionObjectType(CollectionObjectType::HASH_SET, $type), $set); |
| $this->putGetSets(new CollectionObjectType(CollectionObjectType::LINKED_HASH_SET, $type), $set); |
| if (array_key_exists('typeOptional', $typeInfo)) { |
| $this->putGetSets(new CollectionObjectType(CollectionObjectType::LINKED_HASH_SET), $set); |
| $this->putGetSets(null, $set); |
| } |
| } |
| } |
| |
| public function testPutGetLists(): void |
| { |
| foreach (TestingHelper::$primitiveValues as $type => $typeInfo) { |
| $list = array(); |
| foreach ($typeInfo['values'] as $value) { |
| array_push($list, $value); |
| } |
| $this->putGetLists(new CollectionObjectType(CollectionObjectType::USER_COL, $type), $list); |
| $this->putGetLists(new CollectionObjectType(CollectionObjectType::ARRAY_LIST, $type), $list); |
| $this->putGetLists(new CollectionObjectType(CollectionObjectType::LINKED_LIST, $type), $list); |
| if (array_key_exists('typeOptional', $typeInfo)) { |
| $this->putGetLists(new CollectionObjectType(CollectionObjectType::ARRAY_LIST), $list); |
| } |
| // $singletonList = [$typeInfo['values'][0]]; |
| // $this->putGetLists(new CollectionObjectType(CollectionObjectType::SINGLETON_LIST, $type), $singletonList); |
| } |
| } |
| |
| public function testPutGetObjectArrayOfMaps(): void |
| { |
| foreach (TestingHelper::$primitiveValues as $type1 => $typeInfo1) { |
| if (!$typeInfo1['isMapKey']) { |
| continue; |
| } |
| foreach (TestingHelper::$primitiveValues as $type2 => $typeInfo2) { |
| $map = new Map(); |
| $index2 = 0; |
| foreach ($typeInfo1['values'] as $value1) { |
| $value2 = $typeInfo2['values'][$index2]; |
| $index2++; |
| if ($index2 >= count($typeInfo2['values'])) { |
| $index2 = 0; |
| } |
| $map->put($value1, $value2); |
| } |
| $array = array(); |
| for ($i = 0; $i < 5; $i++) { |
| $map->reverse(); |
| array_push($array, $map); |
| } |
| $this->putGetObjectArrays(new ObjectArrayType(new MapObjectType(MapObjectType::HASH_MAP, $type1, $type2)), $array); |
| if (array_key_exists('typeOptional', $typeInfo1)) { |
| $this->putGetObjectArrays(new ObjectArrayType(new MapObjectType(MapObjectType::LINKED_HASH_MAP, null, $type2)), $array); |
| } |
| if (array_key_exists('typeOptional', $typeInfo2)) { |
| $this->putGetObjectArrays(new ObjectArrayType(new MapObjectType(MapObjectType::LINKED_HASH_MAP, $type1)), $array); |
| } |
| if (array_key_exists('typeOptional', $typeInfo1) && array_key_exists('typeOptional', $typeInfo2)) { |
| $this->putGetObjectArrays(new ObjectArrayType(), $array); |
| $this->putGetObjectArrays(null, $array); |
| } |
| } |
| } |
| } |
| |
| public function testPutGetObjectArrayOfPrimitives(): void |
| { |
| foreach (TestingHelper::$primitiveValues as $type => $typeInfo) { |
| $array = $typeInfo['values']; |
| $this->putGetObjectArrays(new ObjectArrayType($type), $array); |
| if (array_key_exists('typeOptional', $typeInfo)) { |
| $this->putGetObjectArrays(new ObjectArrayType(), $array); |
| } |
| } |
| } |
| |
| public function testPutGetObjectArrayOfPrimitiveArrays(): void |
| { |
| foreach (TestingHelper::$arrayValues as $type => $typeInfo) { |
| $primitiveType = $typeInfo['elemType']; |
| $values = TestingHelper::$primitiveValues[$primitiveType]['values']; |
| $array = []; |
| for ($i = 0; $i < 5; $i++) { |
| $values = array_reverse($values); |
| array_push($array, $values); |
| } |
| $this->putGetObjectArrays(new ObjectArrayType($type), $array); |
| if (array_key_exists('typeOptional', $typeInfo)) { |
| $this->putGetObjectArrays(new ObjectArrayType(), $array); |
| $this->putGetObjectArrays(null, $array); |
| } |
| } |
| } |
| |
| public function testPutGetObjectArrayOfSets(): void |
| { |
| foreach (TestingHelper::$primitiveValues as $type => $typeInfo) { |
| $set = new Set(); |
| $values = $typeInfo['values']; |
| $array = array(); |
| for ($i = 0; $i < 5; $i++) { |
| $values = array_reverse($values); |
| array_push($array, new Set($values)); |
| } |
| $this->putGetObjectArrays(new ObjectArrayType(new CollectionObjectType(CollectionObjectType::USER_SET, $type)), $array); |
| $this->putGetObjectArrays(new ObjectArrayType(new CollectionObjectType(CollectionObjectType::HASH_SET, $type)), $array); |
| $this->putGetObjectArrays(new ObjectArrayType(new CollectionObjectType(CollectionObjectType::LINKED_HASH_SET, $type)), $array); |
| if (array_key_exists('typeOptional', $typeInfo)) { |
| $this->putGetObjectArrays(new ObjectArrayType(), $array); |
| $this->putGetObjectArrays(null, $array); |
| } |
| } |
| } |
| |
| public function testPutGetObjectArrayOfLists(): void |
| { |
| foreach (TestingHelper::$primitiveValues as $type => $typeInfo) { |
| $set = new Set(); |
| $values = $typeInfo['values']; |
| $array = array(); |
| for ($i = 0; $i < 5; $i++) { |
| $values = array_reverse($values); |
| array_push($array, $values); |
| } |
| $this->putGetObjectArrays(new ObjectArrayType(new CollectionObjectType(CollectionObjectType::USER_COL, $type)), $array); |
| $this->putGetObjectArrays(new ObjectArrayType(new CollectionObjectType(CollectionObjectType::ARRAY_LIST, $type)), $array); |
| $this->putGetObjectArrays(new ObjectArrayType(new CollectionObjectType(CollectionObjectType::LINKED_LIST, $type)), $array); |
| if (array_key_exists('typeOptional', $typeInfo)) { |
| $this->putGetObjectArrays(new ObjectArrayType(new CollectionObjectType(CollectionObjectType::ARRAY_LIST)), $array); |
| } |
| } |
| } |
| |
| public function testPutGetObjectArrayOfComplexObjects(): void |
| { |
| $array = array(); |
| for ($i = 0; $i < 5; $i++) { |
| $object = new TstComplObjectWithPrimitiveFields(); |
| foreach (TestingHelper::$primitiveValues as $type => $typeInfo) { |
| $fieldName = 'field' . $type; |
| $index = ($i < count($typeInfo['values'])) ? $i : $i % count($typeInfo['values']); |
| $object->$fieldName = $typeInfo['values'][$index]; |
| } |
| array_push($array, $object); |
| } |
| |
| $fullComplexObjectType = new ComplexObjectType(); |
| $partComplexObjectType = new ComplexObjectType(); |
| foreach (TestingHelper::$primitiveValues as $type => $typeInfo) { |
| $fullComplexObjectType->setFieldType('field' . $type, $type); |
| if (!array_key_exists('typeOptional', $typeInfo)) { |
| $partComplexObjectType->setFieldType('field' . $type, $type); |
| } |
| } |
| $this->putGetObjectArrays(new ObjectArrayType($fullComplexObjectType), $array); |
| $this->putGetObjectArrays(new ObjectArrayType($partComplexObjectType), $array); |
| } |
| |
| public function testPutGetObjectArrayOfComplexObjectsWithDefaultFieldTypes(): void |
| { |
| $array = array(); |
| for ($i = 0; $i < 5; $i++) { |
| $object = new TstComplObjectWithDefaultFieldTypes(); |
| foreach (TestingHelper::$primitiveValues as $type => $typeInfo) { |
| if (!array_key_exists('typeOptional', $typeInfo)) { |
| continue; |
| } |
| $fieldName = 'field' . $type; |
| $index = ($i < count($typeInfo['values'])) ? $i : $i % count($typeInfo['values']); |
| $object->$fieldName = $typeInfo['values'][$index]; |
| } |
| array_push($array, $object); |
| } |
| $this->putGetObjectArrays(new ObjectArrayType(new ComplexObjectType()), $array); |
| } |
| |
| public function testPutGetObjectArrayOfBinaryObjects(): void |
| { |
| $array = array(); |
| for ($i = 0; $i < 5; $i++) { |
| $binaryObject = new BinaryObject('tstBinaryObj'); |
| foreach (TestingHelper::$primitiveValues as $type => $typeInfo) { |
| $fieldName = 'field' . $type; |
| $index = ($i < count($typeInfo['values'])) ? $i : $i % count($typeInfo['values']); |
| $binaryObject->setField($fieldName, $typeInfo['values'][$index], $type); |
| } |
| array_push($array, $binaryObject); |
| } |
| $this->putGetObjectArrays(new ObjectArrayType(), $array); |
| $this->putGetObjectArrays(null, $array); |
| } |
| |
| public function testPutGetObjectArrayOfObjectArrays(): void |
| { |
| $complexObjectType = new ComplexObjectType(); |
| foreach (TestingHelper::$primitiveValues as $type => $typeInfo) { |
| $complexObjectType->setFieldType('field' . $type, $type); |
| } |
| $array = array(); |
| for ($i = 0; $i < 2; $i++) { |
| $innerArray = array(); |
| for ($j = 0; $j < 2; $j++) { |
| $object = new TstComplObjectWithPrimitiveFields(); |
| foreach (TestingHelper::$primitiveValues as $type => $typeInfo) { |
| $fieldName = 'field' . $type; |
| $index = $i * 10 + $j; |
| $index = ($index < count($typeInfo['values'])) ? $index : $index % count($typeInfo['values']); |
| $object->$fieldName = $typeInfo['values'][$index]; |
| } |
| array_push($innerArray, $object); |
| } |
| array_push($array, $innerArray); |
| } |
| $this->putGetObjectArrays(new ObjectArrayType(new ObjectArrayType($complexObjectType)), $array); |
| } |
| |
| public function testPutGetObjectArrayOfObjectArraysOfComplexObjectsWithDefaultFieldTypes(): void |
| { |
| $array = array(); |
| for ($i = 0; $i < 2; $i++) { |
| $innerArray = array(); |
| for ($j = 0; $j < 2; $j++) { |
| $object = new TstComplObjectWithDefaultFieldTypes(); |
| foreach (TestingHelper::$primitiveValues as $type => $typeInfo) { |
| if (!array_key_exists('typeOptional', $typeInfo)) { |
| continue; |
| } |
| $fieldName = 'field' . $type; |
| $index = $i * 10 + $j; |
| $index = ($index < count($typeInfo['values'])) ? $index : $index % count($typeInfo['values']); |
| $object->$fieldName = $typeInfo['values'][$index]; |
| } |
| array_push($innerArray, $object); |
| } |
| array_push($array, $innerArray); |
| } |
| $this->putGetObjectArrays(new ObjectArrayType(new ObjectArrayType(new ComplexObjectType())), $array); |
| } |
| |
| public function testPutGetDateTime(): void |
| { |
| $this->putGetDate("Y-m-d H:i:s", "2018-10-19 18:31:13", 0); |
| $this->putGetDate("Y-m-d H:i:s", "2018-10-19 18:31:13", 29726); |
| $this->putGetDate("Y-m-d H:i:s", "2018-10-19 18:31:13", 999999); |
| |
| $this->putGetTimestamp("Y-m-d H:i:s", "2018-10-19 18:31:13", 0); |
| $this->putGetTimestamp("Y-m-d H:i:s", "2018-10-19 18:31:13", 29726000); |
| $this->putGetTimestamp("Y-m-d H:i:s", "2018-10-19 18:31:13", 999999999); |
| |
| $this->putGetTimestampFromDateTime("Y-m-d H:i:s", "2018-10-19 18:31:13", 0); |
| $this->putGetTimestampFromDateTime("Y-m-d H:i:s", "2018-10-19 18:31:13", 29726); |
| $this->putGetTimestampFromDateTime("Y-m-d H:i:s", "2018-10-19 18:31:13", 999999); |
| } |
| |
| public function testPutEnumItems(): void |
| { |
| $fakeTypeId = 12345; |
| $enumItem1 = new EnumItem($fakeTypeId); |
| $enumItem1->setOrdinal(1); |
| $this->putEnumItem($enumItem1, null); |
| $this->putEnumItem($enumItem1, ObjectType::ENUM); |
| $enumItem2 = new EnumItem($fakeTypeId); |
| $enumItem2->setName('name'); |
| $this->putEnumItem($enumItem2, null); |
| $this->putEnumItem($enumItem2, ObjectType::ENUM); |
| $enumItem3 = new EnumItem($fakeTypeId); |
| $enumItem3->setOrdinal(2); |
| $this->putEnumItem($enumItem3, null); |
| $this->putEnumItem($enumItem3, ObjectType::ENUM); |
| } |
| |
| private function putEnumItem($value, $valueType): void |
| { |
| $key = microtime(); |
| self::$cache-> |
| setKeyType(null)-> |
| setValueType($valueType); |
| // Enums registration is not supported by the client, therefore put EnumItem must throw ClientException |
| try { |
| self::$cache->put($key, $value); |
| $this->fail('put EnumItem must throw ClientException'); |
| } catch (ClientException $e) { |
| $this->assertContains('Enum item can not be serialized', $e->getMessage()); |
| } finally { |
| self::$cache->removeAll(); |
| } |
| } |
| |
| private function putGetDate(string $format, string $dateString, int $micros): void |
| { |
| $key = microtime(); |
| self::$cache-> |
| setKeyType(null)-> |
| setValueType(ObjectType::DATE); |
| try { |
| $dt = DateTime::createFromFormat("$format.u", sprintf("%s.%06d", $dateString, $micros)); |
| $iDate = Date::fromDateTime($dt); |
| self::$cache->put($key, $iDate); |
| $result = self::$cache->get($key); |
| |
| $this->assertEquals(sprintf("%06d", intval($micros / 1000) * 1000), $result->toDateTime()->format('u')); |
| $this->assertEquals($dateString, $result->toDateTime()->format($format)); |
| } finally { |
| self::$cache->removeAll(); |
| } |
| } |
| |
| private function putGetTimestamp(string $format, string $dateString, int $nanos): void |
| { |
| $key = microtime(); |
| self::$cache-> |
| setKeyType(null)-> |
| setValueType(ObjectType::TIMESTAMP); |
| |
| try { |
| $millis = intval($nanos / 1000000); |
| $nanosInMillis = $nanos % 1000000; |
| self::$cache->put($key, |
| new Timestamp( |
| DateTime::createFromFormat($format, $dateString)->getTimestamp() * 1000 + $millis, |
| $nanosInMillis |
| ) |
| ); |
| $result = self::$cache->get($key); |
| |
| $this->assertEquals($nanos % 1000000, $result->getNanos()); |
| $this->assertEquals($dateString, $result->toDateTime()->format($format)); |
| } finally { |
| self::$cache->removeAll(); |
| } |
| } |
| |
| private function putGetTimestampFromDateTime(string $format, string $dateString, $micros): void |
| { |
| $key = microtime(); |
| self::$cache-> |
| setKeyType(null)-> |
| setValueType(ObjectType::TIMESTAMP); |
| |
| try { |
| self::$cache->put($key, Timestamp::fromDateTime( |
| DateTime::createFromFormat("$format.u", sprintf("%s.%06d", $dateString, $micros)) |
| )); |
| $result = self::$cache->get($key); |
| |
| $this->assertEquals(intval($micros / 1000) * 1000, $result->toDateTime()->format('u')); |
| $this->assertEquals($dateString, $result->toDateTime()->format($format)); |
| } finally { |
| self::$cache->removeAll(); |
| } |
| } |
| |
| private function putGetObjectArrays(?ObjectArrayType $arrayType, array $value): void |
| { |
| $key = microtime(); |
| self::$cache-> |
| setKeyType(null)-> |
| setValueType($arrayType); |
| try { |
| self::$cache->put($key, $value); |
| $result = self::$cache->get($key); |
| $this->assertTrue(is_array($result)); |
| $this->assertTrue(TestingHelper::compare($value, $result)); |
| } finally { |
| self::$cache->removeAll(); |
| } |
| } |
| |
| private function putGetLists(?CollectionObjectType $listType, array $value): void |
| { |
| $key = microtime(); |
| self::$cache-> |
| setKeyType(null)-> |
| setValueType($listType); |
| try { |
| self::$cache->put($key, $value); |
| $result = self::$cache->get($key); |
| $strResult = TestingHelper::printValue($result); |
| $strValue = TestingHelper::printValue($value); |
| $strValueType = TestingHelper::printValue($listType ? $listType->getElementType() : null); |
| $this->assertTrue( |
| is_array($result), |
| "result is not array: result={$strResult}"); |
| $this->assertTrue( |
| TestingHelper::compare($value, $result), |
| "Lists are not equal: valueType={$strValueType}, put value={$strValue}, get value={$strResult}"); |
| } finally { |
| self::$cache->removeAll(); |
| } |
| } |
| |
| private function putGetSets(?CollectionObjectType $setType, Set $value): void |
| { |
| $key = microtime(); |
| self::$cache-> |
| setKeyType(null)-> |
| setValueType($setType); |
| try { |
| self::$cache->put($key, $value); |
| $result = self::$cache->get($key); |
| $strResult = TestingHelper::printValue($result); |
| $strValue = TestingHelper::printValue($value); |
| $strValueType = TestingHelper::printValue($setType ? $setType->getElementType() : null); |
| $this->assertTrue( |
| $result instanceof Set, |
| "result is not Set: result={$strResult}"); |
| $this->assertTrue( |
| TestingHelper::compare($value, $result), |
| "Sets are not equal: valueType={$strValueType}, put value={$strValue}, get value={$strResult}"); |
| } finally { |
| self::$cache->removeAll(); |
| } |
| } |
| |
| private function putGetArrayMaps(?MapObjectType $mapType, array $value): void |
| { |
| self::$cache-> |
| setKeyType(null)-> |
| setValueType($mapType); |
| try { |
| $key = microtime(); |
| self::$cache->put($key, $value); |
| $result = self::$cache->get($key); |
| $strResult = TestingHelper::printValue($result); |
| $strValue = TestingHelper::printValue($value); |
| $strValueType = TestingHelper::printValue($mapType ? $mapType->getValueType() : null); |
| $this->assertTrue( |
| $result instanceof Map, |
| "result is not Map: result={$strResult}"); |
| $this->assertTrue( |
| TestingHelper::compare(new Map($value), $result), |
| "Maps are not equal: valueType={$strValueType}, put value={$strValue}, get value={$strResult}"); |
| } finally { |
| self::$cache->removeAll(); |
| } |
| } |
| |
| private function putGetMaps(?MapObjectType $mapType, Map $value): void |
| { |
| self::$cache-> |
| setKeyType(null)-> |
| setValueType($mapType); |
| try { |
| $key = microtime(); |
| self::$cache->put($key, $value); |
| $result = self::$cache->get($key); |
| $strResult = TestingHelper::printValue($result); |
| $strValue = TestingHelper::printValue($value); |
| $strValueType = TestingHelper::printValue($mapType ? $mapType->getValueType() : null); |
| $this->assertTrue( |
| $result instanceof Map, |
| "result is not Map: result={$strResult}"); |
| $this->assertTrue( |
| TestingHelper::compare($value, $result), |
| "Maps are not equal: valueType={$strValueType}, put value={$strValue}, get value={$strResult}"); |
| } finally { |
| self::$cache->removeAll(); |
| } |
| } |
| |
| private function putGetPrimitiveValues(?int $typeCode1, ?int $typeCode2, $value1, $value2): void |
| { |
| self::$cache-> |
| setKeyType($typeCode1)-> |
| setValueType($typeCode2); |
| try { |
| self::$cache->put($value1, $value2); |
| $result = self::$cache->get($value1); |
| $strValue1 = TestingHelper::printValue($value1); |
| $strValue2 = TestingHelper::printValue($value2); |
| $strResult = TestingHelper::printValue($result); |
| $this->assertTrue( |
| TestingHelper::compare($value2, $result), |
| "values are not equal: keyType={$typeCode1}, key={$strValue1}, valueType={$typeCode2}, put value={$strValue2}, get value={$strResult}"); |
| } finally { |
| self::$cache->removeAll(); |
| } |
| } |
| |
| private function putGetArrays(int $keyType, int $valueType, $key, $value): void |
| { |
| self::$cache-> |
| setKeyType($keyType)-> |
| setValueType($valueType); |
| try { |
| self::$cache->put($key, $value); |
| $result = self::$cache->get($key); |
| self::$cache->clearKey($key); |
| $strValue = TestingHelper::printValue($value); |
| $strResult = TestingHelper::printValue($result); |
| $this->assertTrue( |
| is_array($result), |
| "result is not Array: arrayType={$valueType}, result={$strResult}"); |
| $this->assertTrue( |
| TestingHelper::compare($value, $result), |
| "Arrays are not equal: arrayType={$valueType}, put array={$strValue}, get array={$strResult}"); |
| } finally { |
| self::$cache->removeAll(); |
| } |
| } |
| |
| private static function cleanUp(): void |
| { |
| TestingHelper::destroyCache(self::CACHE_NAME); |
| } |
| } |
