| <?php | |
| require_once('test_base.php'); | |
| require_once('test_util.php'); | |
| use Google\Protobuf\RepeatedField; | |
| use Google\Protobuf\GPBType; | |
| use Foo\EmptyAnySerialization; | |
| use Foo\TestInt32Value; | |
| use Foo\TestInt64Value; | |
| use Foo\TestUInt32Value; | |
| use Foo\TestUInt64Value; | |
| use Foo\TestBoolValue; | |
| use Foo\TestStringValue; | |
| use Foo\TestBytesValue; | |
| use Foo\TestAny; | |
| use Foo\TestEnum; | |
| use Foo\TestLargeFieldNumber; | |
| use Foo\TestMessage; | |
| use Foo\TestMessage\Sub; | |
| use Foo\TestPackedMessage; | |
| use Foo\TestRandomFieldOrder; | |
| use Foo\TestUnpackedMessage; | |
| use Google\Protobuf\Any; | |
| use Google\Protobuf\DoubleValue; | |
| use Google\Protobuf\FieldMask; | |
| use Google\Protobuf\FloatValue; | |
| use Google\Protobuf\Int32Value; | |
| use Google\Protobuf\UInt32Value; | |
| use Google\Protobuf\Int64Value; | |
| use Google\Protobuf\UInt64Value; | |
| use Google\Protobuf\BoolValue; | |
| use Google\Protobuf\StringValue; | |
| use Google\Protobuf\BytesValue; | |
| use Google\Protobuf\Value; | |
| use Google\Protobuf\ListValue; | |
| use Google\Protobuf\Struct; | |
| use Google\Protobuf\GPBEmpty; | |
| class EncodeDecodeTest extends TestBase | |
| { | |
| public function testDecodeJsonSimple() | |
| { | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"optionalInt32\":1}"); | |
| $this->assertEquals(1, $m->getOptionalInt32()); | |
| } | |
| public function testDecodeJsonUnknown() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":1}"); | |
| } | |
| public function testDecodeJsonIgnoreUnknown() | |
| { | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":1}", true); | |
| $this->assertEquals("{}", $m->serializeToJsonString()); | |
| } | |
| public function testDecodeTopLevelBoolValue() | |
| { | |
| $m = new BoolValue(); | |
| $m->mergeFromJsonString("true"); | |
| $this->assertEquals(true, $m->getValue()); | |
| $m->mergeFromJsonString("false"); | |
| $this->assertEquals(false, $m->getValue()); | |
| } | |
| public function testEncodeTopLevelBoolValue() | |
| { | |
| $m = new BoolValue(); | |
| $m->setValue(true); | |
| $this->assertSame("true", $m->serializeToJsonString()); | |
| } | |
| public function testDecodeTopLevelDoubleValue() | |
| { | |
| $m = new DoubleValue(); | |
| $m->mergeFromJsonString("1.5"); | |
| $this->assertEquals(1.5, $m->getValue()); | |
| } | |
| public function testEncodeTopLevelDoubleValue() | |
| { | |
| $m = new DoubleValue(); | |
| $m->setValue(1.5); | |
| $this->assertSame("1.5", $m->serializeToJsonString()); | |
| } | |
| public function testDecodeTopLevelFloatValue() | |
| { | |
| $m = new FloatValue(); | |
| $m->mergeFromJsonString("1.5"); | |
| $this->assertEquals(1.5, $m->getValue()); | |
| } | |
| public function testEncodeTopLevelFloatValue() | |
| { | |
| $m = new FloatValue(); | |
| $m->setValue(1.5); | |
| $this->assertSame("1.5", $m->serializeToJsonString()); | |
| } | |
| public function testDecodeTopLevelInt32Value() | |
| { | |
| $m = new Int32Value(); | |
| $m->mergeFromJsonString("1"); | |
| $this->assertEquals(1, $m->getValue()); | |
| } | |
| public function testEncodeTopLevelInt32Value() | |
| { | |
| $m = new Int32Value(); | |
| $m->setValue(1); | |
| $this->assertSame("1", $m->serializeToJsonString()); | |
| } | |
| public function testDecodeRepeatedInt32Value() | |
| { | |
| $m = new TestInt32Value(); | |
| $m->mergeFromJsonString("{\"repeated_field\":[12345]}"); | |
| $this->assertSame(12345, $m->getRepeatedField()[0]->getValue()); | |
| } | |
| public function testDecodeTopLevelUInt32Value() | |
| { | |
| $m = new UInt32Value(); | |
| $m->mergeFromJsonString("1"); | |
| $this->assertEquals(1, $m->getValue()); | |
| } | |
| public function testEncodeTopLevelUInt32Value() | |
| { | |
| $m = new UInt32Value(); | |
| $m->setValue(1); | |
| $this->assertSame("1", $m->serializeToJsonString()); | |
| } | |
| public function testDecodeTopLevelInt64Value() | |
| { | |
| $m = new Int64Value(); | |
| $m->mergeFromJsonString("1"); | |
| $this->assertEquals(1, $m->getValue()); | |
| } | |
| public function testDecodeTopLevelInt64ValueAsString() | |
| { | |
| $m = new Int64Value(); | |
| $m->mergeFromJsonString("\"1\""); | |
| $this->assertEquals(1, $m->getValue()); | |
| } | |
| public function testEncodeTopLevelInt64Value() | |
| { | |
| $m = new Int64Value(); | |
| $m->setValue(1); | |
| $this->assertSame("\"1\"", $m->serializeToJsonString()); | |
| } | |
| public function testDecodeTopLevelUInt64Value() | |
| { | |
| $m = new UInt64Value(); | |
| $m->mergeFromJsonString("1"); | |
| $this->assertEquals(1, $m->getValue()); | |
| } | |
| public function testDecodeTopLevelUInt64ValueAsString() | |
| { | |
| $m = new UInt64Value(); | |
| $m->mergeFromJsonString("\"1\""); | |
| $this->assertEquals(1, $m->getValue()); | |
| } | |
| public function testEncodeTopLevelUInt64Value() | |
| { | |
| $m = new UInt64Value(); | |
| $m->setValue(1); | |
| $this->assertSame("\"1\"", $m->serializeToJsonString()); | |
| } | |
| public function testDecodeTopLevelStringValue() | |
| { | |
| $m = new StringValue(); | |
| $m->mergeFromJsonString("\"a\""); | |
| $this->assertSame("a", $m->getValue()); | |
| } | |
| public function testEncodeTopLevelStringValue() | |
| { | |
| $m = new StringValue(); | |
| $m->setValue("a"); | |
| $this->assertSame("\"a\"", $m->serializeToJsonString()); | |
| } | |
| public function testDecodeRepeatedStringValue() | |
| { | |
| $m = new TestStringValue(); | |
| $m->mergeFromJsonString("{\"repeated_field\":[\"a\"]}"); | |
| $this->assertSame("a", $m->getRepeatedField()[0]->getValue()); | |
| } | |
| public function testDecodeMapStringValue() | |
| { | |
| $m = new TestStringValue(); | |
| $m->mergeFromJsonString("{\"map_field\":{\"1\": \"a\"}}"); | |
| $this->assertSame("a", $m->getMapField()[1]->getValue()); | |
| } | |
| public function testDecodeTopLevelBytesValue() | |
| { | |
| $m = new BytesValue(); | |
| $m->mergeFromJsonString("\"YQ==\""); | |
| $this->assertSame("a", $m->getValue()); | |
| } | |
| public function testEncodeTopLevelBytesValue() | |
| { | |
| $m = new BytesValue(); | |
| $m->setValue("a"); | |
| $this->assertSame("\"YQ==\"", $m->serializeToJsonString()); | |
| } | |
| public function generateRandomString($length = 10) { | |
| $randomString = str_repeat("+", $length); | |
| for ($i = 0; $i < $length; $i++) { | |
| $randomString[$i] = chr(rand(0, 255)); | |
| } | |
| return $randomString; | |
| } | |
| public function testEncodeTopLevelLongBytesValue() | |
| { | |
| $m = new BytesValue(); | |
| $data = $this->generateRandomString(12007); | |
| $m->setValue($data); | |
| $expected = "\"" . base64_encode($data) . "\""; | |
| $this->assertSame(strlen($expected), strlen($m->serializeToJsonString())); | |
| } | |
| public function testEncode() | |
| { | |
| $from = new TestMessage(); | |
| $this->expectEmptyFields($from); | |
| $this->setFields($from); | |
| $this->expectFields($from); | |
| $data = $from->serializeToString(); | |
| $this->assertSame(bin2hex(TestUtil::getGoldenTestMessage()), | |
| bin2hex($data)); | |
| } | |
| public function testDecode() | |
| { | |
| $to = new TestMessage(); | |
| $to->mergeFromString(TestUtil::getGoldenTestMessage()); | |
| $this->expectFields($to); | |
| } | |
| public function testEncodeDecode() | |
| { | |
| $from = new TestMessage(); | |
| $this->expectEmptyFields($from); | |
| $this->setFields($from); | |
| $this->expectFields($from); | |
| $data = $from->serializeToString(); | |
| $to = new TestMessage(); | |
| $to->mergeFromString($data); | |
| $this->expectFields($to); | |
| } | |
| public function testEncodeDecodeEmpty() | |
| { | |
| $from = new TestMessage(); | |
| $this->expectEmptyFields($from); | |
| $data = $from->serializeToString(); | |
| $to = new TestMessage(); | |
| $to->mergeFromString($data); | |
| $this->expectEmptyFields($to); | |
| } | |
| public function testEncodeDecodeOneof() | |
| { | |
| $m = new TestMessage(); | |
| $m->setOneofInt32(1); | |
| $data = $m->serializeToString(); | |
| $n = new TestMessage(); | |
| $n->mergeFromString($data); | |
| $this->assertSame(1, $n->getOneofInt32()); | |
| $m->setOneofFloat(2.0); | |
| $data = $m->serializeToString(); | |
| $n = new TestMessage(); | |
| $n->mergeFromString($data); | |
| $this->assertSame(2.0, $n->getOneofFloat()); | |
| $m->setOneofString('abc'); | |
| $data = $m->serializeToString(); | |
| $n = new TestMessage(); | |
| $n->mergeFromString($data); | |
| $this->assertSame('abc', $n->getOneofString()); | |
| $sub_m = new Sub(); | |
| $sub_m->setA(1); | |
| $m->setOneofMessage($sub_m); | |
| $data = $m->serializeToString(); | |
| $n = new TestMessage(); | |
| $n->mergeFromString($data); | |
| $this->assertSame(1, $n->getOneofMessage()->getA()); | |
| // Encode default value | |
| $m->setOneofEnum(TestEnum::ZERO); | |
| $data = $m->serializeToString(); | |
| $n = new TestMessage(); | |
| $n->mergeFromString($data); | |
| $this->assertSame("oneof_enum", $n->getMyOneof()); | |
| $this->assertSame(TestEnum::ZERO, $n->getOneofEnum()); | |
| $m->setOneofString(""); | |
| $data = $m->serializeToString(); | |
| $n = new TestMessage(); | |
| $n->mergeFromString($data); | |
| $this->assertSame("oneof_string", $n->getMyOneof()); | |
| $this->assertSame("", $n->getOneofString()); | |
| $sub_m = new Sub(); | |
| $m->setOneofMessage($sub_m); | |
| $data = $m->serializeToString(); | |
| $n = new TestMessage(); | |
| $n->mergeFromString($data); | |
| $this->assertSame("oneof_message", $n->getMyOneof()); | |
| $this->assertFalse(is_null($n->getOneofMessage())); | |
| } | |
| public function testEncodeDecodeOptional() | |
| { | |
| $m = new TestMessage(); | |
| $this->assertFalse($m->hasTrueOptionalInt32()); | |
| $data = $m->serializeToString(); | |
| $this->assertSame("", $data); | |
| $m->setTrueOptionalInt32(0); | |
| $this->assertTrue($m->hasTrueOptionalInt32()); | |
| $data = $m->serializeToString(); | |
| $this->assertNotSame("", $data); | |
| $m2 = new TestMessage(); | |
| $m2->mergeFromString($data); | |
| $this->assertTrue($m2->hasTrueOptionalInt32()); | |
| $this->assertSame(0, $m2->getTrueOptionalInt32()); | |
| } | |
| public function testJsonEncodeDecodeOptional() | |
| { | |
| $m = new TestMessage(); | |
| $this->assertFalse($m->hasTrueOptionalInt32()); | |
| $data = $m->serializeToJsonString(); | |
| $this->assertSame("{}", $data); | |
| $m->setTrueOptionalInt32(0); | |
| $this->assertTrue($m->hasTrueOptionalInt32()); | |
| $data = $m->serializeToJsonString(); | |
| $this->assertNotSame("{}", $data); | |
| $m2 = new TestMessage(); | |
| $m2->mergeFromJsonString($data); | |
| $this->assertTrue($m2->hasTrueOptionalInt32()); | |
| $this->assertSame(0, $m2->getTrueOptionalInt32()); | |
| } | |
| public function testJsonEncodeDecodeOneof() | |
| { | |
| $m = new TestMessage(); | |
| $m->setOneofEnum(TestEnum::ONE); | |
| $data = $m->serializeToJsonString(); | |
| $n = new TestMessage(); | |
| $n->mergeFromJsonString($data); | |
| $this->assertSame("oneof_enum", $n->getMyOneof()); | |
| $this->assertSame(TestEnum::ONE, $n->getOneofEnum()); | |
| $m->setOneofString("a"); | |
| $data = $m->serializeToJsonString(); | |
| $n = new TestMessage(); | |
| $n->mergeFromJsonString($data); | |
| $this->assertSame("oneof_string", $n->getMyOneof()); | |
| $this->assertSame("a", $n->getOneofString()); | |
| $m->setOneofBytes("bbbb"); | |
| $data = $m->serializeToJsonString(); | |
| $n = new TestMessage(); | |
| $n->mergeFromJsonString($data); | |
| $this->assertSame("oneof_bytes", $n->getMyOneof()); | |
| $this->assertSame("bbbb", $n->getOneofBytes()); | |
| $sub_m = new Sub(); | |
| $m->setOneofMessage($sub_m); | |
| $data = $m->serializeToJsonString(); | |
| $n = new TestMessage(); | |
| $n->mergeFromJsonString($data); | |
| $this->assertSame("oneof_message", $n->getMyOneof()); | |
| $this->assertFalse(is_null($n->getOneofMessage())); | |
| } | |
| public function testPackedEncode() | |
| { | |
| $from = new TestPackedMessage(); | |
| TestUtil::setTestPackedMessage($from); | |
| $this->assertSame(TestUtil::getGoldenTestPackedMessage(), | |
| $from->serializeToString()); | |
| } | |
| public function testPackedDecodePacked() | |
| { | |
| $to = new TestPackedMessage(); | |
| $to->mergeFromString(TestUtil::getGoldenTestPackedMessage()); | |
| TestUtil::assertTestPackedMessage($to); | |
| $this->assertTrue(true); | |
| } | |
| public function testPackedDecodeUnpacked() | |
| { | |
| $to = new TestPackedMessage(); | |
| $to->mergeFromString(TestUtil::getGoldenTestUnpackedMessage()); | |
| TestUtil::assertTestPackedMessage($to); | |
| $this->assertTrue(true); | |
| } | |
| public function testUnpackedEncode() | |
| { | |
| $from = new TestUnpackedMessage(); | |
| TestUtil::setTestPackedMessage($from); | |
| $this->assertSame(TestUtil::getGoldenTestUnpackedMessage(), | |
| $from->serializeToString()); | |
| } | |
| public function testUnpackedDecodePacked() | |
| { | |
| $to = new TestUnpackedMessage(); | |
| $to->mergeFromString(TestUtil::getGoldenTestPackedMessage()); | |
| TestUtil::assertTestPackedMessage($to); | |
| $this->assertTrue(true); | |
| } | |
| public function testUnpackedDecodeUnpacked() | |
| { | |
| $to = new TestUnpackedMessage(); | |
| $to->mergeFromString(TestUtil::getGoldenTestUnpackedMessage()); | |
| TestUtil::assertTestPackedMessage($to); | |
| $this->assertTrue(true); | |
| } | |
| public function testDecodeInt64() | |
| { | |
| // Read 64 testing | |
| $testVals = array( | |
| '10' => '100a', | |
| '100' => '1064', | |
| '800' => '10a006', | |
| '6400' => '108032', | |
| '70400' => '1080a604', | |
| '774400' => '1080a22f', | |
| '9292800' => '108098b704', | |
| '74342400' => '1080c0b923', | |
| '743424000' => '108080bfe202', | |
| '8177664000' => '108080b5bb1e', | |
| '65421312000' => '108080a8dbf301', | |
| '785055744000' => '108080e0c7ec16', | |
| '9420668928000' => '10808080dd969202', | |
| '103627358208000' => '10808080fff9c717', | |
| '1139900940288000' => '10808080f5bd978302', | |
| '13678811283456000' => '10808080fce699a618', | |
| '109430490267648000' => '10808080e0b7ceb1c201', | |
| '984874412408832000' => '10808080e0f5c1bed50d', | |
| ); | |
| $msg = new TestMessage(); | |
| foreach ($testVals as $original => $encoded) { | |
| $msg->setOptionalInt64($original); | |
| $data = $msg->serializeToString(); | |
| $this->assertSame($encoded, bin2hex($data)); | |
| $msg->setOptionalInt64(0); | |
| $msg->mergeFromString($data); | |
| $this->assertEquals($original, $msg->getOptionalInt64()); | |
| } | |
| } | |
| public function testDecodeToExistingMessage() | |
| { | |
| $m1 = new TestMessage(); | |
| $this->setFields($m1); | |
| $this->expectFields($m1); | |
| $m2 = new TestMessage(); | |
| $this->setFields2($m2); | |
| $data = $m2->serializeToString(); | |
| $m1->mergeFromString($data); | |
| $this->expectFieldsMerged($m1); | |
| } | |
| public function testDecodeFieldNonExist() | |
| { | |
| $data = hex2bin('c80501'); | |
| $m = new TestMessage(); | |
| $m->mergeFromString($data); | |
| $this->assertTrue(true); | |
| } | |
| public function testEncodeNegativeInt32() | |
| { | |
| $m = new TestMessage(); | |
| $m->setOptionalInt32(-1); | |
| $data = $m->serializeToString(); | |
| $this->assertSame("08ffffffffffffffffff01", bin2hex($data)); | |
| } | |
| public function testDecodeNegativeInt32() | |
| { | |
| $m = new TestMessage(); | |
| $this->assertEquals(0, $m->getOptionalInt32()); | |
| $m->mergeFromString(hex2bin("08ffffffffffffffffff01")); | |
| $this->assertEquals(-1, $m->getOptionalInt32()); | |
| $m = new TestMessage(); | |
| $this->assertEquals(0, $m->getOptionalInt32()); | |
| $m->mergeFromString(hex2bin("08ffffffff0f")); | |
| $this->assertEquals(-1, $m->getOptionalInt32()); | |
| } | |
| public function testRandomFieldOrder() | |
| { | |
| $m = new TestRandomFieldOrder(); | |
| $data = $m->serializeToString(); | |
| $this->assertSame("", $data); | |
| } | |
| public function testLargeFieldNumber() | |
| { | |
| $m = new TestLargeFieldNumber(['large_field_number' => 5]); | |
| $data = $m->serializeToString(); | |
| $m2 = new TestLargeFieldNumber(); | |
| $m2->mergeFromString($data); | |
| $this->assertSame(5, $m2->getLargeFieldNumber()); | |
| } | |
| public function testDecodeInvalidInt32() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('08')); | |
| } | |
| public function testDecodeInvalidSubMessage() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('9A010108')); | |
| } | |
| public function testDecodeInvalidInt64() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('10')); | |
| } | |
| public function testDecodeInvalidUInt32() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('18')); | |
| } | |
| public function testDecodeInvalidUInt64() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('20')); | |
| } | |
| public function testDecodeInvalidSInt32() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('28')); | |
| } | |
| public function testDecodeInvalidSInt64() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('30')); | |
| } | |
| public function testDecodeInvalidFixed32() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('3D')); | |
| } | |
| public function testDecodeInvalidFixed64() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('41')); | |
| } | |
| public function testDecodeInvalidSFixed32() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('4D')); | |
| } | |
| public function testDecodeInvalidSFixed64() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('51')); | |
| } | |
| public function testDecodeInvalidFloat() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('5D')); | |
| } | |
| public function testDecodeInvalidDouble() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('61')); | |
| } | |
| public function testDecodeInvalidBool() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('68')); | |
| } | |
| public function testDecodeInvalidStringLengthMiss() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('72')); | |
| } | |
| public function testDecodeInvalidStringDataMiss() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('7201')); | |
| } | |
| public function testDecodeInvalidStringDataBadUtf8() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('720180')); | |
| } | |
| public function testDecodeValidStringData() | |
| { | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('720161')); | |
| $this->assertSame('a', $m->getOptionalString()); | |
| } | |
| public function testDecodeInvalidBytesLengthMiss() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('7A')); | |
| } | |
| public function testDecodeInvalidBytesDataMiss() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('7A01')); | |
| } | |
| public function testEncodeDecodeValidUtf8() | |
| { | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"optionalString\":\"\\u1000\"}"); | |
| $serialized = $m->serializeToString(); | |
| $m2 = new TestMessage(); | |
| $m2->mergeFromString($serialized); | |
| $this->assertSame($m->getOptionalString(), $m2->getOptionalString()); | |
| } | |
| public function testDecodeInvalidEnum() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('8001')); | |
| } | |
| public function testDecodeInvalidMessageLengthMiss() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('8A01')); | |
| } | |
| public function testDecodeInvalidMessageDataMiss() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin('8A0101')); | |
| } | |
| public function testDecodeInvalidPackedMessageLength() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestPackedMessage(); | |
| $m->mergeFromString(hex2bin('D205')); | |
| } | |
| public function testUnknown() | |
| { | |
| // Test preserve unknown for varint. | |
| $m = new TestMessage(); | |
| $from = hex2bin('F80601'); // TODO: Add a util to encode | |
| // varint for better readability | |
| $m->mergeFromString($from); | |
| $to = $m->serializeToString(); | |
| $this->assertSame(bin2hex($from), bin2hex($to)); | |
| // Test preserve unknown for 64-bit. | |
| $m = new TestMessage(); | |
| $from = hex2bin('F9060000000000000000'); | |
| $m->mergeFromString($from); | |
| $to = $m->serializeToString(); | |
| $this->assertSame(bin2hex($from), bin2hex($to)); | |
| // Test preserve unknown for length delimited. | |
| $m = new TestMessage(); | |
| $from = hex2bin('FA0600'); | |
| $m->mergeFromString($from); | |
| $to = $m->serializeToString(); | |
| $this->assertSame(bin2hex($from), bin2hex($to)); | |
| // Test preserve unknown for 32-bit. | |
| $m = new TestMessage(); | |
| $from = hex2bin('FD0600000000'); | |
| $m->mergeFromString($from); | |
| $to = $m->serializeToString(); | |
| $this->assertSame(bin2hex($from), bin2hex($to)); | |
| // Test discard unknown in message. | |
| $m = new TestMessage(); | |
| $from = hex2bin('F80601'); | |
| $m->mergeFromString($from); | |
| $m->discardUnknownFields(); | |
| $to = $m->serializeToString(); | |
| $this->assertSame("", bin2hex($to)); | |
| // Test discard unknown for singular message field. | |
| $m = new TestMessage(); | |
| $from = hex2bin('8A0103F80601'); | |
| $m->mergeFromString($from); | |
| $m->discardUnknownFields(); | |
| $to = $m->serializeToString(); | |
| $this->assertSame("8a0100", bin2hex($to)); | |
| // Test discard unknown for repeated message field. | |
| $m = new TestMessage(); | |
| $from = hex2bin('FA0203F80601'); | |
| $m->mergeFromString($from); | |
| $m->discardUnknownFields(); | |
| $to = $m->serializeToString(); | |
| $this->assertSame("fa0200", bin2hex($to)); | |
| // Test discard unknown for map message value field. | |
| $m = new TestMessage(); | |
| $from = hex2bin("BA050708011203F80601"); | |
| $m->mergeFromString($from); | |
| $m->discardUnknownFields(); | |
| $to = $m->serializeToString(); | |
| $this->assertSame("ba050408011200", bin2hex($to)); | |
| // Test discard unknown for singular message field. | |
| $m = new TestMessage(); | |
| $from = hex2bin('9A0403F80601'); | |
| $m->mergeFromString($from); | |
| $m->discardUnknownFields(); | |
| $to = $m->serializeToString(); | |
| $this->assertSame("9a0400", bin2hex($to)); | |
| } | |
| public function testJsonUnknown() | |
| { | |
| // Test unknown number | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":1, | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown bool | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":true, | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown string | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":\"abc\", | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown null | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":null, | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown array | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":[], | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown number array | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":[1], | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown bool array | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":[true], | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown string array | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":[\"a\"], | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown null array | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":[null], | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown array array | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":[[]], | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown object array | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":[{}], | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown double value array | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":[1, 2], | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown object | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":{}, | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown number object | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":{\"a\":1}, | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown bool object | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":{\"a\":true}, | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown string object | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":{\"a\":\"a\"}, | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown null object | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":{\"a\":null}, | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown array object | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":{\"a\":[]}, | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown object object | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":{\"a\":{}}, | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown double value object | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"unknown\":{\"a\":1, \"b\":1}, | |
| \"optionalInt32\":1}", true); | |
| $this->assertSame(1, $m->getOptionalInt32()); | |
| // Test unknown enum value | |
| $m = new TestMessage(); | |
| $m->mergeFromJsonString("{\"optionalEnum\":\"UNKNOWN\"}", true); | |
| $this->assertSame(0, $m->getOptionalEnum()); | |
| } | |
| public function testJsonEncode() | |
| { | |
| $from = new TestMessage(); | |
| $this->setFields($from); | |
| $data = $from->serializeToJsonString(); | |
| $to = new TestMessage(); | |
| $to->mergeFromJsonString($data); | |
| $this->expectFields($to); | |
| } | |
| public function testJsonEncodeNullSubMessage() | |
| { | |
| $from = new TestMessage(); | |
| $from->setOptionalMessage(null); | |
| $data = $from->serializeToJsonString(); | |
| $this->assertEquals("{}", $data); | |
| } | |
| public function testDecodeDuration() | |
| { | |
| $m = new Google\Protobuf\Duration(); | |
| $m->mergeFromJsonString("\"1234.5678s\""); | |
| $this->assertEquals(1234, $m->getSeconds()); | |
| $this->assertEquals(567800000, $m->getNanos()); | |
| } | |
| public function testEncodeDuration() | |
| { | |
| $m = new Google\Protobuf\Duration(); | |
| $m->setSeconds(1234); | |
| $m->setNanos(999999999); | |
| $this->assertEquals("\"1234.999999999s\"", $m->serializeToJsonString()); | |
| } | |
| public function testDecodeTimestamp() | |
| { | |
| $m = new Google\Protobuf\Timestamp(); | |
| $m->mergeFromJsonString("\"2000-01-01T00:00:00.123456789Z\""); | |
| $this->assertEquals(946684800, $m->getSeconds()); | |
| $this->assertEquals(123456789, $m->getNanos()); | |
| } | |
| public function testEncodeTimestamp() | |
| { | |
| $m = new Google\Protobuf\Timestamp(); | |
| $m->setSeconds(946684800); | |
| $m->setNanos(123456789); | |
| $this->assertEquals("\"2000-01-01T00:00:00.123456789Z\"", | |
| $m->serializeToJsonString()); | |
| } | |
| public function testEncodeDecodeTimestampConsistency() | |
| { | |
| $m = new Google\Protobuf\Timestamp(); | |
| $m->setSeconds(946684800); | |
| $m->setNanos(123000000); | |
| $m->mergeFromJsonString($m->serializeToJsonString()); | |
| $this->assertEquals(946684800, $m->getSeconds()); | |
| $this->assertEquals(123000000, $m->getNanos()); | |
| } | |
| public function testDecodeTopLevelValue() | |
| { | |
| $m = new Value(); | |
| $m->mergeFromJsonString("\"a\""); | |
| $this->assertSame("a", $m->getStringValue()); | |
| $m = new Value(); | |
| $m->mergeFromJsonString("1.5"); | |
| $this->assertSame(1.5, $m->getNumberValue()); | |
| $m = new Value(); | |
| $m->mergeFromJsonString("true"); | |
| $this->assertSame(true, $m->getBoolValue()); | |
| $m = new Value(); | |
| $m->mergeFromJsonString("null"); | |
| $this->assertSame("null_value", $m->getKind()); | |
| $m = new Value(); | |
| $m->mergeFromJsonString("[1]"); | |
| $this->assertSame("list_value", $m->getKind()); | |
| $m = new Value(); | |
| $m->mergeFromJsonString("{\"a\":1}"); | |
| $this->assertSame("struct_value", $m->getKind()); | |
| } | |
| public function testEncodeTopLevelValue() | |
| { | |
| $m = new Value(); | |
| $m->setStringValue("a"); | |
| $this->assertSame("\"a\"", $m->serializeToJsonString()); | |
| $m = new Value(); | |
| $m->setNumberValue(1.5); | |
| $this->assertSame("1.5", $m->serializeToJsonString()); | |
| $m = new Value(); | |
| $m->setBoolValue(true); | |
| $this->assertSame("true", $m->serializeToJsonString()); | |
| $m = new Value(); | |
| $m->setNullValue(0); | |
| $this->assertSame("null", $m->serializeToJsonString()); | |
| } | |
| public function testDecodeTopLevelListValue() | |
| { | |
| $m = new ListValue(); | |
| $m->mergeFromJsonString("[1]"); | |
| $this->assertSame(1.0, $m->getValues()[0]->getNumberValue()); | |
| } | |
| public function testEncodeTopLevelListValue() | |
| { | |
| $m = new ListValue(); | |
| $arr = $m->getValues(); | |
| $sub = new Value(); | |
| $sub->setNumberValue(1.5); | |
| $arr[] = $sub; | |
| $this->assertSame("[1.5]", $m->serializeToJsonString()); | |
| } | |
| public function testEncodeEmptyListValue() | |
| { | |
| $m = new Struct(); | |
| $m->setFields(['test' => (new Value())->setListValue(new ListValue())]); | |
| $this->assertSame('{"test":[]}', $m->serializeToJsonString()); | |
| } | |
| public function testDecodeTopLevelStruct() | |
| { | |
| $m = new Struct(); | |
| $m->mergeFromJsonString("{\"a\":{\"b\":1}}"); | |
| $this->assertSame(1.0, $m->getFields()["a"] | |
| ->getStructValue() | |
| ->getFields()["b"]->getNumberValue()); | |
| } | |
| public function testEncodeTopLevelStruct() | |
| { | |
| $m = new Struct(); | |
| $map = $m->getFields(); | |
| $sub = new Value(); | |
| $sub->setNumberValue(1.5); | |
| $map["a"] = $sub; | |
| $this->assertSame("{\"a\":1.5}", $m->serializeToJsonString()); | |
| } | |
| public function testEncodeEmptyStruct() | |
| { | |
| $m = new Struct(); | |
| $m->setFields(['test' => (new Value())->setStructValue(new Struct())]); | |
| $this->assertSame('{"test":{}}', $m->serializeToJsonString()); | |
| } | |
| public function testDecodeTopLevelAny() | |
| { | |
| // Make sure packed message has been created at least once. | |
| $packed = new TestMessage(); | |
| $m1 = new Any(); | |
| $m1->mergeFromJsonString( | |
| "{\"optionalInt32\": 1, " . | |
| "\"@type\":\"type.googleapis.com/foo.TestMessage\"}"); | |
| $this->assertSame("type.googleapis.com/foo.TestMessage", | |
| $m1->getTypeUrl()); | |
| $this->assertSame("0801", bin2hex($m1->getValue())); | |
| $m2 = new Any(); | |
| $m2->mergeFromJsonString( | |
| "{\"@type\":\"type.googleapis.com/foo.TestMessage\", " . | |
| "\"optionalInt32\": 1}"); | |
| $this->assertSame("type.googleapis.com/foo.TestMessage", | |
| $m2->getTypeUrl()); | |
| $this->assertSame("0801", bin2hex($m2->getValue())); | |
| $m3 = new Any(); | |
| $m3->mergeFromJsonString( | |
| "{\"optionalInt32\": 1, " . | |
| "\"@type\":\"type.googleapis.com/foo.TestMessage\", " . | |
| "\"optionalInt64\": 2}"); | |
| $this->assertSame("type.googleapis.com/foo.TestMessage", | |
| $m3->getTypeUrl()); | |
| $this->assertSame("08011002", bin2hex($m3->getValue())); | |
| } | |
| public function testDecodeAny() | |
| { | |
| // Make sure packed message has been created at least once. | |
| $packed = new TestMessage(); | |
| $m1 = new TestAny(); | |
| $m1->mergeFromJsonString( | |
| "{\"any\": {\"optionalInt32\": 1, " . | |
| "\"@type\":\"type.googleapis.com/foo.TestMessage\"}}"); | |
| $this->assertSame("type.googleapis.com/foo.TestMessage", | |
| $m1->getAny()->getTypeUrl()); | |
| $this->assertSame("0801", bin2hex($m1->getAny()->getValue())); | |
| $m2 = new TestAny(); | |
| $m2->mergeFromJsonString( | |
| "{\"any\":{\"@type\":\"type.googleapis.com/foo.TestMessage\", " . | |
| "\"optionalInt32\": 1}}"); | |
| $this->assertSame("type.googleapis.com/foo.TestMessage", | |
| $m2->getAny()->getTypeUrl()); | |
| $this->assertSame("0801", bin2hex($m2->getAny()->getValue())); | |
| $m3 = new TestAny(); | |
| $m3->mergeFromJsonString( | |
| "{\"any\":{\"optionalInt32\": 1, " . | |
| "\"@type\":\"type.googleapis.com/foo.TestMessage\", " . | |
| "\"optionalInt64\": 2}}"); | |
| $this->assertSame("type.googleapis.com/foo.TestMessage", | |
| $m3->getAny()->getTypeUrl()); | |
| $this->assertSame("08011002", bin2hex($m3->getAny()->getValue())); | |
| } | |
| public function testDecodeAnyWithWellKnownPacked() | |
| { | |
| // Make sure packed message has been created at least once. | |
| $packed = new Int32Value(); | |
| $m1 = new TestAny(); | |
| $m1->mergeFromJsonString( | |
| "{\"any\":" . | |
| " {\"@type\":\"type.googleapis.com/google.protobuf.Int32Value\"," . | |
| " \"value\":1}}"); | |
| $this->assertSame("type.googleapis.com/google.protobuf.Int32Value", | |
| $m1->getAny()->getTypeUrl()); | |
| $this->assertSame("0801", bin2hex($m1->getAny()->getValue())); | |
| } | |
| public function testDecodeAnyWithUnknownPacked() | |
| { | |
| $this->expectException(Exception::class); | |
| $m = new TestAny(); | |
| $m->mergeFromJsonString( | |
| "{\"any\":" . | |
| " {\"@type\":\"type.googleapis.com/unknown\"," . | |
| " \"value\":1}}"); | |
| } | |
| public function testEncodeTopLevelAny() | |
| { | |
| // Test a normal message. | |
| $packed = new TestMessage(); | |
| $packed->setOptionalInt32(123); | |
| $packed->setOptionalString("abc"); | |
| $m = new Any(); | |
| $m->pack($packed); | |
| $expected1 = | |
| "{\"@type\":\"type.googleapis.com/foo.TestMessage\"," . | |
| "\"optional_int32\":123,\"optional_string\":\"abc\"}"; | |
| $expected2 = | |
| "{\"@type\":\"type.googleapis.com/foo.TestMessage\"," . | |
| "\"optionalInt32\":123,\"optionalString\":\"abc\"}"; | |
| $result = $m->serializeToJsonString(); | |
| $this->assertTrue($expected1 === $result || $expected2 === $result); | |
| // Test a well known message. | |
| $packed = new Int32Value(); | |
| $packed->setValue(123); | |
| $m = new Any(); | |
| $m->pack($packed); | |
| $this->assertSame( | |
| "{\"@type\":\"type.googleapis.com/google.protobuf.Int32Value\"," . | |
| "\"value\":123}", | |
| $m->serializeToJsonString()); | |
| // Test an Any message. | |
| $outer = new Any(); | |
| $outer->pack($m); | |
| $this->assertSame( | |
| "{\"@type\":\"type.googleapis.com/google.protobuf.Any\"," . | |
| "\"value\":{\"@type\":\"type.googleapis.com/google.protobuf.Int32Value\"," . | |
| "\"value\":123}}", | |
| $outer->serializeToJsonString()); | |
| // Test a Timestamp message. | |
| $packed = new Google\Protobuf\Timestamp(); | |
| $packed->setSeconds(946684800); | |
| $packed->setNanos(123456789); | |
| $m = new Any(); | |
| $m->pack($packed); | |
| $this->assertSame( | |
| "{\"@type\":\"type.googleapis.com/google.protobuf.Timestamp\"," . | |
| "\"value\":\"2000-01-01T00:00:00.123456789Z\"}", | |
| $m->serializeToJsonString()); | |
| } | |
| public function testEncodeAnyWithDefaultWrapperMessagePacked() | |
| { | |
| $any = new Any(); | |
| $any->pack(new TestInt32Value([ | |
| 'field' => new Int32Value(['value' => 0]), | |
| ])); | |
| $this->assertSame( | |
| "{\"@type\":\"type.googleapis.com/foo.TestInt32Value\"," . | |
| "\"field\":0}", | |
| $any->serializeToJsonString()); | |
| } | |
| public function testDecodeTopLevelFieldMask() | |
| { | |
| $m = new TestMessage(); | |
| $m->setMapStringString(['a'=>'abcdefg']); | |
| $data1 = $m->serializeToJsonString(); | |
| $n = new TestMessage(); | |
| $n->mergeFromJsonString($data1); | |
| $data2 = $n->serializeToJsonString(); | |
| $this->assertSame($data1, $data2); | |
| $m = new FieldMask(); | |
| $m->mergeFromJsonString("\"foo.barBaz,qux\""); | |
| $this->assertSame("foo.bar_baz", $m->getPaths()[0]); | |
| $this->assertSame("qux", $m->getPaths()[1]); | |
| } | |
| public function testEncodeTopLevelFieldMask() | |
| { | |
| $m = new FieldMask(); | |
| $m->setPaths(["foo.bar_baz", "qux"]); | |
| $this->assertSame("\"foo.barBaz,qux\"", $m->serializeToJsonString()); | |
| } | |
| public function testDecodeEmptyFieldMask() | |
| { | |
| $m = new FieldMask(); | |
| $m->mergeFromJsonString("\"\""); | |
| $this->assertEquals("", $m->serializeToString()); | |
| } | |
| public function testJsonDecodeMapWithDefaultValueKey() | |
| { | |
| $m = new TestMessage(); | |
| $m->getMapInt32Int32()[0] = 0; | |
| $this->assertSame("{\"mapInt32Int32\":{\"0\":0}}", | |
| $m->serializeToJsonString()); | |
| $m = new TestMessage(); | |
| $m->getMapStringString()[""] = ""; | |
| $this->assertSame("{\"mapStringString\":{\"\":\"\"}}", | |
| $m->serializeToJsonString()); | |
| } | |
| public function testJsonDecodeNumericStringMapKey() | |
| { | |
| $m = new TestMessage(); | |
| $m->getMapStringString()["1"] = "1"; | |
| $data = $m->serializeToJsonString(); | |
| $this->assertSame("{\"mapStringString\":{\"1\":\"1\"}}", $data); | |
| $n = new TestMessage(); | |
| $n->mergeFromJsonString($data); | |
| } | |
| public function testMessageMapNoValue() | |
| { | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin("CA0700")); | |
| $m->serializeToString(); | |
| $this->assertTrue(true); | |
| } | |
| public function testAnyMapNoValue() | |
| { | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin("D20700")); | |
| $m->serializeToString(); | |
| $this->assertTrue(true); | |
| } | |
| public function testListValueMapNoValue() | |
| { | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin("DA0700")); | |
| $m->serializeToString(); | |
| $this->assertTrue(true); | |
| } | |
| public function testStructMapNoValue() | |
| { | |
| $m = new TestMessage(); | |
| $m->mergeFromString(hex2bin("E20700")); | |
| $m->serializeToString(); | |
| $this->assertTrue(true); | |
| } | |
| /** | |
| * @dataProvider wrappersDataProvider | |
| */ | |
| public function testWrapperJsonDecodeAndGet( | |
| $class, | |
| $nonDefaultValue, | |
| $nonDefaultValueData, | |
| $defaultValue, | |
| $defaultValueData | |
| ) | |
| { | |
| // Singular with non-default | |
| $m = new $class(); | |
| $m->mergeFromJsonString("{\"field\":" . $nonDefaultValueData . "}"); | |
| $wrapper = $m->getField(); | |
| $this->assertEquals($nonDefaultValue, $wrapper->getValue()); | |
| // Singular with default | |
| $m = new $class(); | |
| $m->mergeFromJsonString("{\"field\":" . $defaultValueData . "}"); | |
| $wrapper = $m->getField(); | |
| $this->assertEquals($defaultValue, $wrapper->getValue()); | |
| // Repeated with empty | |
| $m = new $class(); | |
| $m->mergeFromJsonString("{\"repeated_field\":[]}"); | |
| $repeatedWrapper = $m->getRepeatedField(); | |
| $this->assertSame(0, count($repeatedWrapper)); | |
| // Repeated with non-default | |
| $m = new $class(); | |
| $m->mergeFromJsonString("{\"repeated_field\":[" . $defaultValueData . "]}"); | |
| $repeatedWrapper = $m->getRepeatedField(); | |
| $this->assertSame(1, count($repeatedWrapper)); | |
| $this->assertEquals($defaultValue, $repeatedWrapper[0]->getValue()); | |
| // Repeated with default | |
| $m = new $class(); | |
| $m->mergeFromJsonString("{\"repeated_field\":[" . $defaultValueData . "]}"); | |
| $repeatedWrapper = $m->getRepeatedField(); | |
| $this->assertSame(1, count($repeatedWrapper)); | |
| $this->assertEquals($defaultValue, $repeatedWrapper[0]->getValue()); | |
| // Oneof with non-default | |
| $m = new $class(); | |
| $m->mergeFromJsonString("{\"oneof_field\":" . $nonDefaultValueData . "}"); | |
| $wrapper = $m->getOneofField(); | |
| $this->assertEquals($nonDefaultValue, $wrapper->getValue()); | |
| $this->assertEquals("oneof_field", $m->getOneofFields()); | |
| $this->assertEquals(0, $m->getInt32Field()); | |
| // Oneof with default | |
| $m = new $class(); | |
| $m->mergeFromJsonString("{\"oneof_field\":" . $defaultValueData . "}"); | |
| $wrapper = $m->getOneofField(); | |
| $this->assertEquals($defaultValue, $wrapper->getValue()); | |
| $this->assertEquals("oneof_field", $m->getOneofFields()); | |
| $this->assertEquals(0, $m->getInt32Field()); | |
| } | |
| /** | |
| * @dataProvider wrappersDataProvider | |
| */ | |
| public function testWrapperJsonDecodeAndGetUnwrapped( | |
| $class, | |
| $nonDefaultValue, | |
| $nonDefaultValueData, | |
| $defaultValue, | |
| $defaultValueData | |
| ) | |
| { | |
| // Singular with non-default | |
| $m = new $class(); | |
| $m->mergeFromJsonString("{\"field\":" . $nonDefaultValueData . "}"); | |
| $this->assertEquals($nonDefaultValue, $m->getFieldUnwrapped()); | |
| // Singular with default | |
| $m = new $class(); | |
| $m->mergeFromJsonString("{\"field\":" . $defaultValueData . "}"); | |
| $this->assertEquals($defaultValue, $m->getFieldUnwrapped()); | |
| // Oneof with non-default | |
| $m = new $class(); | |
| $m->mergeFromJsonString("{\"oneof_field\":" . $nonDefaultValueData . "}"); | |
| $this->assertEquals($nonDefaultValue, $m->getOneofFieldUnwrapped()); | |
| $this->assertEquals("oneof_field", $m->getOneofFields()); | |
| $this->assertEquals(0, $m->getInt32Field()); | |
| // Oneof with default | |
| $m = new $class(); | |
| $m->mergeFromJsonString("{\"oneof_field\":" . $defaultValueData . "}"); | |
| $this->assertEquals($defaultValue, $m->getOneofFieldUnwrapped()); | |
| $this->assertEquals("oneof_field", $m->getOneofFields()); | |
| $this->assertEquals(0, $m->getInt32Field()); | |
| } | |
| /** | |
| * @dataProvider wrappersDataProvider | |
| */ | |
| public function testWrapperJsonDecodeEncode( | |
| $class, | |
| $nonDefaultValue, | |
| $nonDefaultValueData, | |
| $defaultValue, | |
| $defaultValueData | |
| ) | |
| { | |
| // Singular with non-default | |
| $from = new $class(); | |
| $to = new $class(); | |
| $from->mergeFromJsonString("{\"field\":" . $nonDefaultValueData . "}"); | |
| $data = $from->serializeToJsonString(); | |
| $to->mergeFromJsonString($data); | |
| $this->assertEquals($nonDefaultValue, $to->getFieldUnwrapped()); | |
| // Singular with default | |
| $from = new $class(); | |
| $to = new $class(); | |
| $from->mergeFromJsonString("{\"field\":" . $defaultValueData . "}"); | |
| $data = $from->serializeToJsonString(); | |
| $to->mergeFromJsonString($data); | |
| $this->assertEquals($defaultValue, $to->getFieldUnwrapped()); | |
| // Oneof with non-default | |
| $from = new $class(); | |
| $to = new $class(); | |
| $from->mergeFromJsonString("{\"oneof_field\":" . $nonDefaultValueData . "}"); | |
| $data = $from->serializeToJsonString(); | |
| $to->mergeFromJsonString($data); | |
| $this->assertEquals($nonDefaultValue, $to->getOneofFieldUnwrapped()); | |
| // Oneof with default | |
| $from = new $class(); | |
| $to = new $class(); | |
| $from->mergeFromJsonString("{\"oneof_field\":" . $defaultValueData . "}"); | |
| $data = $from->serializeToJsonString(); | |
| $to->mergeFromJsonString($data); | |
| $this->assertEquals($defaultValue, $to->getOneofFieldUnwrapped()); | |
| } | |
| /** | |
| * @dataProvider wrappersDataProvider | |
| */ | |
| public function testWrapperSetUnwrappedJsonEncode( | |
| $class, | |
| $nonDefaultValue, | |
| $nonDefaultValueData, | |
| $defaultValue, | |
| $defaultValueData | |
| ) | |
| { | |
| // Singular with non-default | |
| $from = new $class(); | |
| $to = new $class(); | |
| $from->setFieldUnwrapped($nonDefaultValue); | |
| $data = $from->serializeToJsonString(); | |
| $to->mergeFromJsonString($data); | |
| $this->assertEquals($nonDefaultValue, $to->getFieldUnwrapped()); | |
| // Singular with default | |
| $from = new $class(); | |
| $to = new $class(); | |
| $from->setFieldUnwrapped($defaultValue); | |
| $data = $from->serializeToJsonString(); | |
| $to->mergeFromJsonString($data); | |
| $this->assertEquals($defaultValue, $to->getFieldUnwrapped()); | |
| // Oneof with non-default | |
| $from = new $class(); | |
| $to = new $class(); | |
| $from->setOneofFieldUnwrapped($nonDefaultValue); | |
| $data = $from->serializeToJsonString(); | |
| $to->mergeFromJsonString($data); | |
| $this->assertEquals($nonDefaultValue, $to->getOneofFieldUnwrapped()); | |
| // Oneof with default | |
| $from = new $class(); | |
| $to = new $class(); | |
| $from->setOneofFieldUnwrapped($defaultValue); | |
| $data = $from->serializeToJsonString(); | |
| $to->mergeFromJsonString($data); | |
| $this->assertEquals($defaultValue, $to->getOneofFieldUnwrapped()); | |
| } | |
| public function wrappersDataProvider() | |
| { | |
| return [ | |
| [TestInt32Value::class, 1, "1", 0, "0"], | |
| [TestStringValue::class, "a", "\"a\"", "", "\"\""], | |
| ]; | |
| } | |
| public function testEmptyAnySerialization() | |
| { | |
| $m = new EmptyAnySerialization(); | |
| $any = new Any(); | |
| $any->pack($m); | |
| $data = $any->serializeToJsonString(); | |
| $this->assertEquals('{"@type":"type.googleapis.com/foo.EmptyAnySerialization"}', $data); | |
| $any = new Any(); | |
| $any->mergeFromJsonString($data); | |
| $m = $any->unpack(); | |
| $this->assertInstanceOf(EmptyAnySerialization::class, $m); | |
| $this->assertEquals('', $m->getA()); | |
| } | |
| } |