• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1<?php
2
3require_once('test_base.php');
4require_once('test_util.php');
5
6use Google\Protobuf\RepeatedField;
7use Google\Protobuf\GPBType;
8use Foo\EmptyAnySerialization;
9use Foo\TestInt32Value;
10use Foo\TestInt64Value;
11use Foo\TestUInt32Value;
12use Foo\TestUInt64Value;
13use Foo\TestBoolValue;
14use Foo\TestStringValue;
15use Foo\TestBytesValue;
16use Foo\TestAny;
17use Foo\TestEnum;
18use Foo\TestLargeFieldNumber;
19use Foo\TestMessage;
20use Foo\TestMessage\Sub;
21use Foo\TestPackedMessage;
22use Foo\TestRandomFieldOrder;
23use Foo\TestUnpackedMessage;
24use Google\Protobuf\Any;
25use Google\Protobuf\DoubleValue;
26use Google\Protobuf\FieldMask;
27use Google\Protobuf\FloatValue;
28use Google\Protobuf\Int32Value;
29use Google\Protobuf\UInt32Value;
30use Google\Protobuf\Int64Value;
31use Google\Protobuf\UInt64Value;
32use Google\Protobuf\BoolValue;
33use Google\Protobuf\StringValue;
34use Google\Protobuf\BytesValue;
35use Google\Protobuf\Value;
36use Google\Protobuf\ListValue;
37use Google\Protobuf\Struct;
38use Google\Protobuf\GPBEmpty;
39
40class EncodeDecodeTest extends TestBase
41{
42    public function testDecodeJsonSimple()
43    {
44        $m = new TestMessage();
45        $m->mergeFromJsonString("{\"optionalInt32\":1}");
46        $this->assertEquals(1, $m->getOptionalInt32());
47    }
48
49    public function testDecodeJsonUnknown()
50    {
51        $this->expectException(Exception::class);
52
53        $m = new TestMessage();
54        $m->mergeFromJsonString("{\"unknown\":1}");
55    }
56
57    public function testDecodeJsonIgnoreUnknown()
58    {
59        $m = new TestMessage();
60        $m->mergeFromJsonString("{\"unknown\":1}", true);
61        $this->assertEquals("{}", $m->serializeToJsonString());
62    }
63
64    public function testDecodeTopLevelBoolValue()
65    {
66        $m = new BoolValue();
67
68        $m->mergeFromJsonString("true");
69        $this->assertEquals(true, $m->getValue());
70
71        $m->mergeFromJsonString("false");
72        $this->assertEquals(false, $m->getValue());
73    }
74
75    public function testEncodeTopLevelBoolValue()
76    {
77        $m = new BoolValue();
78        $m->setValue(true);
79        $this->assertSame("true", $m->serializeToJsonString());
80    }
81
82    public function testDecodeTopLevelDoubleValue()
83    {
84        $m = new DoubleValue();
85        $m->mergeFromJsonString("1.5");
86        $this->assertEquals(1.5, $m->getValue());
87    }
88
89    public function testEncodeTopLevelDoubleValue()
90    {
91        $m = new DoubleValue();
92        $m->setValue(1.5);
93        $this->assertSame("1.5", $m->serializeToJsonString());
94    }
95
96    public function testDecodeTopLevelFloatValue()
97    {
98        $m = new FloatValue();
99        $m->mergeFromJsonString("1.5");
100        $this->assertEquals(1.5, $m->getValue());
101    }
102
103    public function testEncodeTopLevelFloatValue()
104    {
105        $m = new FloatValue();
106        $m->setValue(1.5);
107        $this->assertSame("1.5", $m->serializeToJsonString());
108    }
109
110    public function testDecodeTopLevelInt32Value()
111    {
112        $m = new Int32Value();
113        $m->mergeFromJsonString("1");
114        $this->assertEquals(1, $m->getValue());
115    }
116
117    public function testEncodeTopLevelInt32Value()
118    {
119        $m = new Int32Value();
120        $m->setValue(1);
121        $this->assertSame("1", $m->serializeToJsonString());
122    }
123
124    public function testDecodeRepeatedInt32Value()
125    {
126        $m = new TestInt32Value();
127        $m->mergeFromJsonString("{\"repeated_field\":[12345]}");
128        $this->assertSame(12345, $m->getRepeatedField()[0]->getValue());
129    }
130
131    public function testDecodeTopLevelUInt32Value()
132    {
133        $m = new UInt32Value();
134        $m->mergeFromJsonString("1");
135        $this->assertEquals(1, $m->getValue());
136    }
137
138    public function testEncodeTopLevelUInt32Value()
139    {
140        $m = new UInt32Value();
141        $m->setValue(1);
142        $this->assertSame("1", $m->serializeToJsonString());
143    }
144
145    public function testDecodeTopLevelInt64Value()
146    {
147        $m = new Int64Value();
148        $m->mergeFromJsonString("1");
149        $this->assertEquals(1, $m->getValue());
150    }
151
152    public function testDecodeTopLevelInt64ValueAsString()
153    {
154        $m = new Int64Value();
155        $m->mergeFromJsonString("\"1\"");
156        $this->assertEquals(1, $m->getValue());
157    }
158
159    public function testEncodeTopLevelInt64Value()
160    {
161        $m = new Int64Value();
162        $m->setValue(1);
163        $this->assertSame("\"1\"", $m->serializeToJsonString());
164    }
165
166    public function testDecodeTopLevelUInt64Value()
167    {
168        $m = new UInt64Value();
169        $m->mergeFromJsonString("1");
170        $this->assertEquals(1, $m->getValue());
171    }
172
173    public function testDecodeTopLevelUInt64ValueAsString()
174    {
175        $m = new UInt64Value();
176        $m->mergeFromJsonString("\"1\"");
177        $this->assertEquals(1, $m->getValue());
178    }
179
180    public function testEncodeTopLevelUInt64Value()
181    {
182        $m = new UInt64Value();
183        $m->setValue(1);
184        $this->assertSame("\"1\"", $m->serializeToJsonString());
185    }
186
187    public function testDecodeTopLevelStringValue()
188    {
189        $m = new StringValue();
190        $m->mergeFromJsonString("\"a\"");
191        $this->assertSame("a", $m->getValue());
192    }
193
194    public function testEncodeTopLevelStringValue()
195    {
196        $m = new StringValue();
197        $m->setValue("a");
198        $this->assertSame("\"a\"", $m->serializeToJsonString());
199    }
200
201    public function testDecodeRepeatedStringValue()
202    {
203        $m = new TestStringValue();
204        $m->mergeFromJsonString("{\"repeated_field\":[\"a\"]}");
205        $this->assertSame("a", $m->getRepeatedField()[0]->getValue());
206    }
207
208    public function testDecodeMapStringValue()
209    {
210        $m = new TestStringValue();
211        $m->mergeFromJsonString("{\"map_field\":{\"1\": \"a\"}}");
212        $this->assertSame("a", $m->getMapField()[1]->getValue());
213    }
214
215    public function testDecodeTopLevelBytesValue()
216    {
217        $m = new BytesValue();
218        $m->mergeFromJsonString("\"YQ==\"");
219        $this->assertSame("a", $m->getValue());
220    }
221
222    public function testEncodeTopLevelBytesValue()
223    {
224        $m = new BytesValue();
225        $m->setValue("a");
226        $this->assertSame("\"YQ==\"", $m->serializeToJsonString());
227    }
228
229    public function generateRandomString($length = 10) {
230        $randomString = str_repeat("+", $length);
231        for ($i = 0; $i < $length; $i++) {
232            $randomString[$i] = chr(rand(0, 255));
233        }
234        return $randomString;
235    }
236
237    public function testEncodeTopLevelLongBytesValue()
238    {
239        $m = new BytesValue();
240        $data = $this->generateRandomString(12007);
241        $m->setValue($data);
242        $expected = "\"" . base64_encode($data) . "\"";
243        $this->assertSame(strlen($expected), strlen($m->serializeToJsonString()));
244    }
245
246    public function testEncode()
247    {
248        $from = new TestMessage();
249        $this->expectEmptyFields($from);
250        $this->setFields($from);
251        $this->expectFields($from);
252
253        $data = $from->serializeToString();
254        $this->assertSame(bin2hex(TestUtil::getGoldenTestMessage()),
255                          bin2hex($data));
256    }
257
258    public function testDecode()
259    {
260        $to = new TestMessage();
261        $to->mergeFromString(TestUtil::getGoldenTestMessage());
262        $this->expectFields($to);
263    }
264
265    public function testEncodeDecode()
266    {
267        $from = new TestMessage();
268        $this->expectEmptyFields($from);
269        $this->setFields($from);
270        $this->expectFields($from);
271
272        $data = $from->serializeToString();
273
274        $to = new TestMessage();
275        $to->mergeFromString($data);
276        $this->expectFields($to);
277    }
278
279    public function testEncodeDecodeEmpty()
280    {
281        $from = new TestMessage();
282        $this->expectEmptyFields($from);
283
284        $data = $from->serializeToString();
285
286        $to = new TestMessage();
287        $to->mergeFromString($data);
288        $this->expectEmptyFields($to);
289    }
290
291    public function testEncodeDecodeOneof()
292    {
293        $m = new TestMessage();
294
295        $m->setOneofInt32(1);
296        $data = $m->serializeToString();
297        $n = new TestMessage();
298        $n->mergeFromString($data);
299        $this->assertSame(1, $n->getOneofInt32());
300
301        $m->setOneofFloat(2.0);
302        $data = $m->serializeToString();
303        $n = new TestMessage();
304        $n->mergeFromString($data);
305        $this->assertSame(2.0, $n->getOneofFloat());
306
307        $m->setOneofString('abc');
308        $data = $m->serializeToString();
309        $n = new TestMessage();
310        $n->mergeFromString($data);
311        $this->assertSame('abc', $n->getOneofString());
312
313        $sub_m = new Sub();
314        $sub_m->setA(1);
315        $m->setOneofMessage($sub_m);
316        $data = $m->serializeToString();
317        $n = new TestMessage();
318        $n->mergeFromString($data);
319        $this->assertSame(1, $n->getOneofMessage()->getA());
320
321        // Encode default value
322        $m->setOneofEnum(TestEnum::ZERO);
323        $data = $m->serializeToString();
324        $n = new TestMessage();
325        $n->mergeFromString($data);
326        $this->assertSame("oneof_enum", $n->getMyOneof());
327        $this->assertSame(TestEnum::ZERO, $n->getOneofEnum());
328
329        $m->setOneofString("");
330        $data = $m->serializeToString();
331        $n = new TestMessage();
332        $n->mergeFromString($data);
333        $this->assertSame("oneof_string", $n->getMyOneof());
334        $this->assertSame("", $n->getOneofString());
335
336        $sub_m = new Sub();
337        $m->setOneofMessage($sub_m);
338        $data = $m->serializeToString();
339        $n = new TestMessage();
340        $n->mergeFromString($data);
341        $this->assertSame("oneof_message", $n->getMyOneof());
342        $this->assertFalse(is_null($n->getOneofMessage()));
343
344    }
345
346    public function testEncodeDecodeOptional()
347    {
348      $m = new TestMessage();
349      $this->assertFalse($m->hasTrueOptionalInt32());
350      $data = $m->serializeToString();
351      $this->assertSame("", $data);
352
353      $m->setTrueOptionalInt32(0);
354      $this->assertTrue($m->hasTrueOptionalInt32());
355      $data = $m->serializeToString();
356      $this->assertNotSame("", $data);
357
358      $m2 = new TestMessage();
359      $m2->mergeFromString($data);
360      $this->assertTrue($m2->hasTrueOptionalInt32());
361      $this->assertSame(0, $m2->getTrueOptionalInt32());
362    }
363
364    public function testJsonEncodeDecodeOptional()
365    {
366      $m = new TestMessage();
367      $this->assertFalse($m->hasTrueOptionalInt32());
368      $data = $m->serializeToJsonString();
369      $this->assertSame("{}", $data);
370
371      $m->setTrueOptionalInt32(0);
372      $this->assertTrue($m->hasTrueOptionalInt32());
373      $data = $m->serializeToJsonString();
374      $this->assertNotSame("{}", $data);
375
376      $m2 = new TestMessage();
377      $m2->mergeFromJsonString($data);
378      $this->assertTrue($m2->hasTrueOptionalInt32());
379      $this->assertSame(0, $m2->getTrueOptionalInt32());
380    }
381
382    public function testJsonEncodeDecodeOneof()
383    {
384        $m = new TestMessage();
385
386        $m->setOneofEnum(TestEnum::ONE);
387        $data = $m->serializeToJsonString();
388        $n = new TestMessage();
389        $n->mergeFromJsonString($data);
390        $this->assertSame("oneof_enum", $n->getMyOneof());
391        $this->assertSame(TestEnum::ONE, $n->getOneofEnum());
392
393        $m->setOneofString("a");
394        $data = $m->serializeToJsonString();
395        $n = new TestMessage();
396        $n->mergeFromJsonString($data);
397        $this->assertSame("oneof_string", $n->getMyOneof());
398        $this->assertSame("a", $n->getOneofString());
399
400        $m->setOneofBytes("bbbb");
401        $data = $m->serializeToJsonString();
402        $n = new TestMessage();
403        $n->mergeFromJsonString($data);
404        $this->assertSame("oneof_bytes", $n->getMyOneof());
405        $this->assertSame("bbbb", $n->getOneofBytes());
406
407        $sub_m = new Sub();
408        $m->setOneofMessage($sub_m);
409        $data = $m->serializeToJsonString();
410        $n = new TestMessage();
411        $n->mergeFromJsonString($data);
412        $this->assertSame("oneof_message", $n->getMyOneof());
413        $this->assertFalse(is_null($n->getOneofMessage()));
414    }
415
416    public function testPackedEncode()
417    {
418        $from = new TestPackedMessage();
419        TestUtil::setTestPackedMessage($from);
420        $this->assertSame(TestUtil::getGoldenTestPackedMessage(),
421                          $from->serializeToString());
422    }
423
424    public function testPackedDecodePacked()
425    {
426        $to = new TestPackedMessage();
427        $to->mergeFromString(TestUtil::getGoldenTestPackedMessage());
428        TestUtil::assertTestPackedMessage($to);
429        $this->assertTrue(true);
430    }
431
432    public function testPackedDecodeUnpacked()
433    {
434        $to = new TestPackedMessage();
435        $to->mergeFromString(TestUtil::getGoldenTestUnpackedMessage());
436        TestUtil::assertTestPackedMessage($to);
437        $this->assertTrue(true);
438    }
439
440    public function testUnpackedEncode()
441    {
442        $from = new TestUnpackedMessage();
443        TestUtil::setTestPackedMessage($from);
444        $this->assertSame(TestUtil::getGoldenTestUnpackedMessage(),
445                          $from->serializeToString());
446    }
447
448    public function testUnpackedDecodePacked()
449    {
450        $to = new TestUnpackedMessage();
451        $to->mergeFromString(TestUtil::getGoldenTestPackedMessage());
452        TestUtil::assertTestPackedMessage($to);
453        $this->assertTrue(true);
454    }
455
456    public function testUnpackedDecodeUnpacked()
457    {
458        $to = new TestUnpackedMessage();
459        $to->mergeFromString(TestUtil::getGoldenTestUnpackedMessage());
460        TestUtil::assertTestPackedMessage($to);
461        $this->assertTrue(true);
462    }
463
464    public function testDecodeInt64()
465    {
466        // Read 64 testing
467        $testVals = array(
468            '10'                 => '100a',
469            '100'                => '1064',
470            '800'                => '10a006',
471            '6400'               => '108032',
472            '70400'              => '1080a604',
473            '774400'             => '1080a22f',
474            '9292800'            => '108098b704',
475            '74342400'           => '1080c0b923',
476            '743424000'          => '108080bfe202',
477            '8177664000'         => '108080b5bb1e',
478            '65421312000'        => '108080a8dbf301',
479            '785055744000'       => '108080e0c7ec16',
480            '9420668928000'      => '10808080dd969202',
481            '103627358208000'    => '10808080fff9c717',
482            '1139900940288000'   => '10808080f5bd978302',
483            '13678811283456000'  => '10808080fce699a618',
484            '109430490267648000' => '10808080e0b7ceb1c201',
485            '984874412408832000' => '10808080e0f5c1bed50d',
486        );
487
488        $msg = new TestMessage();
489        foreach ($testVals as $original => $encoded) {
490            $msg->setOptionalInt64($original);
491            $data = $msg->serializeToString();
492            $this->assertSame($encoded, bin2hex($data));
493            $msg->setOptionalInt64(0);
494            $msg->mergeFromString($data);
495            $this->assertEquals($original, $msg->getOptionalInt64());
496        }
497    }
498
499    public function testDecodeToExistingMessage()
500    {
501        $m1 = new TestMessage();
502        $this->setFields($m1);
503        $this->expectFields($m1);
504
505        $m2 = new TestMessage();
506        $this->setFields2($m2);
507        $data = $m2->serializeToString();
508
509        $m1->mergeFromString($data);
510        $this->expectFieldsMerged($m1);
511    }
512
513    public function testDecodeFieldNonExist()
514    {
515        $data = hex2bin('c80501');
516        $m = new TestMessage();
517        $m->mergeFromString($data);
518        $this->assertTrue(true);
519    }
520
521    public function testEncodeNegativeInt32()
522    {
523        $m = new TestMessage();
524        $m->setOptionalInt32(-1);
525        $data = $m->serializeToString();
526        $this->assertSame("08ffffffffffffffffff01", bin2hex($data));
527    }
528
529    public function testDecodeNegativeInt32()
530    {
531        $m = new TestMessage();
532        $this->assertEquals(0, $m->getOptionalInt32());
533        $m->mergeFromString(hex2bin("08ffffffffffffffffff01"));
534        $this->assertEquals(-1, $m->getOptionalInt32());
535
536        $m = new TestMessage();
537        $this->assertEquals(0, $m->getOptionalInt32());
538        $m->mergeFromString(hex2bin("08ffffffff0f"));
539        $this->assertEquals(-1, $m->getOptionalInt32());
540    }
541
542    public function testRandomFieldOrder()
543    {
544        $m = new TestRandomFieldOrder();
545        $data = $m->serializeToString();
546        $this->assertSame("", $data);
547    }
548
549    public function testLargeFieldNumber()
550    {
551        $m = new TestLargeFieldNumber(['large_field_number' => 5]);
552        $data = $m->serializeToString();
553        $m2 = new TestLargeFieldNumber();
554        $m2->mergeFromString($data);
555        $this->assertSame(5, $m2->getLargeFieldNumber());
556    }
557
558    public function testDecodeInvalidInt32()
559    {
560        $this->expectException(Exception::class);
561
562        $m = new TestMessage();
563        $m->mergeFromString(hex2bin('08'));
564    }
565
566    public function testDecodeInvalidSubMessage()
567    {
568        $this->expectException(Exception::class);
569
570        $m = new TestMessage();
571        $m->mergeFromString(hex2bin('9A010108'));
572    }
573
574    public function testDecodeInvalidInt64()
575    {
576        $this->expectException(Exception::class);
577
578        $m = new TestMessage();
579        $m->mergeFromString(hex2bin('10'));
580    }
581
582    public function testDecodeInvalidUInt32()
583    {
584        $this->expectException(Exception::class);
585
586        $m = new TestMessage();
587        $m->mergeFromString(hex2bin('18'));
588    }
589
590    public function testDecodeInvalidUInt64()
591    {
592        $this->expectException(Exception::class);
593
594        $m = new TestMessage();
595        $m->mergeFromString(hex2bin('20'));
596    }
597
598    public function testDecodeInvalidSInt32()
599    {
600        $this->expectException(Exception::class);
601
602        $m = new TestMessage();
603        $m->mergeFromString(hex2bin('28'));
604    }
605
606    public function testDecodeInvalidSInt64()
607    {
608        $this->expectException(Exception::class);
609
610        $m = new TestMessage();
611        $m->mergeFromString(hex2bin('30'));
612    }
613
614    public function testDecodeInvalidFixed32()
615    {
616        $this->expectException(Exception::class);
617
618        $m = new TestMessage();
619        $m->mergeFromString(hex2bin('3D'));
620    }
621
622    public function testDecodeInvalidFixed64()
623    {
624        $this->expectException(Exception::class);
625
626        $m = new TestMessage();
627        $m->mergeFromString(hex2bin('41'));
628    }
629
630    public function testDecodeInvalidSFixed32()
631    {
632        $this->expectException(Exception::class);
633
634        $m = new TestMessage();
635        $m->mergeFromString(hex2bin('4D'));
636    }
637
638    public function testDecodeInvalidSFixed64()
639    {
640        $this->expectException(Exception::class);
641
642        $m = new TestMessage();
643        $m->mergeFromString(hex2bin('51'));
644    }
645
646    public function testDecodeInvalidFloat()
647    {
648        $this->expectException(Exception::class);
649
650        $m = new TestMessage();
651        $m->mergeFromString(hex2bin('5D'));
652    }
653
654    public function testDecodeInvalidDouble()
655    {
656        $this->expectException(Exception::class);
657
658        $m = new TestMessage();
659        $m->mergeFromString(hex2bin('61'));
660    }
661
662    public function testDecodeInvalidBool()
663    {
664        $this->expectException(Exception::class);
665
666        $m = new TestMessage();
667        $m->mergeFromString(hex2bin('68'));
668    }
669
670    public function testDecodeInvalidStringLengthMiss()
671    {
672        $this->expectException(Exception::class);
673
674        $m = new TestMessage();
675        $m->mergeFromString(hex2bin('72'));
676    }
677
678    public function testDecodeInvalidStringDataMiss()
679    {
680        $this->expectException(Exception::class);
681
682        $m = new TestMessage();
683        $m->mergeFromString(hex2bin('7201'));
684    }
685
686    public function testDecodeInvalidStringDataBadUtf8()
687    {
688        $this->expectException(Exception::class);
689
690        $m = new TestMessage();
691        $m->mergeFromString(hex2bin('720180'));
692    }
693
694    public function testDecodeValidStringData()
695    {
696        $m = new TestMessage();
697        $m->mergeFromString(hex2bin('720161'));
698        $this->assertSame('a', $m->getOptionalString());
699    }
700
701    public function testDecodeInvalidBytesLengthMiss()
702    {
703        $this->expectException(Exception::class);
704
705        $m = new TestMessage();
706        $m->mergeFromString(hex2bin('7A'));
707    }
708
709    public function testDecodeInvalidBytesDataMiss()
710    {
711        $this->expectException(Exception::class);
712
713        $m = new TestMessage();
714        $m->mergeFromString(hex2bin('7A01'));
715    }
716
717    public function testEncodeDecodeValidUtf8()
718    {
719        $m = new TestMessage();
720        $m->mergeFromJsonString("{\"optionalString\":\"\\u1000\"}");
721        $serialized = $m->serializeToString();
722        $m2 = new TestMessage();
723        $m2->mergeFromString($serialized);
724        $this->assertSame($m->getOptionalString(), $m2->getOptionalString());
725    }
726
727    public function testDecodeInvalidEnum()
728    {
729        $this->expectException(Exception::class);
730
731        $m = new TestMessage();
732        $m->mergeFromString(hex2bin('8001'));
733    }
734
735    public function testDecodeInvalidMessageLengthMiss()
736    {
737        $this->expectException(Exception::class);
738
739        $m = new TestMessage();
740        $m->mergeFromString(hex2bin('8A01'));
741    }
742
743    public function testDecodeInvalidMessageDataMiss()
744    {
745        $this->expectException(Exception::class);
746
747        $m = new TestMessage();
748        $m->mergeFromString(hex2bin('8A0101'));
749    }
750
751    public function testDecodeInvalidPackedMessageLength()
752    {
753        $this->expectException(Exception::class);
754
755        $m = new TestPackedMessage();
756        $m->mergeFromString(hex2bin('D205'));
757    }
758
759    public function testUnknown()
760    {
761        // Test preserve unknown for varint.
762        $m = new TestMessage();
763        $from = hex2bin('F80601');  // TODO: Add a util to encode
764                                    // varint for better readability
765        $m->mergeFromString($from);
766        $to = $m->serializeToString();
767        $this->assertSame(bin2hex($from), bin2hex($to));
768
769        // Test preserve unknown for 64-bit.
770        $m = new TestMessage();
771        $from = hex2bin('F9060000000000000000');
772        $m->mergeFromString($from);
773        $to = $m->serializeToString();
774        $this->assertSame(bin2hex($from), bin2hex($to));
775
776        // Test preserve unknown for length delimited.
777        $m = new TestMessage();
778        $from = hex2bin('FA0600');
779        $m->mergeFromString($from);
780        $to = $m->serializeToString();
781        $this->assertSame(bin2hex($from), bin2hex($to));
782
783        // Test preserve unknown for 32-bit.
784        $m = new TestMessage();
785        $from = hex2bin('FD0600000000');
786        $m->mergeFromString($from);
787        $to = $m->serializeToString();
788        $this->assertSame(bin2hex($from), bin2hex($to));
789
790        // Test discard unknown in message.
791        $m = new TestMessage();
792        $from = hex2bin('F80601');
793        $m->mergeFromString($from);
794        $m->discardUnknownFields();
795        $to = $m->serializeToString();
796        $this->assertSame("", bin2hex($to));
797
798        // Test discard unknown for singular message field.
799        $m = new TestMessage();
800        $from = hex2bin('8A0103F80601');
801        $m->mergeFromString($from);
802        $m->discardUnknownFields();
803        $to = $m->serializeToString();
804        $this->assertSame("8a0100", bin2hex($to));
805
806        // Test discard unknown for repeated message field.
807        $m = new TestMessage();
808        $from = hex2bin('FA0203F80601');
809        $m->mergeFromString($from);
810        $m->discardUnknownFields();
811        $to = $m->serializeToString();
812        $this->assertSame("fa0200", bin2hex($to));
813
814        // Test discard unknown for map message value field.
815        $m = new TestMessage();
816        $from = hex2bin("BA050708011203F80601");
817        $m->mergeFromString($from);
818        $m->discardUnknownFields();
819        $to = $m->serializeToString();
820        $this->assertSame("ba050408011200", bin2hex($to));
821
822        // Test discard unknown for singular message field.
823        $m = new TestMessage();
824        $from = hex2bin('9A0403F80601');
825        $m->mergeFromString($from);
826        $m->discardUnknownFields();
827        $to = $m->serializeToString();
828        $this->assertSame("9a0400", bin2hex($to));
829    }
830
831    public function testJsonUnknown()
832    {
833        // Test unknown number
834        $m = new TestMessage();
835        $m->mergeFromJsonString("{\"unknown\":1,
836                                \"optionalInt32\":1}", true);
837        $this->assertSame(1, $m->getOptionalInt32());
838
839        // Test unknown bool
840        $m = new TestMessage();
841        $m->mergeFromJsonString("{\"unknown\":true,
842                                \"optionalInt32\":1}", true);
843        $this->assertSame(1, $m->getOptionalInt32());
844
845        // Test unknown string
846        $m = new TestMessage();
847        $m->mergeFromJsonString("{\"unknown\":\"abc\",
848                                \"optionalInt32\":1}", true);
849        $this->assertSame(1, $m->getOptionalInt32());
850
851        // Test unknown null
852        $m = new TestMessage();
853        $m->mergeFromJsonString("{\"unknown\":null,
854                                \"optionalInt32\":1}", true);
855        $this->assertSame(1, $m->getOptionalInt32());
856
857        // Test unknown array
858        $m = new TestMessage();
859        $m->mergeFromJsonString("{\"unknown\":[],
860                                \"optionalInt32\":1}", true);
861        $this->assertSame(1, $m->getOptionalInt32());
862
863        // Test unknown number array
864        $m = new TestMessage();
865        $m->mergeFromJsonString("{\"unknown\":[1],
866                                \"optionalInt32\":1}", true);
867        $this->assertSame(1, $m->getOptionalInt32());
868
869        // Test unknown bool array
870        $m = new TestMessage();
871        $m->mergeFromJsonString("{\"unknown\":[true],
872                                \"optionalInt32\":1}", true);
873        $this->assertSame(1, $m->getOptionalInt32());
874
875        // Test unknown string array
876        $m = new TestMessage();
877        $m->mergeFromJsonString("{\"unknown\":[\"a\"],
878                                \"optionalInt32\":1}", true);
879        $this->assertSame(1, $m->getOptionalInt32());
880
881        // Test unknown null array
882        $m = new TestMessage();
883        $m->mergeFromJsonString("{\"unknown\":[null],
884                                \"optionalInt32\":1}", true);
885        $this->assertSame(1, $m->getOptionalInt32());
886
887        // Test unknown array array
888        $m = new TestMessage();
889        $m->mergeFromJsonString("{\"unknown\":[[]],
890                                \"optionalInt32\":1}", true);
891        $this->assertSame(1, $m->getOptionalInt32());
892
893        // Test unknown object array
894        $m = new TestMessage();
895        $m->mergeFromJsonString("{\"unknown\":[{}],
896                                \"optionalInt32\":1}", true);
897        $this->assertSame(1, $m->getOptionalInt32());
898
899        // Test unknown double value array
900        $m = new TestMessage();
901        $m->mergeFromJsonString("{\"unknown\":[1, 2],
902                                \"optionalInt32\":1}", true);
903        $this->assertSame(1, $m->getOptionalInt32());
904
905        // Test unknown object
906        $m = new TestMessage();
907        $m->mergeFromJsonString("{\"unknown\":{},
908                                \"optionalInt32\":1}", true);
909        $this->assertSame(1, $m->getOptionalInt32());
910
911        // Test unknown number object
912        $m = new TestMessage();
913        $m->mergeFromJsonString("{\"unknown\":{\"a\":1},
914                                \"optionalInt32\":1}", true);
915        $this->assertSame(1, $m->getOptionalInt32());
916
917        // Test unknown bool object
918        $m = new TestMessage();
919        $m->mergeFromJsonString("{\"unknown\":{\"a\":true},
920                                \"optionalInt32\":1}", true);
921        $this->assertSame(1, $m->getOptionalInt32());
922
923        // Test unknown string object
924        $m = new TestMessage();
925        $m->mergeFromJsonString("{\"unknown\":{\"a\":\"a\"},
926                                \"optionalInt32\":1}", true);
927        $this->assertSame(1, $m->getOptionalInt32());
928
929        // Test unknown null object
930        $m = new TestMessage();
931        $m->mergeFromJsonString("{\"unknown\":{\"a\":null},
932                                \"optionalInt32\":1}", true);
933        $this->assertSame(1, $m->getOptionalInt32());
934
935        // Test unknown array object
936        $m = new TestMessage();
937        $m->mergeFromJsonString("{\"unknown\":{\"a\":[]},
938                                \"optionalInt32\":1}", true);
939        $this->assertSame(1, $m->getOptionalInt32());
940
941        // Test unknown object object
942        $m = new TestMessage();
943        $m->mergeFromJsonString("{\"unknown\":{\"a\":{}},
944                                \"optionalInt32\":1}", true);
945        $this->assertSame(1, $m->getOptionalInt32());
946
947        // Test unknown double value object
948        $m = new TestMessage();
949        $m->mergeFromJsonString("{\"unknown\":{\"a\":1, \"b\":1},
950                                \"optionalInt32\":1}", true);
951        $this->assertSame(1, $m->getOptionalInt32());
952
953        // Test unknown enum value
954        $m = new TestMessage();
955        $m->mergeFromJsonString("{\"optionalEnum\":\"UNKNOWN\"}", true);
956        $this->assertSame(0, $m->getOptionalEnum());
957    }
958
959    public function testJsonEncode()
960    {
961        $from = new TestMessage();
962        $this->setFields($from);
963        $data = $from->serializeToJsonString();
964        $to = new TestMessage();
965        $to->mergeFromJsonString($data);
966        $this->expectFields($to);
967    }
968
969    public function testJsonEncodeNullSubMessage()
970    {
971        $from = new TestMessage();
972        $from->setOptionalMessage(null);
973        $data = $from->serializeToJsonString();
974        $this->assertEquals("{}", $data);
975    }
976
977    public function testDecodeDuration()
978    {
979        $m = new Google\Protobuf\Duration();
980        $m->mergeFromJsonString("\"1234.5678s\"");
981        $this->assertEquals(1234, $m->getSeconds());
982        $this->assertEquals(567800000, $m->getNanos());
983    }
984
985    public function testEncodeDuration()
986    {
987        $m = new Google\Protobuf\Duration();
988        $m->setSeconds(1234);
989        $m->setNanos(999999999);
990        $this->assertEquals("\"1234.999999999s\"", $m->serializeToJsonString());
991    }
992
993    public function testDecodeTimestamp()
994    {
995        $m = new Google\Protobuf\Timestamp();
996        $m->mergeFromJsonString("\"2000-01-01T00:00:00.123456789Z\"");
997        $this->assertEquals(946684800, $m->getSeconds());
998        $this->assertEquals(123456789, $m->getNanos());
999    }
1000
1001    public function testEncodeTimestamp()
1002    {
1003        $m = new Google\Protobuf\Timestamp();
1004        $m->setSeconds(946684800);
1005        $m->setNanos(123456789);
1006        $this->assertEquals("\"2000-01-01T00:00:00.123456789Z\"",
1007                            $m->serializeToJsonString());
1008    }
1009
1010    public function testEncodeDecodeTimestampConsistency()
1011    {
1012        $m = new Google\Protobuf\Timestamp();
1013        $m->setSeconds(946684800);
1014        $m->setNanos(123000000);
1015        $m->mergeFromJsonString($m->serializeToJsonString());
1016        $this->assertEquals(946684800, $m->getSeconds());
1017        $this->assertEquals(123000000, $m->getNanos());
1018    }
1019
1020    public function testDecodeTopLevelValue()
1021    {
1022        $m = new Value();
1023        $m->mergeFromJsonString("\"a\"");
1024        $this->assertSame("a", $m->getStringValue());
1025
1026        $m = new Value();
1027        $m->mergeFromJsonString("1.5");
1028        $this->assertSame(1.5, $m->getNumberValue());
1029
1030        $m = new Value();
1031        $m->mergeFromJsonString("true");
1032        $this->assertSame(true, $m->getBoolValue());
1033
1034        $m = new Value();
1035        $m->mergeFromJsonString("null");
1036        $this->assertSame("null_value", $m->getKind());
1037
1038        $m = new Value();
1039        $m->mergeFromJsonString("[1]");
1040        $this->assertSame("list_value", $m->getKind());
1041
1042        $m = new Value();
1043        $m->mergeFromJsonString("{\"a\":1}");
1044        $this->assertSame("struct_value", $m->getKind());
1045    }
1046
1047    public function testEncodeTopLevelValue()
1048    {
1049        $m = new Value();
1050        $m->setStringValue("a");
1051        $this->assertSame("\"a\"", $m->serializeToJsonString());
1052
1053        $m = new Value();
1054        $m->setNumberValue(1.5);
1055        $this->assertSame("1.5", $m->serializeToJsonString());
1056
1057        $m = new Value();
1058        $m->setBoolValue(true);
1059        $this->assertSame("true", $m->serializeToJsonString());
1060
1061        $m = new Value();
1062        $m->setNullValue(0);
1063        $this->assertSame("null", $m->serializeToJsonString());
1064    }
1065
1066    public function testDecodeTopLevelListValue()
1067    {
1068        $m = new ListValue();
1069        $m->mergeFromJsonString("[1]");
1070        $this->assertSame(1.0, $m->getValues()[0]->getNumberValue());
1071    }
1072
1073    public function testEncodeTopLevelListValue()
1074    {
1075        $m = new ListValue();
1076        $arr = $m->getValues();
1077        $sub = new Value();
1078        $sub->setNumberValue(1.5);
1079        $arr[] = $sub;
1080        $this->assertSame("[1.5]", $m->serializeToJsonString());
1081    }
1082
1083    public function testEncodeEmptyListValue()
1084    {
1085        $m = new Struct();
1086        $m->setFields(['test' => (new Value())->setListValue(new ListValue())]);
1087        $this->assertSame('{"test":[]}', $m->serializeToJsonString());
1088    }
1089
1090    public function testDecodeTopLevelStruct()
1091    {
1092        $m = new Struct();
1093        $m->mergeFromJsonString("{\"a\":{\"b\":1}}");
1094        $this->assertSame(1.0, $m->getFields()["a"]
1095                                 ->getStructValue()
1096                                 ->getFields()["b"]->getNumberValue());
1097    }
1098
1099    public function testEncodeTopLevelStruct()
1100    {
1101        $m = new Struct();
1102        $map = $m->getFields();
1103        $sub = new Value();
1104        $sub->setNumberValue(1.5);
1105        $map["a"] = $sub;
1106        $this->assertSame("{\"a\":1.5}", $m->serializeToJsonString());
1107    }
1108
1109    public function testEncodeEmptyStruct()
1110    {
1111        $m = new Struct();
1112        $m->setFields(['test' => (new Value())->setStructValue(new Struct())]);
1113        $this->assertSame('{"test":{}}', $m->serializeToJsonString());
1114    }
1115
1116    public function testDecodeTopLevelAny()
1117    {
1118        // Make sure packed message has been created at least once.
1119        $packed = new TestMessage();
1120
1121        $m1 = new Any();
1122        $m1->mergeFromJsonString(
1123            "{\"optionalInt32\": 1, " .
1124            "\"@type\":\"type.googleapis.com/foo.TestMessage\"}");
1125        $this->assertSame("type.googleapis.com/foo.TestMessage",
1126                          $m1->getTypeUrl());
1127        $this->assertSame("0801", bin2hex($m1->getValue()));
1128
1129        $m2 = new Any();
1130        $m2->mergeFromJsonString(
1131            "{\"@type\":\"type.googleapis.com/foo.TestMessage\", " .
1132            "\"optionalInt32\": 1}");
1133        $this->assertSame("type.googleapis.com/foo.TestMessage",
1134                          $m2->getTypeUrl());
1135        $this->assertSame("0801", bin2hex($m2->getValue()));
1136
1137        $m3 = new Any();
1138        $m3->mergeFromJsonString(
1139            "{\"optionalInt32\": 1, " .
1140            "\"@type\":\"type.googleapis.com/foo.TestMessage\", " .
1141            "\"optionalInt64\": 2}");
1142        $this->assertSame("type.googleapis.com/foo.TestMessage",
1143                          $m3->getTypeUrl());
1144        $this->assertSame("08011002", bin2hex($m3->getValue()));
1145    }
1146
1147    public function testDecodeAny()
1148    {
1149        // Make sure packed message has been created at least once.
1150        $packed = new TestMessage();
1151
1152        $m1 = new TestAny();
1153        $m1->mergeFromJsonString(
1154            "{\"any\": {\"optionalInt32\": 1, " .
1155            "\"@type\":\"type.googleapis.com/foo.TestMessage\"}}");
1156        $this->assertSame("type.googleapis.com/foo.TestMessage",
1157                          $m1->getAny()->getTypeUrl());
1158        $this->assertSame("0801", bin2hex($m1->getAny()->getValue()));
1159
1160        $m2 = new TestAny();
1161        $m2->mergeFromJsonString(
1162            "{\"any\":{\"@type\":\"type.googleapis.com/foo.TestMessage\", " .
1163            "\"optionalInt32\": 1}}");
1164        $this->assertSame("type.googleapis.com/foo.TestMessage",
1165                          $m2->getAny()->getTypeUrl());
1166        $this->assertSame("0801", bin2hex($m2->getAny()->getValue()));
1167
1168        $m3 = new TestAny();
1169        $m3->mergeFromJsonString(
1170            "{\"any\":{\"optionalInt32\": 1, " .
1171            "\"@type\":\"type.googleapis.com/foo.TestMessage\", " .
1172            "\"optionalInt64\": 2}}");
1173        $this->assertSame("type.googleapis.com/foo.TestMessage",
1174                          $m3->getAny()->getTypeUrl());
1175        $this->assertSame("08011002", bin2hex($m3->getAny()->getValue()));
1176    }
1177
1178    public function testDecodeAnyWithWellKnownPacked()
1179    {
1180        // Make sure packed message has been created at least once.
1181        $packed = new Int32Value();
1182
1183        $m1 = new TestAny();
1184        $m1->mergeFromJsonString(
1185            "{\"any\":" .
1186            "  {\"@type\":\"type.googleapis.com/google.protobuf.Int32Value\"," .
1187            "   \"value\":1}}");
1188        $this->assertSame("type.googleapis.com/google.protobuf.Int32Value",
1189                          $m1->getAny()->getTypeUrl());
1190        $this->assertSame("0801", bin2hex($m1->getAny()->getValue()));
1191    }
1192
1193    public function testDecodeAnyWithUnknownPacked()
1194    {
1195        $this->expectException(Exception::class);
1196
1197        $m = new TestAny();
1198        $m->mergeFromJsonString(
1199            "{\"any\":" .
1200            "  {\"@type\":\"type.googleapis.com/unknown\"," .
1201            "   \"value\":1}}");
1202    }
1203
1204    public function testEncodeTopLevelAny()
1205    {
1206        // Test a normal message.
1207        $packed = new TestMessage();
1208        $packed->setOptionalInt32(123);
1209        $packed->setOptionalString("abc");
1210
1211        $m = new Any();
1212        $m->pack($packed);
1213        $expected1 =
1214            "{\"@type\":\"type.googleapis.com/foo.TestMessage\"," .
1215            "\"optional_int32\":123,\"optional_string\":\"abc\"}";
1216        $expected2 =
1217            "{\"@type\":\"type.googleapis.com/foo.TestMessage\"," .
1218            "\"optionalInt32\":123,\"optionalString\":\"abc\"}";
1219        $result = $m->serializeToJsonString();
1220        $this->assertTrue($expected1 === $result || $expected2 === $result);
1221
1222        // Test a well known message.
1223        $packed = new Int32Value();
1224        $packed->setValue(123);
1225
1226        $m = new Any();
1227        $m->pack($packed);
1228        $this->assertSame(
1229            "{\"@type\":\"type.googleapis.com/google.protobuf.Int32Value\"," .
1230            "\"value\":123}",
1231            $m->serializeToJsonString());
1232
1233        // Test an Any message.
1234        $outer = new Any();
1235        $outer->pack($m);
1236        $this->assertSame(
1237            "{\"@type\":\"type.googleapis.com/google.protobuf.Any\"," .
1238            "\"value\":{\"@type\":\"type.googleapis.com/google.protobuf.Int32Value\"," .
1239            "\"value\":123}}",
1240            $outer->serializeToJsonString());
1241
1242        // Test a Timestamp message.
1243        $packed = new Google\Protobuf\Timestamp();
1244        $packed->setSeconds(946684800);
1245        $packed->setNanos(123456789);
1246        $m = new Any();
1247        $m->pack($packed);
1248        $this->assertSame(
1249            "{\"@type\":\"type.googleapis.com/google.protobuf.Timestamp\"," .
1250            "\"value\":\"2000-01-01T00:00:00.123456789Z\"}",
1251            $m->serializeToJsonString());
1252    }
1253
1254    public function testEncodeAnyWithDefaultWrapperMessagePacked()
1255    {
1256        $any = new Any();
1257        $any->pack(new TestInt32Value([
1258            'field' => new Int32Value(['value' => 0]),
1259        ]));
1260        $this->assertSame(
1261            "{\"@type\":\"type.googleapis.com/foo.TestInt32Value\"," .
1262            "\"field\":0}",
1263            $any->serializeToJsonString());
1264    }
1265
1266    public function testDecodeTopLevelFieldMask()
1267    {
1268        $m = new TestMessage();
1269        $m->setMapStringString(['a'=>'abcdefg']);
1270        $data1 = $m->serializeToJsonString();
1271        $n = new TestMessage();
1272        $n->mergeFromJsonString($data1);
1273        $data2 = $n->serializeToJsonString();
1274        $this->assertSame($data1, $data2);
1275
1276        $m = new FieldMask();
1277        $m->mergeFromJsonString("\"foo.barBaz,qux\"");
1278        $this->assertSame("foo.bar_baz", $m->getPaths()[0]);
1279        $this->assertSame("qux", $m->getPaths()[1]);
1280    }
1281
1282    public function testEncodeTopLevelFieldMask()
1283    {
1284        $m = new FieldMask();
1285        $m->setPaths(["foo.bar_baz", "qux"]);
1286        $this->assertSame("\"foo.barBaz,qux\"", $m->serializeToJsonString());
1287    }
1288
1289    public function testDecodeEmptyFieldMask()
1290    {
1291        $m = new FieldMask();
1292        $m->mergeFromJsonString("\"\"");
1293        $this->assertEquals("", $m->serializeToString());
1294    }
1295
1296    public function testJsonDecodeMapWithDefaultValueKey()
1297    {
1298        $m = new TestMessage();
1299        $m->getMapInt32Int32()[0] = 0;
1300        $this->assertSame("{\"mapInt32Int32\":{\"0\":0}}",
1301                          $m->serializeToJsonString());
1302
1303        $m = new TestMessage();
1304        $m->getMapStringString()[""] = "";
1305        $this->assertSame("{\"mapStringString\":{\"\":\"\"}}",
1306                          $m->serializeToJsonString());
1307    }
1308
1309    public function testJsonDecodeNumericStringMapKey()
1310    {
1311        $m = new TestMessage();
1312        $m->getMapStringString()["1"] = "1";
1313        $data = $m->serializeToJsonString();
1314        $this->assertSame("{\"mapStringString\":{\"1\":\"1\"}}", $data);
1315        $n = new TestMessage();
1316        $n->mergeFromJsonString($data);
1317    }
1318
1319    public function testMessageMapNoValue()
1320    {
1321        $m = new TestMessage();
1322        $m->mergeFromString(hex2bin("CA0700"));
1323        $m->serializeToString();
1324        $this->assertTrue(true);
1325    }
1326
1327    public function testAnyMapNoValue()
1328    {
1329        $m = new TestMessage();
1330        $m->mergeFromString(hex2bin("D20700"));
1331        $m->serializeToString();
1332        $this->assertTrue(true);
1333    }
1334
1335    public function testListValueMapNoValue()
1336    {
1337        $m = new TestMessage();
1338        $m->mergeFromString(hex2bin("DA0700"));
1339        $m->serializeToString();
1340        $this->assertTrue(true);
1341    }
1342
1343    public function testStructMapNoValue()
1344    {
1345        $m = new TestMessage();
1346        $m->mergeFromString(hex2bin("E20700"));
1347        $m->serializeToString();
1348        $this->assertTrue(true);
1349    }
1350
1351    /**
1352     * @dataProvider wrappersDataProvider
1353     */
1354    public function testWrapperJsonDecodeAndGet(
1355        $class,
1356        $nonDefaultValue,
1357        $nonDefaultValueData,
1358        $defaultValue,
1359        $defaultValueData
1360    )
1361    {
1362        // Singular with non-default
1363        $m = new $class();
1364        $m->mergeFromJsonString("{\"field\":" . $nonDefaultValueData . "}");
1365        $wrapper = $m->getField();
1366        $this->assertEquals($nonDefaultValue, $wrapper->getValue());
1367
1368        // Singular with default
1369        $m = new $class();
1370        $m->mergeFromJsonString("{\"field\":" . $defaultValueData . "}");
1371        $wrapper = $m->getField();
1372        $this->assertEquals($defaultValue, $wrapper->getValue());
1373
1374        // Repeated with empty
1375        $m = new $class();
1376        $m->mergeFromJsonString("{\"repeated_field\":[]}");
1377        $repeatedWrapper = $m->getRepeatedField();
1378        $this->assertSame(0, count($repeatedWrapper));
1379
1380        // Repeated with non-default
1381        $m = new $class();
1382        $m->mergeFromJsonString("{\"repeated_field\":[" . $defaultValueData . "]}");
1383        $repeatedWrapper = $m->getRepeatedField();
1384        $this->assertSame(1, count($repeatedWrapper));
1385        $this->assertEquals($defaultValue, $repeatedWrapper[0]->getValue());
1386
1387        // Repeated with default
1388        $m = new $class();
1389        $m->mergeFromJsonString("{\"repeated_field\":[" . $defaultValueData . "]}");
1390        $repeatedWrapper = $m->getRepeatedField();
1391        $this->assertSame(1, count($repeatedWrapper));
1392        $this->assertEquals($defaultValue, $repeatedWrapper[0]->getValue());
1393
1394        // Oneof with non-default
1395        $m = new $class();
1396        $m->mergeFromJsonString("{\"oneof_field\":" . $nonDefaultValueData . "}");
1397        $wrapper = $m->getOneofField();
1398        $this->assertEquals($nonDefaultValue, $wrapper->getValue());
1399        $this->assertEquals("oneof_field", $m->getOneofFields());
1400        $this->assertEquals(0, $m->getInt32Field());
1401
1402        // Oneof with default
1403        $m = new $class();
1404        $m->mergeFromJsonString("{\"oneof_field\":" . $defaultValueData . "}");
1405        $wrapper = $m->getOneofField();
1406        $this->assertEquals($defaultValue, $wrapper->getValue());
1407        $this->assertEquals("oneof_field", $m->getOneofFields());
1408        $this->assertEquals(0, $m->getInt32Field());
1409    }
1410
1411    /**
1412     * @dataProvider wrappersDataProvider
1413     */
1414    public function testWrapperJsonDecodeAndGetUnwrapped(
1415        $class,
1416        $nonDefaultValue,
1417        $nonDefaultValueData,
1418        $defaultValue,
1419        $defaultValueData
1420    )
1421    {
1422        // Singular with non-default
1423        $m = new $class();
1424        $m->mergeFromJsonString("{\"field\":" . $nonDefaultValueData . "}");
1425        $this->assertEquals($nonDefaultValue, $m->getFieldUnwrapped());
1426
1427        // Singular with default
1428        $m = new $class();
1429        $m->mergeFromJsonString("{\"field\":" . $defaultValueData . "}");
1430        $this->assertEquals($defaultValue, $m->getFieldUnwrapped());
1431
1432        // Oneof with non-default
1433        $m = new $class();
1434        $m->mergeFromJsonString("{\"oneof_field\":" . $nonDefaultValueData . "}");
1435        $this->assertEquals($nonDefaultValue, $m->getOneofFieldUnwrapped());
1436        $this->assertEquals("oneof_field", $m->getOneofFields());
1437        $this->assertEquals(0, $m->getInt32Field());
1438
1439        // Oneof with default
1440        $m = new $class();
1441        $m->mergeFromJsonString("{\"oneof_field\":" . $defaultValueData . "}");
1442        $this->assertEquals($defaultValue, $m->getOneofFieldUnwrapped());
1443        $this->assertEquals("oneof_field", $m->getOneofFields());
1444        $this->assertEquals(0, $m->getInt32Field());
1445    }
1446
1447    /**
1448     * @dataProvider wrappersDataProvider
1449     */
1450    public function testWrapperJsonDecodeEncode(
1451        $class,
1452        $nonDefaultValue,
1453        $nonDefaultValueData,
1454        $defaultValue,
1455        $defaultValueData
1456    )
1457    {
1458        // Singular with non-default
1459        $from = new $class();
1460        $to = new $class();
1461        $from->mergeFromJsonString("{\"field\":" . $nonDefaultValueData . "}");
1462        $data = $from->serializeToJsonString();
1463        $to->mergeFromJsonString($data);
1464        $this->assertEquals($nonDefaultValue, $to->getFieldUnwrapped());
1465
1466        // Singular with default
1467        $from = new $class();
1468        $to = new $class();
1469        $from->mergeFromJsonString("{\"field\":" . $defaultValueData . "}");
1470        $data = $from->serializeToJsonString();
1471        $to->mergeFromJsonString($data);
1472        $this->assertEquals($defaultValue, $to->getFieldUnwrapped());
1473
1474        // Oneof with non-default
1475        $from = new $class();
1476        $to = new $class();
1477        $from->mergeFromJsonString("{\"oneof_field\":" . $nonDefaultValueData . "}");
1478        $data = $from->serializeToJsonString();
1479        $to->mergeFromJsonString($data);
1480        $this->assertEquals($nonDefaultValue, $to->getOneofFieldUnwrapped());
1481
1482        // Oneof with default
1483        $from = new $class();
1484        $to = new $class();
1485        $from->mergeFromJsonString("{\"oneof_field\":" . $defaultValueData . "}");
1486        $data = $from->serializeToJsonString();
1487        $to->mergeFromJsonString($data);
1488        $this->assertEquals($defaultValue, $to->getOneofFieldUnwrapped());
1489    }
1490
1491    /**
1492     * @dataProvider wrappersDataProvider
1493     */
1494    public function testWrapperSetUnwrappedJsonEncode(
1495        $class,
1496        $nonDefaultValue,
1497        $nonDefaultValueData,
1498        $defaultValue,
1499        $defaultValueData
1500    )
1501    {
1502        // Singular with non-default
1503        $from = new $class();
1504        $to = new $class();
1505        $from->setFieldUnwrapped($nonDefaultValue);
1506        $data = $from->serializeToJsonString();
1507        $to->mergeFromJsonString($data);
1508        $this->assertEquals($nonDefaultValue, $to->getFieldUnwrapped());
1509
1510        // Singular with default
1511        $from = new $class();
1512        $to = new $class();
1513        $from->setFieldUnwrapped($defaultValue);
1514        $data = $from->serializeToJsonString();
1515        $to->mergeFromJsonString($data);
1516        $this->assertEquals($defaultValue, $to->getFieldUnwrapped());
1517
1518        // Oneof with non-default
1519        $from = new $class();
1520        $to = new $class();
1521        $from->setOneofFieldUnwrapped($nonDefaultValue);
1522        $data = $from->serializeToJsonString();
1523        $to->mergeFromJsonString($data);
1524        $this->assertEquals($nonDefaultValue, $to->getOneofFieldUnwrapped());
1525
1526        // Oneof with default
1527        $from = new $class();
1528        $to = new $class();
1529        $from->setOneofFieldUnwrapped($defaultValue);
1530        $data = $from->serializeToJsonString();
1531        $to->mergeFromJsonString($data);
1532        $this->assertEquals($defaultValue, $to->getOneofFieldUnwrapped());
1533    }
1534
1535    public function wrappersDataProvider()
1536    {
1537        return [
1538            [TestInt32Value::class, 1, "1", 0, "0"],
1539            [TestStringValue::class, "a", "\"a\"", "", "\"\""],
1540        ];
1541    }
1542
1543    public function testEmptyAnySerialization()
1544    {
1545        $m = new EmptyAnySerialization();
1546
1547        $any = new Any();
1548        $any->pack($m);
1549
1550        $data = $any->serializeToJsonString();
1551        $this->assertEquals('{"@type":"type.googleapis.com/foo.EmptyAnySerialization"}', $data);
1552
1553        $any = new Any();
1554        $any->mergeFromJsonString($data);
1555
1556        $m = $any->unpack();
1557        $this->assertInstanceOf(EmptyAnySerialization::class, $m);
1558        $this->assertEquals('', $m->getA());
1559    }
1560}
1561