| <?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. |
| * |
| */ |
| |
| declare(strict_types=1); |
| |
| namespace Test\Thrift\Unit\Lib\Protocol; |
| |
| use PHPUnit\Framework\TestCase; |
| use PHPUnit\Framework\Attributes\DataProvider; |
| use Test\Thrift\Unit\Lib\ReflectionHelper; |
| use Thrift\Exception\TProtocolException; |
| use Thrift\Protocol\JSON\BaseContext; |
| use Thrift\Protocol\TJSONProtocol; |
| use Thrift\Transport\TMemoryBuffer; |
| use Thrift\Type\TMessageType; |
| use Thrift\Type\TType; |
| |
| class TJSONProtocolTest extends TestCase |
| { |
| use ReflectionHelper; |
| |
| #[DataProvider('writeAndReadMessageBeginDataProvider')] |
| public function testWriteAndReadMessageBegin(string $name, int $type, int $seqid) |
| { |
| $transport = new TMemoryBuffer(); |
| $protocol = new TJSONProtocol($transport); |
| |
| $protocol->writeMessageBegin($name, $type, $seqid); |
| $protocol->writeMessageEnd(); |
| |
| $protocol->reset(); |
| $transport = new TMemoryBuffer($transport->getBuffer()); |
| $protocol = new TJSONProtocol($transport); |
| |
| $readName = null; |
| $readType = null; |
| $readSeqid = null; |
| $protocol->readMessageBegin($readName, $readType, $readSeqid); |
| $protocol->readMessageEnd(); |
| |
| $this->assertSame($name, $readName); |
| $this->assertSame($type, $readType); |
| $this->assertSame($seqid, $readSeqid); |
| } |
| |
| public static function writeAndReadMessageBeginDataProvider() |
| { |
| yield 'call message' => [ |
| 'name' => 'testMethod', |
| 'type' => TMessageType::CALL, |
| 'seqid' => 1, |
| ]; |
| yield 'reply message' => [ |
| 'name' => 'getResult', |
| 'type' => TMessageType::REPLY, |
| 'seqid' => 42, |
| ]; |
| yield 'exception message' => [ |
| 'name' => 'failMethod', |
| 'type' => TMessageType::EXCEPTION, |
| 'seqid' => 100, |
| ]; |
| yield 'oneway message' => [ |
| 'name' => 'fireAndForget', |
| 'type' => TMessageType::ONEWAY, |
| 'seqid' => 0, |
| ]; |
| } |
| |
| public function testReadMessageBeginBadVersion() |
| { |
| // Manually craft a JSON message with wrong version (99 instead of 1) |
| $json = '[99,"testMethod",1,1]'; |
| $transport = new TMemoryBuffer($json); |
| $protocol = new TJSONProtocol($transport); |
| |
| $this->expectException(TProtocolException::class); |
| $this->expectExceptionCode(TProtocolException::BAD_VERSION); |
| |
| $name = null; |
| $type = null; |
| $seqid = null; |
| $protocol->readMessageBegin($name, $type, $seqid); |
| } |
| |
| #[DataProvider('writeAndReadScalarDataProvider')] |
| public function testWriteAndReadScalar(int $fieldType, string $writeMethod, $value, string $readMethod) |
| { |
| if ($fieldType === TType::I64 && PHP_INT_SIZE === 4) { |
| $this->markTestSkipped('64-bit integer tests require 64-bit PHP'); |
| } |
| |
| $transport = new TMemoryBuffer(); |
| $protocol = new TJSONProtocol($transport); |
| |
| $protocol->writeStructBegin('Test'); |
| $protocol->writeFieldBegin('f', $fieldType, 1); |
| $protocol->$writeMethod($value); |
| $protocol->writeFieldEnd(); |
| $protocol->writeFieldStop(); |
| $protocol->writeStructEnd(); |
| |
| $transport = new TMemoryBuffer($transport->getBuffer()); |
| $protocol = new TJSONProtocol($transport); |
| |
| $protocol->readStructBegin($name); |
| $protocol->readFieldBegin($fname, $ftype, $fid); |
| $result = null; |
| $protocol->$readMethod($result); |
| $protocol->readFieldEnd(); |
| $protocol->readStructEnd(); |
| |
| if (is_float($value) && is_nan($value)) { |
| $this->assertNan($result); |
| } else { |
| $this->assertSame($value, $result); |
| } |
| } |
| |
| public static function writeAndReadScalarDataProvider() |
| { |
| yield 'bool true' => [ |
| 'fieldType' => TType::BOOL, |
| 'writeMethod' => 'writeBool', |
| 'value' => true, |
| 'readMethod' => 'readBool', |
| ]; |
| yield 'bool false' => [ |
| 'fieldType' => TType::BOOL, |
| 'writeMethod' => 'writeBool', |
| 'value' => false, |
| 'readMethod' => 'readBool', |
| ]; |
| yield 'byte zero' => [ |
| 'fieldType' => TType::BYTE, |
| 'writeMethod' => 'writeByte', |
| 'value' => 0, |
| 'readMethod' => 'readByte', |
| ]; |
| yield 'byte positive' => [ |
| 'fieldType' => TType::BYTE, |
| 'writeMethod' => 'writeByte', |
| 'value' => 127, |
| 'readMethod' => 'readByte', |
| ]; |
| yield 'byte negative' => [ |
| 'fieldType' => TType::BYTE, |
| 'writeMethod' => 'writeByte', |
| 'value' => -128, |
| 'readMethod' => 'readByte', |
| ]; |
| yield 'byte one' => [ |
| 'fieldType' => TType::BYTE, |
| 'writeMethod' => 'writeByte', |
| 'value' => 1, |
| 'readMethod' => 'readByte', |
| ]; |
| yield 'i16 zero' => [ |
| 'fieldType' => TType::I16, |
| 'writeMethod' => 'writeI16', |
| 'value' => 0, |
| 'readMethod' => 'readI16', |
| ]; |
| yield 'i16 positive' => [ |
| 'fieldType' => TType::I16, |
| 'writeMethod' => 'writeI16', |
| 'value' => 32767, |
| 'readMethod' => 'readI16', |
| ]; |
| yield 'i16 negative' => [ |
| 'fieldType' => TType::I16, |
| 'writeMethod' => 'writeI16', |
| 'value' => -32768, |
| 'readMethod' => 'readI16', |
| ]; |
| yield 'i16 small positive' => [ |
| 'fieldType' => TType::I16, |
| 'writeMethod' => 'writeI16', |
| 'value' => 256, |
| 'readMethod' => 'readI16', |
| ]; |
| yield 'i32 zero' => [ |
| 'fieldType' => TType::I32, |
| 'writeMethod' => 'writeI32', |
| 'value' => 0, |
| 'readMethod' => 'readI32', |
| ]; |
| yield 'i32 positive' => [ |
| 'fieldType' => TType::I32, |
| 'writeMethod' => 'writeI32', |
| 'value' => 2147483647, |
| 'readMethod' => 'readI32', |
| ]; |
| yield 'i32 negative' => [ |
| 'fieldType' => TType::I32, |
| 'writeMethod' => 'writeI32', |
| 'value' => -2147483648, |
| 'readMethod' => 'readI32', |
| ]; |
| yield 'i32 small negative' => [ |
| 'fieldType' => TType::I32, |
| 'writeMethod' => 'writeI32', |
| 'value' => -1, |
| 'readMethod' => 'readI32', |
| ]; |
| yield 'i32 medium value' => [ |
| 'fieldType' => TType::I32, |
| 'writeMethod' => 'writeI32', |
| 'value' => 100000, |
| 'readMethod' => 'readI32', |
| ]; |
| yield 'i64 zero' => [ |
| 'fieldType' => TType::I64, |
| 'writeMethod' => 'writeI64', |
| 'value' => 0, |
| 'readMethod' => 'readI64', |
| ]; |
| yield 'i64 positive' => [ |
| 'fieldType' => TType::I64, |
| 'writeMethod' => 'writeI64', |
| 'value' => 1099511627776, |
| 'readMethod' => 'readI64', |
| ]; |
| yield 'i64 negative' => [ |
| 'fieldType' => TType::I64, |
| 'writeMethod' => 'writeI64', |
| 'value' => -1099511627776, |
| 'readMethod' => 'readI64', |
| ]; |
| yield 'i64 max int32' => [ |
| 'fieldType' => TType::I64, |
| 'writeMethod' => 'writeI64', |
| 'value' => 2147483647, |
| 'readMethod' => 'readI64', |
| ]; |
| yield 'i64 small value' => [ |
| 'fieldType' => TType::I64, |
| 'writeMethod' => 'writeI64', |
| 'value' => 42, |
| 'readMethod' => 'readI64', |
| ]; |
| yield 'double zero' => [ |
| 'fieldType' => TType::DOUBLE, |
| 'writeMethod' => 'writeDouble', |
| 'value' => 0.0, |
| 'readMethod' => 'readDouble', |
| ]; |
| yield 'double positive' => [ |
| 'fieldType' => TType::DOUBLE, |
| 'writeMethod' => 'writeDouble', |
| 'value' => 3.14159265358979, |
| 'readMethod' => 'readDouble', |
| ]; |
| yield 'double negative' => [ |
| 'fieldType' => TType::DOUBLE, |
| 'writeMethod' => 'writeDouble', |
| 'value' => -2.718281828, |
| 'readMethod' => 'readDouble', |
| ]; |
| yield 'double large' => [ |
| 'fieldType' => TType::DOUBLE, |
| 'writeMethod' => 'writeDouble', |
| 'value' => 1.7976931348623e+100, |
| 'readMethod' => 'readDouble', |
| ]; |
| yield 'double small' => [ |
| 'fieldType' => TType::DOUBLE, |
| 'writeMethod' => 'writeDouble', |
| 'value' => 1.0e-10, |
| 'readMethod' => 'readDouble', |
| ]; |
| yield 'double NaN round-trips via "NaN" token' => [ |
| 'fieldType' => TType::DOUBLE, |
| 'writeMethod' => 'writeDouble', |
| 'value' => NAN, |
| 'readMethod' => 'readDouble', |
| ]; |
| yield 'double +Infinity round-trips via "Infinity" token' => [ |
| 'fieldType' => TType::DOUBLE, |
| 'writeMethod' => 'writeDouble', |
| 'value' => INF, |
| 'readMethod' => 'readDouble', |
| ]; |
| yield 'double -Infinity round-trips via "-Infinity" token' => [ |
| 'fieldType' => TType::DOUBLE, |
| 'writeMethod' => 'writeDouble', |
| 'value' => -INF, |
| 'readMethod' => 'readDouble', |
| ]; |
| yield 'string empty' => [ |
| 'fieldType' => TType::STRING, |
| 'writeMethod' => 'writeString', |
| 'value' => '', |
| 'readMethod' => 'readString', |
| ]; |
| yield 'string simple' => [ |
| 'fieldType' => TType::STRING, |
| 'writeMethod' => 'writeString', |
| 'value' => 'hello world', |
| 'readMethod' => 'readString', |
| ]; |
| yield 'string special characters' => [ |
| 'fieldType' => TType::STRING, |
| 'writeMethod' => 'writeString', |
| 'value' => "line1\nline2\ttab", |
| 'readMethod' => 'readString', |
| ]; |
| yield 'string unicode' => [ |
| 'fieldType' => TType::STRING, |
| 'writeMethod' => 'writeString', |
| 'value' => 'héllo wörld', |
| 'readMethod' => 'readString', |
| ]; |
| yield 'string quotes and backslash' => [ |
| 'fieldType' => TType::STRING, |
| 'writeMethod' => 'writeString', |
| 'value' => 'say "hello" and use \\path', |
| 'readMethod' => 'readString', |
| ]; |
| yield 'string json special chars' => [ |
| 'fieldType' => TType::STRING, |
| 'writeMethod' => 'writeString', |
| 'value' => '{"key": "value"}', |
| 'readMethod' => 'readString', |
| ]; |
| yield 'uuid standard' => [ |
| 'fieldType' => TType::UUID, |
| 'writeMethod' => 'writeUuid', |
| 'value' => '12345678-1234-5678-1234-567812345678', |
| 'readMethod' => 'readUuid', |
| ]; |
| yield 'uuid nil' => [ |
| 'fieldType' => TType::UUID, |
| 'writeMethod' => 'writeUuid', |
| 'value' => '00000000-0000-0000-0000-000000000000', |
| 'readMethod' => 'readUuid', |
| ]; |
| yield 'uuid random' => [ |
| 'fieldType' => TType::UUID, |
| 'writeMethod' => 'writeUuid', |
| 'value' => 'a1b2c3d4-e5f6-7890-abcd-ef1234567890', |
| 'readMethod' => 'readUuid', |
| ]; |
| } |
| |
| public function testWriteAndReadStruct() |
| { |
| $transport = new TMemoryBuffer(); |
| $protocol = new TJSONProtocol($transport); |
| |
| $protocol->writeStructBegin('TestStruct'); |
| $protocol->writeFieldBegin('name', TType::STRING, 1); |
| $protocol->writeString('hello'); |
| $protocol->writeFieldEnd(); |
| $protocol->writeFieldBegin('age', TType::I32, 2); |
| $protocol->writeI32(25); |
| $protocol->writeFieldEnd(); |
| $protocol->writeFieldStop(); |
| $protocol->writeStructEnd(); |
| |
| $transport = new TMemoryBuffer($transport->getBuffer()); |
| $protocol = new TJSONProtocol($transport); |
| |
| $name = null; |
| $protocol->readStructBegin($name); |
| |
| $fieldName = null; |
| $fieldType = null; |
| $fieldId = null; |
| $protocol->readFieldBegin($fieldName, $fieldType, $fieldId); |
| $this->assertSame(TType::STRING, $fieldType); |
| $this->assertSame(1, $fieldId); |
| $str = null; |
| $protocol->readString($str); |
| $this->assertSame('hello', $str); |
| $protocol->readFieldEnd(); |
| |
| $protocol->readFieldBegin($fieldName, $fieldType, $fieldId); |
| $this->assertSame(TType::I32, $fieldType); |
| $this->assertSame(2, $fieldId); |
| $i32 = null; |
| $protocol->readI32($i32); |
| $this->assertSame(25, $i32); |
| $protocol->readFieldEnd(); |
| |
| // Read field stop |
| $protocol->readFieldBegin($fieldName, $fieldType, $fieldId); |
| $this->assertSame(TType::STOP, $fieldType); |
| |
| $protocol->readStructEnd(); |
| } |
| |
| public function testWriteAndReadMap() |
| { |
| $transport = new TMemoryBuffer(); |
| $protocol = new TJSONProtocol($transport); |
| |
| $protocol->writeMapBegin(TType::STRING, TType::I32, 2); |
| $protocol->writeString('key1'); |
| $protocol->writeI32(100); |
| $protocol->writeString('key2'); |
| $protocol->writeI32(200); |
| $protocol->writeMapEnd(); |
| |
| $transport = new TMemoryBuffer($transport->getBuffer()); |
| $protocol = new TJSONProtocol($transport); |
| |
| $keyType = null; |
| $valType = null; |
| $size = null; |
| $protocol->readMapBegin($keyType, $valType, $size); |
| $this->assertSame(TType::STRING, $keyType); |
| $this->assertSame(TType::I32, $valType); |
| $this->assertSame(2, $size); |
| |
| $key = null; |
| $val = null; |
| $protocol->readString($key); |
| $protocol->readI32($val); |
| $this->assertSame('key1', $key); |
| $this->assertSame(100, $val); |
| |
| $protocol->readString($key); |
| $protocol->readI32($val); |
| $this->assertSame('key2', $key); |
| $this->assertSame(200, $val); |
| |
| $protocol->readMapEnd(); |
| } |
| |
| public function testWriteAndReadList() |
| { |
| $transport = new TMemoryBuffer(); |
| $protocol = new TJSONProtocol($transport); |
| |
| $protocol->writeListBegin(TType::I32, 3); |
| $protocol->writeI32(10); |
| $protocol->writeI32(20); |
| $protocol->writeI32(30); |
| $protocol->writeListEnd(); |
| |
| $transport = new TMemoryBuffer($transport->getBuffer()); |
| $protocol = new TJSONProtocol($transport); |
| |
| $elemType = null; |
| $size = null; |
| $protocol->readListBegin($elemType, $size); |
| $this->assertSame(TType::I32, $elemType); |
| $this->assertSame(3, $size); |
| |
| $val = null; |
| $protocol->readI32($val); |
| $this->assertSame(10, $val); |
| $protocol->readI32($val); |
| $this->assertSame(20, $val); |
| $protocol->readI32($val); |
| $this->assertSame(30, $val); |
| |
| $protocol->readListEnd(); |
| } |
| |
| public function testWriteAndReadSet() |
| { |
| $transport = new TMemoryBuffer(); |
| $protocol = new TJSONProtocol($transport); |
| |
| $protocol->writeSetBegin(TType::STRING, 2); |
| $protocol->writeString('alpha'); |
| $protocol->writeString('beta'); |
| $protocol->writeSetEnd(); |
| |
| $transport = new TMemoryBuffer($transport->getBuffer()); |
| $protocol = new TJSONProtocol($transport); |
| |
| $elemType = null; |
| $size = null; |
| $protocol->readSetBegin($elemType, $size); |
| $this->assertSame(TType::STRING, $elemType); |
| $this->assertSame(2, $size); |
| |
| $val = null; |
| $protocol->readString($val); |
| $this->assertSame('alpha', $val); |
| $protocol->readString($val); |
| $this->assertSame('beta', $val); |
| |
| $protocol->readSetEnd(); |
| } |
| |
| public function testWriteAndReadEmptyMap() |
| { |
| $transport = new TMemoryBuffer(); |
| $protocol = new TJSONProtocol($transport); |
| |
| $protocol->writeMapBegin(TType::STRING, TType::I32, 0); |
| $protocol->writeMapEnd(); |
| |
| $transport = new TMemoryBuffer($transport->getBuffer()); |
| $protocol = new TJSONProtocol($transport); |
| |
| $keyType = null; |
| $valType = null; |
| $size = null; |
| $protocol->readMapBegin($keyType, $valType, $size); |
| $this->assertSame(TType::STRING, $keyType); |
| $this->assertSame(TType::I32, $valType); |
| $this->assertSame(0, $size); |
| |
| $protocol->readMapEnd(); |
| } |
| |
| public function testWriteAndReadEmptyList() |
| { |
| $transport = new TMemoryBuffer(); |
| $protocol = new TJSONProtocol($transport); |
| |
| $protocol->writeListBegin(TType::BOOL, 0); |
| $protocol->writeListEnd(); |
| |
| $transport = new TMemoryBuffer($transport->getBuffer()); |
| $protocol = new TJSONProtocol($transport); |
| |
| $elemType = null; |
| $size = null; |
| $protocol->readListBegin($elemType, $size); |
| $this->assertSame(TType::BOOL, $elemType); |
| $this->assertSame(0, $size); |
| |
| $protocol->readListEnd(); |
| } |
| |
| public function testGetTypeNameForUnknownType() |
| { |
| $transport = new TMemoryBuffer(); |
| $protocol = new TJSONProtocol($transport); |
| |
| $this->expectException(TProtocolException::class); |
| $this->expectExceptionCode(TProtocolException::UNKNOWN); |
| |
| // Use writeFieldBegin with an invalid type to trigger getTypeNameForTypeID |
| $protocol->writeFieldBegin('invalid', 99, 1); |
| } |
| |
| public function testGetTypeIDForUnknownTypeName() |
| { |
| // Craft JSON that has an unknown type name in field position |
| // A struct with one field: fieldId=1, then object start, then unknown type name |
| $json = '{1:{"zzz"'; |
| $transport = new TMemoryBuffer($json); |
| $protocol = new TJSONProtocol($transport); |
| |
| $this->expectException(TProtocolException::class); |
| $this->expectExceptionCode(TProtocolException::INVALID_DATA); |
| |
| $name = null; |
| $protocol->readStructBegin($name); |
| |
| $fieldName = null; |
| $fieldType = null; |
| $fieldId = null; |
| $protocol->readFieldBegin($fieldName, $fieldType, $fieldId); |
| } |
| |
| public function testWriteAndReadCompleteMessage() |
| { |
| $transport = new TMemoryBuffer(); |
| $protocol = new TJSONProtocol($transport); |
| |
| // Write a complete message with a struct containing various types |
| $protocol->writeMessageBegin('testFunc', TMessageType::CALL, 7); |
| $protocol->writeStructBegin('Args'); |
| $protocol->writeFieldBegin('flag', TType::BOOL, 1); |
| $protocol->writeBool(true); |
| $protocol->writeFieldEnd(); |
| $protocol->writeFieldBegin('count', TType::I32, 2); |
| $protocol->writeI32(42); |
| $protocol->writeFieldEnd(); |
| $protocol->writeFieldStop(); |
| $protocol->writeStructEnd(); |
| $protocol->writeMessageEnd(); |
| |
| $transport = new TMemoryBuffer($transport->getBuffer()); |
| $protocol = new TJSONProtocol($transport); |
| |
| $name = null; |
| $type = null; |
| $seqid = null; |
| $protocol->readMessageBegin($name, $type, $seqid); |
| $this->assertSame('testFunc', $name); |
| $this->assertSame(TMessageType::CALL, $type); |
| $this->assertSame(7, $seqid); |
| |
| $structName = null; |
| $protocol->readStructBegin($structName); |
| |
| $fieldName = null; |
| $fieldType = null; |
| $fieldId = null; |
| |
| $protocol->readFieldBegin($fieldName, $fieldType, $fieldId); |
| $this->assertSame(TType::BOOL, $fieldType); |
| $this->assertSame(1, $fieldId); |
| $boolVal = null; |
| $protocol->readBool($boolVal); |
| $this->assertTrue($boolVal); |
| $protocol->readFieldEnd(); |
| |
| $protocol->readFieldBegin($fieldName, $fieldType, $fieldId); |
| $this->assertSame(TType::I32, $fieldType); |
| $this->assertSame(2, $fieldId); |
| $i32Val = null; |
| $protocol->readI32($i32Val); |
| $this->assertSame(42, $i32Val); |
| $protocol->readFieldEnd(); |
| |
| $protocol->readFieldBegin($fieldName, $fieldType, $fieldId); |
| $this->assertSame(TType::STOP, $fieldType); |
| |
| $protocol->readStructEnd(); |
| $protocol->readMessageEnd(); |
| } |
| |
| public function testWriteAndReadNestedList() |
| { |
| $transport = new TMemoryBuffer(); |
| $protocol = new TJSONProtocol($transport); |
| |
| // Write a list of lists |
| $protocol->writeListBegin(TType::LST, 2); |
| |
| $protocol->writeListBegin(TType::I32, 2); |
| $protocol->writeI32(1); |
| $protocol->writeI32(2); |
| $protocol->writeListEnd(); |
| |
| $protocol->writeListBegin(TType::I32, 2); |
| $protocol->writeI32(3); |
| $protocol->writeI32(4); |
| $protocol->writeListEnd(); |
| |
| $protocol->writeListEnd(); |
| |
| $transport = new TMemoryBuffer($transport->getBuffer()); |
| $protocol = new TJSONProtocol($transport); |
| |
| $elemType = null; |
| $size = null; |
| $protocol->readListBegin($elemType, $size); |
| $this->assertSame(TType::LST, $elemType); |
| $this->assertSame(2, $size); |
| |
| $protocol->readListBegin($elemType, $size); |
| $this->assertSame(TType::I32, $elemType); |
| $this->assertSame(2, $size); |
| $val = null; |
| $protocol->readI32($val); |
| $this->assertSame(1, $val); |
| $protocol->readI32($val); |
| $this->assertSame(2, $val); |
| $protocol->readListEnd(); |
| |
| $protocol->readListBegin($elemType, $size); |
| $this->assertSame(TType::I32, $elemType); |
| $this->assertSame(2, $size); |
| $protocol->readI32($val); |
| $this->assertSame(3, $val); |
| $protocol->readI32($val); |
| $this->assertSame(4, $val); |
| $protocol->readListEnd(); |
| |
| $protocol->readListEnd(); |
| } |
| |
| public function testWriteAndReadMapWithIntegerKeys() |
| { |
| $transport = new TMemoryBuffer(); |
| $protocol = new TJSONProtocol($transport); |
| |
| $protocol->writeMapBegin(TType::I32, TType::STRING, 2); |
| $protocol->writeI32(1); |
| $protocol->writeString('one'); |
| $protocol->writeI32(2); |
| $protocol->writeString('two'); |
| $protocol->writeMapEnd(); |
| |
| $transport = new TMemoryBuffer($transport->getBuffer()); |
| $protocol = new TJSONProtocol($transport); |
| |
| $keyType = null; |
| $valType = null; |
| $size = null; |
| $protocol->readMapBegin($keyType, $valType, $size); |
| $this->assertSame(TType::I32, $keyType); |
| $this->assertSame(TType::STRING, $valType); |
| $this->assertSame(2, $size); |
| |
| $key = null; |
| $val = null; |
| $protocol->readI32($key); |
| $protocol->readString($val); |
| $this->assertSame(1, $key); |
| $this->assertSame('one', $val); |
| |
| $protocol->readI32($key); |
| $protocol->readString($val); |
| $this->assertSame(2, $key); |
| $this->assertSame('two', $val); |
| |
| $protocol->readMapEnd(); |
| } |
| |
| /** |
| * Guards the popContext underflow recovery added when the `$context` |
| * property was tightened to non-nullable: an empty stack now yields a |
| * default BaseContext instead of returning null and tripping the typed |
| * property assignment. |
| */ |
| public function testPopContextOnEmptyStackFallsBackToBaseContext(): void |
| { |
| $protocol = new TJSONProtocol(new TMemoryBuffer()); |
| |
| // Reflect into the private popContext()/context to assert the |
| // underflow path completes without TypeError. |
| $popContext = $this->getAccessibleMethod($protocol, 'popContext'); |
| $popContext->invoke($protocol); |
| |
| $context = $this->getPropertyValue($protocol, 'context'); |
| $this->assertInstanceOf(BaseContext::class, $context); |
| } |
| } |
