diff options
Diffstat (limited to 'php/tests/generated_class_test.php')
-rw-r--r-- | php/tests/generated_class_test.php | 993 |
1 files changed, 796 insertions, 197 deletions
diff --git a/php/tests/generated_class_test.php b/php/tests/generated_class_test.php index 7f8567b8..9f20bddc 100644 --- a/php/tests/generated_class_test.php +++ b/php/tests/generated_class_test.php @@ -1,15 +1,28 @@ <?php -require_once('generated/NoNameSpaceEnum.php'); -require_once('generated/NoNameSpaceMessage.php'); +require_once('generated/NoNamespaceEnum.php'); +require_once('generated/NoNamespaceMessage.php'); require_once('test_base.php'); require_once('test_util.php'); use Google\Protobuf\Internal\RepeatedField; +use Google\Protobuf\Internal\MapField; use Google\Protobuf\Internal\GPBType; +use Bar\TestLegacyMessage; +use Bar\TestLegacyMessage_NestedEnum; +use Bar\TestLegacyMessage_NestedMessage; use Foo\TestEnum; +use Foo\TestIncludeNamespaceMessage; +use Foo\TestIncludePrefixMessage; use Foo\TestMessage; +use Foo\TestMessage\Sub; use Foo\TestMessage_Sub; +use Foo\TestMessage\NestedEnum; +use Foo\TestReverseFieldOrder; +use Foo\testLowerCaseMessage; +use Foo\testLowerCaseEnum; +use PBEmpty\PBEcho\TestEmptyPackage; +use Php\Test\TestNamespace; class GeneratedClassTest extends TestBase { @@ -58,24 +71,6 @@ class GeneratedClassTest extends TestBase $this->assertSame(MIN_INT32, $m->getOptionalInt32()); } - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testInt32FieldInvalidTypeFail() - { - $m = new TestMessage(); - $m->setOptionalInt32(new TestMessage()); - } - - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testInt32FieldInvalidStringFail() - { - $m = new TestMessage(); - $m->setOptionalInt32('abc'); - } - ######################################################### # Test uint32 field. ######################################################### @@ -115,24 +110,6 @@ class GeneratedClassTest extends TestBase $this->assertSame(MIN_INT32, $m->getOptionalUint32()); } - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testUint32FieldInvalidTypeFail() - { - $m = new TestMessage(); - $m->setOptionalUint32(new TestMessage()); - } - - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testUint32FieldInvalidStringFail() - { - $m = new TestMessage(); - $m->setOptionalUint32('abc'); - } - ######################################################### # Test int64 field. ######################################################### @@ -185,24 +162,6 @@ class GeneratedClassTest extends TestBase } } - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testInt64FieldInvalidTypeFail() - { - $m = new TestMessage(); - $m->setOptionalInt64(new TestMessage()); - } - - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testInt64FieldInvalidStringFail() - { - $m = new TestMessage(); - $m->setOptionalInt64('abc'); - } - ######################################################### # Test uint64 field. ######################################################### @@ -250,24 +209,6 @@ class GeneratedClassTest extends TestBase } } - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testUint64FieldInvalidTypeFail() - { - $m = new TestMessage(); - $m->setOptionalUint64(new TestMessage()); - } - - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testUint64FieldInvalidStringFail() - { - $m = new TestMessage(); - $m->setOptionalUint64('abc'); - } - ######################################################### # Test enum field. ######################################################### @@ -293,6 +234,29 @@ class GeneratedClassTest extends TestBase $this->assertEquals(TestEnum::ONE, $m->getOptionalEnum()); } + public function testNestedEnum() + { + $m = new TestMessage(); + $m->setOptionalNestedEnum(NestedEnum::ZERO); + } + + public function testLegacyNestedEnum() + { + $m = new TestMessage(); + $m->setOptionalNestedEnum(\Foo\TestMessage_NestedEnum::ZERO); + } + + public function testLegacyTypehintWithNestedEnums() + { + $this->legacyEnum(new TestLegacyMessage\NestedEnum); + } + + private function legacyEnum(TestLegacyMessage_NestedEnum $enum) + { + // If we made it here without a PHP Fatal error, the typehint worked + $this->assertTrue(true); + } + ######################################################### # Test float field. ######################################################### @@ -316,24 +280,6 @@ class GeneratedClassTest extends TestBase $this->assertEquals(3.1, $m->getOptionalFloat(), '', MAX_FLOAT_DIFF); } - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testFloatFieldInvalidTypeFail() - { - $m = new TestMessage(); - $m->setOptionalFloat(new TestMessage()); - } - - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testFloatFieldInvalidStringFail() - { - $m = new TestMessage(); - $m->setOptionalFloat('abc'); - } - ######################################################### # Test double field. ######################################################### @@ -357,24 +303,6 @@ class GeneratedClassTest extends TestBase $this->assertEquals(3.1, $m->getOptionalDouble(), '', MAX_FLOAT_DIFF); } - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testDoubleFieldInvalidTypeFail() - { - $m = new TestMessage(); - $m->setOptionalDouble(new TestMessage()); - } - - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testDoubleFieldInvalidStringFail() - { - $m = new TestMessage(); - $m->setOptionalDouble('abc'); - } - ######################################################### # Test bool field. ######################################################### @@ -400,15 +328,6 @@ class GeneratedClassTest extends TestBase $this->assertSame(false, $m->getOptionalBool()); } - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testBoolFieldInvalidStringFail() - { - $m = new TestMessage(); - $m->setOptionalBool(new TestMessage()); - } - ######################################################### # Test string field. ######################################################### @@ -434,16 +353,6 @@ class GeneratedClassTest extends TestBase $this->assertSame('1', $m->getOptionalString()); } - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testStringFieldInvalidUTF8Fail() - { - $m = new TestMessage(); - $hex = hex2bin("ff"); - $m->setOptionalString($hex); - } - ######################################################### # Test bytes field. ######################################################### @@ -484,7 +393,7 @@ class GeneratedClassTest extends TestBase { $m = new TestMessage(); - $sub_m = new TestMessage_Sub(); + $sub_m = new Sub(); $sub_m->setA(1); $m->setOptionalMessage($sub_m); $this->assertSame(1, $m->getOptionalMessage()->getA()); @@ -494,23 +403,29 @@ class GeneratedClassTest extends TestBase $this->assertNull($m->getOptionalMessage()); } - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testMessageFieldWrongTypeFail() + public function testLegacyMessageField() { $m = new TestMessage(); - $a = 1; - $m->setOptionalMessage($a); + + $sub_m = new TestMessage_Sub(); + $sub_m->setA(1); + $m->setOptionalMessage($sub_m); + $this->assertSame(1, $m->getOptionalMessage()->getA()); + + $null = null; + $m->setOptionalMessage($null); + $this->assertNull($m->getOptionalMessage()); } - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testMessageFieldWrongClassFail() + public function testLegacyTypehintWithNestedMessages() { - $m = new TestMessage(); - $m->setOptionalMessage(new TestMessage()); + $this->legacyMessage(new TestLegacyMessage\NestedMessage); + } + + private function legacyMessage(TestLegacyMessage_NestedMessage $sub) + { + // If we made it here without a PHP Fatal error, the typehint worked + $this->assertTrue(true); } ######################################################### @@ -526,46 +441,55 @@ class GeneratedClassTest extends TestBase $this->assertSame($repeated_int32, $m->getRepeatedInt32()); } - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testRepeatedFieldWrongTypeFail() + public function testRepeatedFieldViaArray() { $m = new TestMessage(); - $a = 1; - $m->setRepeatedInt32($a); - } - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testRepeatedFieldWrongObjectFail() - { - $m = new TestMessage(); - $m->setRepeatedInt32($m); + $arr = array(); + $m->setRepeatedInt32($arr); + $this->assertSame(0, count($m->getRepeatedInt32())); + + $arr = array(1, 2.1, "3"); + $m->setRepeatedInt32($arr); + $this->assertTrue($m->getRepeatedInt32() instanceof RepeatedField); + $this->assertSame("Google\Protobuf\Internal\RepeatedField", + get_class($m->getRepeatedInt32())); + $this->assertSame(3, count($m->getRepeatedInt32())); + $this->assertSame(1, $m->getRepeatedInt32()[0]); + $this->assertSame(2, $m->getRepeatedInt32()[1]); + $this->assertSame(3, $m->getRepeatedInt32()[2]); + $this->assertFalse($arr instanceof RepeatedField); } - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testRepeatedFieldWrongRepeatedTypeFail() + ######################################################### + # Test map field. + ######################################################### + + public function testMapField() { $m = new TestMessage(); - $repeated_int32 = new RepeatedField(GPBType::UINT32); - $m->setRepeatedInt32($repeated_int32); + $map_int32_int32 = new MapField(GPBType::INT32, GPBType::INT32); + $m->setMapInt32Int32($map_int32_int32); + $this->assertSame($map_int32_int32, $m->getMapInt32Int32()); } - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testRepeatedFieldWrongRepeatedMessageClassFail() + public function testMapFieldViaArray() { $m = new TestMessage(); - $repeated_message = new RepeatedField(GPBType::MESSAGE, - TestMessage::class); - $m->setRepeatedMessage($repeated_message); + $dict = array(); + $m->setMapInt32Int32($dict); + $this->assertSame(0, count($m->getMapInt32Int32())); + + $dict = array(5 => 5, 6.1 => 6.1, "7" => "7"); + $m->setMapInt32Int32($dict); + $this->assertTrue($m->getMapInt32Int32() instanceof MapField); + $this->assertSame(3, count($m->getMapInt32Int32())); + $this->assertSame(5, $m->getMapInt32Int32()[5]); + $this->assertSame(6, $m->getMapInt32Int32()[6]); + $this->assertSame(7, $m->getMapInt32Int32()[7]); + $this->assertFalse($dict instanceof MapField); } ######################################################### @@ -598,7 +522,7 @@ class GeneratedClassTest extends TestBase $this->assertSame(NULL, $m->getOneofMessage()); $this->assertSame("oneof_string", $m->getMyOneof()); - $sub_m = new TestMessage_Sub(); + $sub_m = new Sub(); $sub_m->setA(1); $m->setOneofMessage($sub_m); $this->assertSame(0, $m->getOneofInt32()); @@ -637,26 +561,46 @@ class GeneratedClassTest extends TestBase // Singular $n->setOptionalInt32(100); - $sub1 = new TestMessage_Sub(); + $sub1 = new Sub(); $sub1->setA(101); - $sub1->getB()[] = 102; + + $b = $sub1->getB(); + $b[] = 102; + $sub1->setB($b); + $n->setOptionalMessage($sub1); // Repeated - $n->getRepeatedInt32()[] = 200; - $n->getRepeatedString()[] = 'abc'; - $sub2 = new TestMessage_Sub(); + $repeatedInt32 = $n->getRepeatedInt32(); + $repeatedInt32[] = 200; + $n->setRepeatedInt32($repeatedInt32); + + $repeatedString = $n->getRepeatedString(); + $repeatedString[] = 'abc'; + $n->setRepeatedString($repeatedString); + + $sub2 = new Sub(); $sub2->setA(201); - $n->getRepeatedMessage()[] = $sub2; + $repeatedMessage = $n->getRepeatedMessage(); + $repeatedMessage[] = $sub2; + $n->setRepeatedMessage($repeatedMessage); // Map - $n->getMapInt32Int32()[1] = 300; - $n->getMapInt32Int32()[-62] = 301; - $n->getMapStringString()['def'] = 'def'; - $n->getMapInt32Message()[1] = new TestMessage_Sub(); - $n->getMapInt32Message()[1]->setA(302); - $n->getMapInt32Message()[2] = new TestMessage_Sub(); - $n->getMapInt32Message()[2]->setA(303); + $mapInt32Int32 = $n->getMapInt32Int32(); + $mapInt32Int32[1] = 300; + $mapInt32Int32[-62] = 301; + $n->setMapInt32Int32($mapInt32Int32); + + $mapStringString = $n->getMapStringString(); + $mapStringString['def'] = 'def'; + $n->setMapStringString($mapStringString); + + $mapInt32Message = $n->getMapInt32Message(); + $mapInt32Message[1] = new Sub(); + $mapInt32Message[1]->setA(302); + $mapInt32Message[2] = new Sub(); + $mapInt32Message[2]->setA(303); + $n->setMapInt32Message($mapInt32Message); $m->mergeFrom($n); @@ -691,9 +635,16 @@ class GeneratedClassTest extends TestBase // Check sub-messages are copied by value. $n->getOptionalMessage()->setA(-101); $this->assertSame(101, $m->getOptionalMessage()->getA()); - $n->getRepeatedMessage()[0]->setA(-201); + + $repeatedMessage = $n->getRepeatedMessage(); + $repeatedMessage[0]->setA(-201); + $n->setRepeatedMessage($repeatedMessage); $this->assertSame(201, $m->getRepeatedMessage()[2]->getA()); - $n->getMapInt32Message()[1]->setA(-302); + + $mapInt32Message = $n->getMapInt32Message(); + $mapInt32Message[1]->setA(-302); + $n->setMapInt32Message($mapInt32Message); + $this->assertSame(302, $m->getMapInt32Message()[1]->getA()); // Test merge oneof. @@ -704,7 +655,7 @@ class GeneratedClassTest extends TestBase $m->mergeFrom($n); $this->assertSame(1, $m->getOneofInt32()); - $sub = new TestMessage_Sub(); + $sub = new Sub(); $n->setOneofMessage($sub); $n->getOneofMessage()->setA(400); $m->mergeFrom($n); @@ -720,27 +671,675 @@ class GeneratedClassTest extends TestBase $this->expectFields($n); } - /** - * @expectedException PHPUnit_Framework_Error - */ - public function testMessageMergeFromInvalidTypeFail() + ######################################################### + # Test message/enum without namespace. + ######################################################### + + public function testMessageWithoutNamespace() { $m = new TestMessage(); - $n = new TestMessage_Sub(); - $m->mergeFrom($n); + $n = new NoNameSpaceMessage(); + $m->setOptionalNoNamespaceMessage($n); + $repeatedNoNamespaceMessage = $m->getRepeatedNoNamespaceMessage(); + $repeatedNoNamespaceMessage[] = new NoNameSpaceMessage(); + $m->setRepeatedNoNamespaceMessage($repeatedNoNamespaceMessage); + + // test nested messages + $sub = new NoNamespaceMessage\NestedMessage(); + $n->setNestedMessage($sub); + } + + public function testEnumWithoutNamespace() + { + $m = new TestMessage(); + $m->setOptionalNoNamespaceEnum(NoNameSpaceEnum::VALUE_A); + $repeatedNoNamespaceEnum = $m->getRepeatedNoNamespaceEnum(); + $repeatedNoNamespaceEnum[] = NoNameSpaceEnum::VALUE_A; + $m->setRepeatedNoNamespaceEnum($repeatedNoNamespaceEnum); } ######################################################### - # Test message/enum without namespace. + # Test message with given namespace. ######################################################### - public function testMessageWithoutNamespace() + public function testNestedMessagesAndEnums() { - $m = new NoNameSpaceMessage(); + $m = new TestMessage(); + $n = new TestMessage\Sub(); + $m->setOptionalMessage($n); + $m->setOptionalNestedEnum(TestMessage\NestedEnum::ZERO); + $this->assertSame($n, $m->getOptionalMessage()); + $this->assertSame(TestMessage\NestedEnum::ZERO, $m->getOptionalNestedEnum()); } - public function testEnumWithoutNamespace() + public function testMessagesAndEnumsWithPrefix() + { + // Test message prefix + $m = new TestIncludePrefixMessage(); + $n = new PrefixTestPrefix(); + $n->setA(1); + $m->setPrefixMessage($n); + $this->assertSame(1, $m->getPrefixMessage()->getA()); + + // Test nested message prefix + $o = new PrefixTestPrefix(); + $p = new PrefixTestPrefix\PrefixNestedMessage(); + $o->setNestedMessage($p); + $o->setNestedEnum(PrefixTestPrefix\PrefixNestedEnum::ZERO); + $this->assertSame($p, $o->getNestedMessage()); + $this->assertSame(PrefixTestPrefix\PrefixNestedEnum::ZERO, $o->getNestedEnum()); + } + + public function testMessagesAndEnumsWithPhpNamespace() + { + $m = new TestNamespace(); + $n = new TestNamespace\NestedMessage(); + $m->setNestedMessage($n); + $m->setNestedEnum(TestNamespace\NestedEnum::ZERO); + $this->assertSame($n, $m->getNestedMessage()); + $this->assertSame(TestNamespace\NestedEnum::ZERO, $m->getNestedEnum()); + } + + public function testMesssagesAndEnumsWithEmptyPhpNamespace() + { + $m = new TestEmptyNamespace(); + $n = new TestEmptyNamespace\NestedMessage(); + $m->setNestedMessage($n); + $m->setNestedEnum(TestEmptyNamespace\NestedEnum::ZERO); + $this->assertSame($n, $m->getNestedMessage()); + $this->assertSame(TestEmptyNamespace\NestedEnum::ZERO, $m->getNestedEnum()); + } + + public function testMessagesAndEnumsWithNoNamespace() + { + $m = new NoNamespaceMessage(); + $n = new NoNamespaceMessage\NestedMessage(); + $m->setNestedMessage($n); + $m->setNestedEnum(NoNamespaceMessage\NestedEnum::ZERO); + $this->assertSame($n, $m->getNestedMessage()); + $this->assertSame(NoNamespaceMessage\NestedEnum::ZERO, $m->getNestedEnum()); + } + + public function testReservedWordsInPackageName() + { + $m = new TestEmptyPackage(); + $n = new TestEmptyPackage\NestedMessage(); + $m->setNestedMessage($n); + $m->setNestedEnum(TestEmptyPackage\NestedEnum::ZERO); + $this->assertSame($n, $m->getNestedMessage()); + $this->assertSame(TestEmptyPackage\NestedEnum::ZERO, $m->getNestedEnum()); + } + + public function testReservedWordsInNamespace() + { + $m = new TestNamespace(); + $n = new TestNamespace\PBEmpty(); + $o = new TestNamespace\PBEmpty\NestedMessage(); + $n->setNestedMessage($o); + $n->setNestedEnum(TestNamespace\PBEmpty\NestedEnum::ZERO); + $m->setReservedName($n); + $this->assertSame($n, $m->getReservedName()); + $this->assertSame($o, $n->getNestedMessage()); + $this->assertSame( + TestNamespace\PBEmpty\NestedEnum::ZERO, + $n->getNestedEnum() + ); + } + + ######################################################### + # Test prefix for reserved words. + ######################################################### + + public function testPrefixForReservedWords() + { + $m = new \Foo\TestMessage\PBEmpty(); + $m = new \Foo\PBEmpty(); + $m = new \PrefixEmpty(); + $m = new \Foo\PBARRAY(); + + $m = new \Lower\PBabstract(); + $m = new \Lower\PBand(); + $m = new \Lower\PBarray(); + $m = new \Lower\PBas(); + $m = new \Lower\PBbreak(); + $m = new \Lower\PBcallable(); + $m = new \Lower\PBcase(); + $m = new \Lower\PBcatch(); + $m = new \Lower\PBclass(); + $m = new \Lower\PBclone(); + $m = new \Lower\PBconst(); + $m = new \Lower\PBcontinue(); + $m = new \Lower\PBdeclare(); + $m = new \Lower\PBdefault(); + $m = new \Lower\PBdie(); + $m = new \Lower\PBdo(); + $m = new \Lower\PBecho(); + $m = new \Lower\PBelse(); + $m = new \Lower\PBelseif(); + $m = new \Lower\PBempty(); + $m = new \Lower\PBenddeclare(); + $m = new \Lower\PBendfor(); + $m = new \Lower\PBendforeach(); + $m = new \Lower\PBendif(); + $m = new \Lower\PBendswitch(); + $m = new \Lower\PBendwhile(); + $m = new \Lower\PBeval(); + $m = new \Lower\PBexit(); + $m = new \Lower\PBextends(); + $m = new \Lower\PBfinal(); + $m = new \Lower\PBfor(); + $m = new \Lower\PBforeach(); + $m = new \Lower\PBfunction(); + $m = new \Lower\PBglobal(); + $m = new \Lower\PBgoto(); + $m = new \Lower\PBif(); + $m = new \Lower\PBimplements(); + $m = new \Lower\PBinclude(); + $m = new \Lower\PBinclude_once(); + $m = new \Lower\PBinstanceof(); + $m = new \Lower\PBinsteadof(); + $m = new \Lower\PBinterface(); + $m = new \Lower\PBisset(); + $m = new \Lower\PBlist(); + $m = new \Lower\PBnamespace(); + $m = new \Lower\PBnew(); + $m = new \Lower\PBor(); + $m = new \Lower\PBprint(); + $m = new \Lower\PBprivate(); + $m = new \Lower\PBprotected(); + $m = new \Lower\PBpublic(); + $m = new \Lower\PBrequire(); + $m = new \Lower\PBrequire_once(); + $m = new \Lower\PBreturn(); + $m = new \Lower\PBstatic(); + $m = new \Lower\PBswitch(); + $m = new \Lower\PBthrow(); + $m = new \Lower\PBtrait(); + $m = new \Lower\PBtry(); + $m = new \Lower\PBunset(); + $m = new \Lower\PBuse(); + $m = new \Lower\PBvar(); + $m = new \Lower\PBwhile(); + $m = new \Lower\PBxor(); + $m = new \Lower\PBint(); + $m = new \Lower\PBfloat(); + $m = new \Lower\PBbool(); + $m = new \Lower\PBstring(); + $m = new \Lower\PBtrue(); + $m = new \Lower\PBfalse(); + $m = new \Lower\PBnull(); + $m = new \Lower\PBvoid(); + $m = new \Lower\PBiterable(); + + $m = new \Upper\PBABSTRACT(); + $m = new \Upper\PBAND(); + $m = new \Upper\PBARRAY(); + $m = new \Upper\PBAS(); + $m = new \Upper\PBBREAK(); + $m = new \Upper\PBCALLABLE(); + $m = new \Upper\PBCASE(); + $m = new \Upper\PBCATCH(); + $m = new \Upper\PBCLASS(); + $m = new \Upper\PBCLONE(); + $m = new \Upper\PBCONST(); + $m = new \Upper\PBCONTINUE(); + $m = new \Upper\PBDECLARE(); + $m = new \Upper\PBDEFAULT(); + $m = new \Upper\PBDIE(); + $m = new \Upper\PBDO(); + $m = new \Upper\PBECHO(); + $m = new \Upper\PBELSE(); + $m = new \Upper\PBELSEIF(); + $m = new \Upper\PBEMPTY(); + $m = new \Upper\PBENDDECLARE(); + $m = new \Upper\PBENDFOR(); + $m = new \Upper\PBENDFOREACH(); + $m = new \Upper\PBENDIF(); + $m = new \Upper\PBENDSWITCH(); + $m = new \Upper\PBENDWHILE(); + $m = new \Upper\PBEVAL(); + $m = new \Upper\PBEXIT(); + $m = new \Upper\PBEXTENDS(); + $m = new \Upper\PBFINAL(); + $m = new \Upper\PBFOR(); + $m = new \Upper\PBFOREACH(); + $m = new \Upper\PBFUNCTION(); + $m = new \Upper\PBGLOBAL(); + $m = new \Upper\PBGOTO(); + $m = new \Upper\PBIF(); + $m = new \Upper\PBIMPLEMENTS(); + $m = new \Upper\PBINCLUDE(); + $m = new \Upper\PBINCLUDE_ONCE(); + $m = new \Upper\PBINSTANCEOF(); + $m = new \Upper\PBINSTEADOF(); + $m = new \Upper\PBINTERFACE(); + $m = new \Upper\PBISSET(); + $m = new \Upper\PBLIST(); + $m = new \Upper\PBNAMESPACE(); + $m = new \Upper\PBNEW(); + $m = new \Upper\PBOR(); + $m = new \Upper\PBPRINT(); + $m = new \Upper\PBPRIVATE(); + $m = new \Upper\PBPROTECTED(); + $m = new \Upper\PBPUBLIC(); + $m = new \Upper\PBREQUIRE(); + $m = new \Upper\PBREQUIRE_ONCE(); + $m = new \Upper\PBRETURN(); + $m = new \Upper\PBSTATIC(); + $m = new \Upper\PBSWITCH(); + $m = new \Upper\PBTHROW(); + $m = new \Upper\PBTRAIT(); + $m = new \Upper\PBTRY(); + $m = new \Upper\PBUNSET(); + $m = new \Upper\PBUSE(); + $m = new \Upper\PBVAR(); + $m = new \Upper\PBWHILE(); + $m = new \Upper\PBXOR(); + $m = new \Upper\PBINT(); + $m = new \Upper\PBFLOAT(); + $m = new \Upper\PBBOOL(); + $m = new \Upper\PBSTRING(); + $m = new \Upper\PBTRUE(); + $m = new \Upper\PBFALSE(); + $m = new \Upper\PBNULL(); + $m = new \Upper\PBVOID(); + $m = new \Upper\PBITERABLE(); + + $m = new \Lower_enum\PBabstract(); + $m = new \Lower_enum\PBand(); + $m = new \Lower_enum\PBarray(); + $m = new \Lower_enum\PBas(); + $m = new \Lower_enum\PBbreak(); + $m = new \Lower_enum\PBcallable(); + $m = new \Lower_enum\PBcase(); + $m = new \Lower_enum\PBcatch(); + $m = new \Lower_enum\PBclass(); + $m = new \Lower_enum\PBclone(); + $m = new \Lower_enum\PBconst(); + $m = new \Lower_enum\PBcontinue(); + $m = new \Lower_enum\PBdeclare(); + $m = new \Lower_enum\PBdefault(); + $m = new \Lower_enum\PBdie(); + $m = new \Lower_enum\PBdo(); + $m = new \Lower_enum\PBecho(); + $m = new \Lower_enum\PBelse(); + $m = new \Lower_enum\PBelseif(); + $m = new \Lower_enum\PBempty(); + $m = new \Lower_enum\PBenddeclare(); + $m = new \Lower_enum\PBendfor(); + $m = new \Lower_enum\PBendforeach(); + $m = new \Lower_enum\PBendif(); + $m = new \Lower_enum\PBendswitch(); + $m = new \Lower_enum\PBendwhile(); + $m = new \Lower_enum\PBeval(); + $m = new \Lower_enum\PBexit(); + $m = new \Lower_enum\PBextends(); + $m = new \Lower_enum\PBfinal(); + $m = new \Lower_enum\PBfor(); + $m = new \Lower_enum\PBforeach(); + $m = new \Lower_enum\PBfunction(); + $m = new \Lower_enum\PBglobal(); + $m = new \Lower_enum\PBgoto(); + $m = new \Lower_enum\PBif(); + $m = new \Lower_enum\PBimplements(); + $m = new \Lower_enum\PBinclude(); + $m = new \Lower_enum\PBinclude_once(); + $m = new \Lower_enum\PBinstanceof(); + $m = new \Lower_enum\PBinsteadof(); + $m = new \Lower_enum\PBinterface(); + $m = new \Lower_enum\PBisset(); + $m = new \Lower_enum\PBlist(); + $m = new \Lower_enum\PBnamespace(); + $m = new \Lower_enum\PBnew(); + $m = new \Lower_enum\PBor(); + $m = new \Lower_enum\PBprint(); + $m = new \Lower_enum\PBprivate(); + $m = new \Lower_enum\PBprotected(); + $m = new \Lower_enum\PBpublic(); + $m = new \Lower_enum\PBrequire(); + $m = new \Lower_enum\PBrequire_once(); + $m = new \Lower_enum\PBreturn(); + $m = new \Lower_enum\PBstatic(); + $m = new \Lower_enum\PBswitch(); + $m = new \Lower_enum\PBthrow(); + $m = new \Lower_enum\PBtrait(); + $m = new \Lower_enum\PBtry(); + $m = new \Lower_enum\PBunset(); + $m = new \Lower_enum\PBuse(); + $m = new \Lower_enum\PBvar(); + $m = new \Lower_enum\PBwhile(); + $m = new \Lower_enum\PBxor(); + $m = new \Lower_enum\PBint(); + $m = new \Lower_enum\PBfloat(); + $m = new \Lower_enum\PBbool(); + $m = new \Lower_enum\PBstring(); + $m = new \Lower_enum\PBtrue(); + $m = new \Lower_enum\PBfalse(); + $m = new \Lower_enum\PBnull(); + $m = new \Lower_enum\PBvoid(); + $m = new \Lower_enum\PBiterable(); + + $m = new \Upper_enum\PBABSTRACT(); + $m = new \Upper_enum\PBAND(); + $m = new \Upper_enum\PBARRAY(); + $m = new \Upper_enum\PBAS(); + $m = new \Upper_enum\PBBREAK(); + $m = new \Upper_enum\PBCALLABLE(); + $m = new \Upper_enum\PBCASE(); + $m = new \Upper_enum\PBCATCH(); + $m = new \Upper_enum\PBCLASS(); + $m = new \Upper_enum\PBCLONE(); + $m = new \Upper_enum\PBCONST(); + $m = new \Upper_enum\PBCONTINUE(); + $m = new \Upper_enum\PBDECLARE(); + $m = new \Upper_enum\PBDEFAULT(); + $m = new \Upper_enum\PBDIE(); + $m = new \Upper_enum\PBDO(); + $m = new \Upper_enum\PBECHO(); + $m = new \Upper_enum\PBELSE(); + $m = new \Upper_enum\PBELSEIF(); + $m = new \Upper_enum\PBEMPTY(); + $m = new \Upper_enum\PBENDDECLARE(); + $m = new \Upper_enum\PBENDFOR(); + $m = new \Upper_enum\PBENDFOREACH(); + $m = new \Upper_enum\PBENDIF(); + $m = new \Upper_enum\PBENDSWITCH(); + $m = new \Upper_enum\PBENDWHILE(); + $m = new \Upper_enum\PBEVAL(); + $m = new \Upper_enum\PBEXIT(); + $m = new \Upper_enum\PBEXTENDS(); + $m = new \Upper_enum\PBFINAL(); + $m = new \Upper_enum\PBFOR(); + $m = new \Upper_enum\PBFOREACH(); + $m = new \Upper_enum\PBFUNCTION(); + $m = new \Upper_enum\PBGLOBAL(); + $m = new \Upper_enum\PBGOTO(); + $m = new \Upper_enum\PBIF(); + $m = new \Upper_enum\PBIMPLEMENTS(); + $m = new \Upper_enum\PBINCLUDE(); + $m = new \Upper_enum\PBINCLUDE_ONCE(); + $m = new \Upper_enum\PBINSTANCEOF(); + $m = new \Upper_enum\PBINSTEADOF(); + $m = new \Upper_enum\PBINTERFACE(); + $m = new \Upper_enum\PBISSET(); + $m = new \Upper_enum\PBLIST(); + $m = new \Upper_enum\PBNAMESPACE(); + $m = new \Upper_enum\PBNEW(); + $m = new \Upper_enum\PBOR(); + $m = new \Upper_enum\PBPRINT(); + $m = new \Upper_enum\PBPRIVATE(); + $m = new \Upper_enum\PBPROTECTED(); + $m = new \Upper_enum\PBPUBLIC(); + $m = new \Upper_enum\PBREQUIRE(); + $m = new \Upper_enum\PBREQUIRE_ONCE(); + $m = new \Upper_enum\PBRETURN(); + $m = new \Upper_enum\PBSTATIC(); + $m = new \Upper_enum\PBSWITCH(); + $m = new \Upper_enum\PBTHROW(); + $m = new \Upper_enum\PBTRAIT(); + $m = new \Upper_enum\PBTRY(); + $m = new \Upper_enum\PBUNSET(); + $m = new \Upper_enum\PBUSE(); + $m = new \Upper_enum\PBVAR(); + $m = new \Upper_enum\PBWHILE(); + $m = new \Upper_enum\PBXOR(); + $m = new \Upper_enum\PBINT(); + $m = new \Upper_enum\PBFLOAT(); + $m = new \Upper_enum\PBBOOL(); + $m = new \Upper_enum\PBSTRING(); + $m = new \Upper_enum\PBTRUE(); + $m = new \Upper_enum\PBFALSE(); + $m = new \Upper_enum\PBNULL(); + $m = new \Upper_enum\PBVOID(); + $m = new \Upper_enum\PBITERABLE(); + + $m = \Lower_enum_value\NotAllowed::PBabstract; + $m = \Lower_enum_value\NotAllowed::PBand; + $m = \Lower_enum_value\NotAllowed::PBarray; + $m = \Lower_enum_value\NotAllowed::PBas; + $m = \Lower_enum_value\NotAllowed::PBbreak; + $m = \Lower_enum_value\NotAllowed::PBcallable; + $m = \Lower_enum_value\NotAllowed::PBcase; + $m = \Lower_enum_value\NotAllowed::PBcatch; + $m = \Lower_enum_value\NotAllowed::PBclass; + $m = \Lower_enum_value\NotAllowed::PBclone; + $m = \Lower_enum_value\NotAllowed::PBconst; + $m = \Lower_enum_value\NotAllowed::PBcontinue; + $m = \Lower_enum_value\NotAllowed::PBdeclare; + $m = \Lower_enum_value\NotAllowed::PBdefault; + $m = \Lower_enum_value\NotAllowed::PBdie; + $m = \Lower_enum_value\NotAllowed::PBdo; + $m = \Lower_enum_value\NotAllowed::PBecho; + $m = \Lower_enum_value\NotAllowed::PBelse; + $m = \Lower_enum_value\NotAllowed::PBelseif; + $m = \Lower_enum_value\NotAllowed::PBempty; + $m = \Lower_enum_value\NotAllowed::PBenddeclare; + $m = \Lower_enum_value\NotAllowed::PBendfor; + $m = \Lower_enum_value\NotAllowed::PBendforeach; + $m = \Lower_enum_value\NotAllowed::PBendif; + $m = \Lower_enum_value\NotAllowed::PBendswitch; + $m = \Lower_enum_value\NotAllowed::PBendwhile; + $m = \Lower_enum_value\NotAllowed::PBeval; + $m = \Lower_enum_value\NotAllowed::PBexit; + $m = \Lower_enum_value\NotAllowed::PBextends; + $m = \Lower_enum_value\NotAllowed::PBfinal; + $m = \Lower_enum_value\NotAllowed::PBfor; + $m = \Lower_enum_value\NotAllowed::PBforeach; + $m = \Lower_enum_value\NotAllowed::PBfunction; + $m = \Lower_enum_value\NotAllowed::PBglobal; + $m = \Lower_enum_value\NotAllowed::PBgoto; + $m = \Lower_enum_value\NotAllowed::PBif; + $m = \Lower_enum_value\NotAllowed::PBimplements; + $m = \Lower_enum_value\NotAllowed::PBinclude; + $m = \Lower_enum_value\NotAllowed::PBinclude_once; + $m = \Lower_enum_value\NotAllowed::PBinstanceof; + $m = \Lower_enum_value\NotAllowed::PBinsteadof; + $m = \Lower_enum_value\NotAllowed::PBinterface; + $m = \Lower_enum_value\NotAllowed::PBisset; + $m = \Lower_enum_value\NotAllowed::PBlist; + $m = \Lower_enum_value\NotAllowed::PBnamespace; + $m = \Lower_enum_value\NotAllowed::PBnew; + $m = \Lower_enum_value\NotAllowed::PBor; + $m = \Lower_enum_value\NotAllowed::PBprint; + $m = \Lower_enum_value\NotAllowed::PBprivate; + $m = \Lower_enum_value\NotAllowed::PBprotected; + $m = \Lower_enum_value\NotAllowed::PBpublic; + $m = \Lower_enum_value\NotAllowed::PBrequire; + $m = \Lower_enum_value\NotAllowed::PBrequire_once; + $m = \Lower_enum_value\NotAllowed::PBreturn; + $m = \Lower_enum_value\NotAllowed::PBstatic; + $m = \Lower_enum_value\NotAllowed::PBswitch; + $m = \Lower_enum_value\NotAllowed::PBthrow; + $m = \Lower_enum_value\NotAllowed::PBtrait; + $m = \Lower_enum_value\NotAllowed::PBtry; + $m = \Lower_enum_value\NotAllowed::PBunset; + $m = \Lower_enum_value\NotAllowed::PBuse; + $m = \Lower_enum_value\NotAllowed::PBvar; + $m = \Lower_enum_value\NotAllowed::PBwhile; + $m = \Lower_enum_value\NotAllowed::PBxor; + $m = \Lower_enum_value\NotAllowed::int; + $m = \Lower_enum_value\NotAllowed::float; + $m = \Lower_enum_value\NotAllowed::bool; + $m = \Lower_enum_value\NotAllowed::string; + $m = \Lower_enum_value\NotAllowed::true; + $m = \Lower_enum_value\NotAllowed::false; + $m = \Lower_enum_value\NotAllowed::null; + $m = \Lower_enum_value\NotAllowed::void; + $m = \Lower_enum_value\NotAllowed::iterable; + + $m = \Upper_enum_value\NotAllowed::PBABSTRACT; + $m = \Upper_enum_value\NotAllowed::PBAND; + $m = \Upper_enum_value\NotAllowed::PBARRAY; + $m = \Upper_enum_value\NotAllowed::PBAS; + $m = \Upper_enum_value\NotAllowed::PBBREAK; + $m = \Upper_enum_value\NotAllowed::PBCALLABLE; + $m = \Upper_enum_value\NotAllowed::PBCASE; + $m = \Upper_enum_value\NotAllowed::PBCATCH; + $m = \Upper_enum_value\NotAllowed::PBCLASS; + $m = \Upper_enum_value\NotAllowed::PBCLONE; + $m = \Upper_enum_value\NotAllowed::PBCONST; + $m = \Upper_enum_value\NotAllowed::PBCONTINUE; + $m = \Upper_enum_value\NotAllowed::PBDECLARE; + $m = \Upper_enum_value\NotAllowed::PBDEFAULT; + $m = \Upper_enum_value\NotAllowed::PBDIE; + $m = \Upper_enum_value\NotAllowed::PBDO; + $m = \Upper_enum_value\NotAllowed::PBECHO; + $m = \Upper_enum_value\NotAllowed::PBELSE; + $m = \Upper_enum_value\NotAllowed::PBELSEIF; + $m = \Upper_enum_value\NotAllowed::PBEMPTY; + $m = \Upper_enum_value\NotAllowed::PBENDDECLARE; + $m = \Upper_enum_value\NotAllowed::PBENDFOR; + $m = \Upper_enum_value\NotAllowed::PBENDFOREACH; + $m = \Upper_enum_value\NotAllowed::PBENDIF; + $m = \Upper_enum_value\NotAllowed::PBENDSWITCH; + $m = \Upper_enum_value\NotAllowed::PBENDWHILE; + $m = \Upper_enum_value\NotAllowed::PBEVAL; + $m = \Upper_enum_value\NotAllowed::PBEXIT; + $m = \Upper_enum_value\NotAllowed::PBEXTENDS; + $m = \Upper_enum_value\NotAllowed::PBFINAL; + $m = \Upper_enum_value\NotAllowed::PBFOR; + $m = \Upper_enum_value\NotAllowed::PBFOREACH; + $m = \Upper_enum_value\NotAllowed::PBFUNCTION; + $m = \Upper_enum_value\NotAllowed::PBGLOBAL; + $m = \Upper_enum_value\NotAllowed::PBGOTO; + $m = \Upper_enum_value\NotAllowed::PBIF; + $m = \Upper_enum_value\NotAllowed::PBIMPLEMENTS; + $m = \Upper_enum_value\NotAllowed::PBINCLUDE; + $m = \Upper_enum_value\NotAllowed::PBINCLUDE_ONCE; + $m = \Upper_enum_value\NotAllowed::PBINSTANCEOF; + $m = \Upper_enum_value\NotAllowed::PBINSTEADOF; + $m = \Upper_enum_value\NotAllowed::PBINTERFACE; + $m = \Upper_enum_value\NotAllowed::PBISSET; + $m = \Upper_enum_value\NotAllowed::PBLIST; + $m = \Upper_enum_value\NotAllowed::PBNAMESPACE; + $m = \Upper_enum_value\NotAllowed::PBNEW; + $m = \Upper_enum_value\NotAllowed::PBOR; + $m = \Upper_enum_value\NotAllowed::PBPRINT; + $m = \Upper_enum_value\NotAllowed::PBPRIVATE; + $m = \Upper_enum_value\NotAllowed::PBPROTECTED; + $m = \Upper_enum_value\NotAllowed::PBPUBLIC; + $m = \Upper_enum_value\NotAllowed::PBREQUIRE; + $m = \Upper_enum_value\NotAllowed::PBREQUIRE_ONCE; + $m = \Upper_enum_value\NotAllowed::PBRETURN; + $m = \Upper_enum_value\NotAllowed::PBSTATIC; + $m = \Upper_enum_value\NotAllowed::PBSWITCH; + $m = \Upper_enum_value\NotAllowed::PBTHROW; + $m = \Upper_enum_value\NotAllowed::PBTRAIT; + $m = \Upper_enum_value\NotAllowed::PBTRY; + $m = \Upper_enum_value\NotAllowed::PBUNSET; + $m = \Upper_enum_value\NotAllowed::PBUSE; + $m = \Upper_enum_value\NotAllowed::PBVAR; + $m = \Upper_enum_value\NotAllowed::PBWHILE; + $m = \Upper_enum_value\NotAllowed::PBXOR; + $m = \Upper_enum_value\NotAllowed::INT; + $m = \Upper_enum_value\NotAllowed::FLOAT; + $m = \Upper_enum_value\NotAllowed::BOOL; + $m = \Upper_enum_value\NotAllowed::STRING; + $m = \Upper_enum_value\NotAllowed::TRUE; + $m = \Upper_enum_value\NotAllowed::FALSE; + $m = \Upper_enum_value\NotAllowed::NULL; + $m = \Upper_enum_value\NotAllowed::VOID; + $m = \Upper_enum_value\NotAllowed::ITERABLE; + } + + ######################################################### + # Test fluent setters. + ######################################################### + + public function testFluentSetters() + { + $m = (new TestMessage()) + ->setOptionalInt32(1) + ->setOptionalUInt32(2); + $this->assertSame(1, $m->getOptionalInt32()); + $this->assertSame(2, $m->getOptionalUInt32()); + } + + ######################################################### + # Test Reverse Field Order. + ######################################################### + + public function testReverseFieldOrder() + { + $m = new TestReverseFieldOrder(); + $m->setB("abc"); + $this->assertSame("abc", $m->getB()); + $this->assertNotSame("abc", $m->getA()); + } + + ######################################################### + # Test Reverse Field Order. + ######################################################### + + public function testLowerCase() + { + $m = new testLowerCaseMessage(); + $n = testLowerCaseEnum::VALUE; + } + + ######################################################### + # Test Array Constructor. + ######################################################### + + public function testArrayConstructor() { - $m = new NoNameSpaceEnum(); + $m = new TestMessage([ + 'optional_int32' => -42, + 'optional_int64' => -43, + 'optional_uint32' => 42, + 'optional_uint64' => 43, + 'optional_sint32' => -44, + 'optional_sint64' => -45, + 'optional_fixed32' => 46, + 'optional_fixed64' => 47, + 'optional_sfixed32' => -46, + 'optional_sfixed64' => -47, + 'optional_float' => 1.5, + 'optional_double' => 1.6, + 'optional_bool' => true, + 'optional_string' => 'a', + 'optional_bytes' => 'b', + 'optional_enum' => TestEnum::ONE, + 'optional_message' => new Sub([ + 'a' => 33 + ]), + 'repeated_int32' => [-42, -52], + 'repeated_int64' => [-43, -53], + 'repeated_uint32' => [42, 52], + 'repeated_uint64' => [43, 53], + 'repeated_sint32' => [-44, -54], + 'repeated_sint64' => [-45, -55], + 'repeated_fixed32' => [46, 56], + 'repeated_fixed64' => [47, 57], + 'repeated_sfixed32' => [-46, -56], + 'repeated_sfixed64' => [-47, -57], + 'repeated_float' => [1.5, 2.5], + 'repeated_double' => [1.6, 2.6], + 'repeated_bool' => [true, false], + 'repeated_string' => ['a', 'c'], + 'repeated_bytes' => ['b', 'd'], + 'repeated_enum' => [TestEnum::ZERO, TestEnum::ONE], + 'repeated_message' => [new Sub(['a' => 34]), + new Sub(['a' => 35])], + 'map_int32_int32' => [-62 => -62], + 'map_int64_int64' => [-63 => -63], + 'map_uint32_uint32' => [62 => 62], + 'map_uint64_uint64' => [63 => 63], + 'map_sint32_sint32' => [-64 => -64], + 'map_sint64_sint64' => [-65 => -65], + 'map_fixed32_fixed32' => [66 => 66], + 'map_fixed64_fixed64' => [67 => 67], + 'map_sfixed32_sfixed32' => [-68 => -68], + 'map_sfixed64_sfixed64' => [-69 => -69], + 'map_int32_float' => [1 => 3.5], + 'map_int32_double' => [1 => 3.6], + 'map_bool_bool' => [true => true], + 'map_string_string' => ['e' => 'e'], + 'map_int32_bytes' => [1 => 'f'], + 'map_int32_enum' => [1 => TestEnum::ONE], + 'map_int32_message' => [1 => new Sub(['a' => 36])], + ]); + + TestUtil::assertTestMessage($m); } } |