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