Chiebot-Mirror
/
protobuf
mirror of https://github.com/protocolbuffers/protobuf.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Uncomment php tests (#3301)

Browse Source
pull/3291/merge
Paul Yang 8 years ago committed by GitHub
parent bd5ab154da
commit b9c4daadf7
2 changed files with 416 additions and 416 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      php/ext/google/protobuf/encode_decode.c
  2. 830
      php/tests/encode_decode_test.php

2
php/ext/google/protobuf/encode_decode.c
Unescape View File

@ -474,7 +474,7 @@ static void map_slot_init(void* memory, upb_fieldtype_t type, zval* cache) {
*(zval***)memory = holder; *(zval***)memory = holder;
#else #else
*(zval**)memory = cache; *(zval**)memory = cache;
// PHP_PROTO_ZVAL_STRINGL(*(zval**)memory, "", 0, 1); PHP_PROTO_ZVAL_STRINGL(*(zval**)memory, "", 0, 1);
#endif #endif
break; break;
} }

830
php/tests/encode_decode_test.php
Unescape View File

@ -14,432 +14,432 @@ use Foo\TestUnpackedMessage;
class EncodeDecodeTest extends TestBase class EncodeDecodeTest extends TestBase
{ {
# public function testEncode() public function testEncode()
# { {
# $from = new TestMessage(); $from = new TestMessage();
# $this->expectEmptyFields($from); $this->expectEmptyFields($from);
# $this->setFields($from); $this->setFields($from);
# $this->expectFields($from); $this->expectFields($from);
#
# $data = $from->serializeToString(); $data = $from->serializeToString();
# $this->assertSame(bin2hex(TestUtil::getGoldenTestMessage()), $this->assertSame(bin2hex(TestUtil::getGoldenTestMessage()),
# bin2hex($data)); bin2hex($data));
# } }
#
# public function testDecode() public function testDecode()
# { {
# $to = new TestMessage(); $to = new TestMessage();
# $to->mergeFromString(TestUtil::getGoldenTestMessage()); $to->mergeFromString(TestUtil::getGoldenTestMessage());
# $this->expectFields($to); $this->expectFields($to);
# } }
#
# public function testEncodeDecode() public function testEncodeDecode()
# { {
# $from = new TestMessage(); $from = new TestMessage();
# $this->expectEmptyFields($from); $this->expectEmptyFields($from);
# $this->setFields($from); $this->setFields($from);
# $this->expectFields($from); $this->expectFields($from);
#
# $data = $from->serializeToString(); $data = $from->serializeToString();
#
# $to = new TestMessage(); $to = new TestMessage();
# $to->mergeFromString($data); $to->mergeFromString($data);
# $this->expectFields($to); $this->expectFields($to);
# } }
#
# public function testEncodeDecodeEmpty() public function testEncodeDecodeEmpty()
# { {
# $from = new TestMessage(); $from = new TestMessage();
# $this->expectEmptyFields($from); $this->expectEmptyFields($from);
#
# $data = $from->serializeToString(); $data = $from->serializeToString();
#
# $to = new TestMessage(); $to = new TestMessage();
# $to->mergeFromString($data); $to->mergeFromString($data);
# $this->expectEmptyFields($to); $this->expectEmptyFields($to);
# } }
public function testEncodeDecodeOneof() public function testEncodeDecodeOneof()
{ {
$m = new TestMessage(); $m = new TestMessage();
# $m->setOneofInt32(1); $m->setOneofInt32(1);
# $data = $m->serializeToString(); $data = $m->serializeToString();
# $n = new TestMessage(); $n = new TestMessage();
# $n->mergeFromString($data); $n->mergeFromString($data);
# $this->assertSame(1, $n->getOneofInt32()); $this->assertSame(1, $n->getOneofInt32());
#
# $m->setOneofFloat(2.0); $m->setOneofFloat(2.0);
# $data = $m->serializeToString(); $data = $m->serializeToString();
# $n = new TestMessage(); $n = new TestMessage();
# $n->mergeFromString($data); $n->mergeFromString($data);
# $this->assertSame(2.0, $n->getOneofFloat()); $this->assertSame(2.0, $n->getOneofFloat());
#
# $m->setOneofString('abc'); $m->setOneofString('abc');
# $data = $m->serializeToString(); $data = $m->serializeToString();
# $n = new TestMessage(); $n = new TestMessage();
# $n->mergeFromString($data); $n->mergeFromString($data);
# $this->assertSame('abc', $n->getOneofString()); $this->assertSame('abc', $n->getOneofString());
#
# $sub_m = new TestMessage_Sub(); $sub_m = new TestMessage_Sub();
# $sub_m->setA(1); $sub_m->setA(1);
# $m->setOneofMessage($sub_m); $m->setOneofMessage($sub_m);
# $data = $m->serializeToString(); $data = $m->serializeToString();
# $n = new TestMessage(); $n = new TestMessage();
# $n->mergeFromString($data); $n->mergeFromString($data);
# $this->assertSame(1, $n->getOneofMessage()->getA()); $this->assertSame(1, $n->getOneofMessage()->getA());
// Encode default value // Encode default value
# $m->setOneofEnum(TestEnum::ZERO); $m->setOneofEnum(TestEnum::ZERO);
# $data = $m->serializeToString(); $data = $m->serializeToString();
# $n = new TestMessage(); $n = new TestMessage();
# $n->mergeFromString($data); $n->mergeFromString($data);
# $this->assertSame("oneof_enum", $n->getMyOneof()); $this->assertSame("oneof_enum", $n->getMyOneof());
# $this->assertSame(TestEnum::ZERO, $n->getOneofEnum()); $this->assertSame(TestEnum::ZERO, $n->getOneofEnum());
$m->setOneofString(""); $m->setOneofString("");
$data = $m->serializeToString(); $data = $m->serializeToString();
$n = new TestMessage(); $n = new TestMessage();
$n->mergeFromString($data); $n->mergeFromString($data);
$this->assertSame("oneof_string", $n->getMyOneof()); $this->assertSame("oneof_string", $n->getMyOneof());
$this->assertSame("", $n->getOneofString()); $this->assertSame("", $n->getOneofString());
# $sub_m = new TestMessage_Sub(); $sub_m = new TestMessage_Sub();
# $m->setOneofMessage($sub_m); $m->setOneofMessage($sub_m);
# $data = $m->serializeToString(); $data = $m->serializeToString();
# $n = new TestMessage(); $n = new TestMessage();
# $n->mergeFromString($data); $n->mergeFromString($data);
# $this->assertSame("oneof_message", $n->getMyOneof()); $this->assertSame("oneof_message", $n->getMyOneof());
# $this->assertFalse(is_null($n->getOneofMessage())); $this->assertFalse(is_null($n->getOneofMessage()));
} }
# public function testPackedEncode() public function testPackedEncode()
# { {
# $from = new TestPackedMessage(); $from = new TestPackedMessage();
# TestUtil::setTestPackedMessage($from); TestUtil::setTestPackedMessage($from);
# $this->assertSame(TestUtil::getGoldenTestPackedMessage(), $this->assertSame(TestUtil::getGoldenTestPackedMessage(),
# $from->serializeToString()); $from->serializeToString());
# } }
#
# public function testPackedDecodePacked() public function testPackedDecodePacked()
# { {
# $to = new TestPackedMessage(); $to = new TestPackedMessage();
# $to->mergeFromString(TestUtil::getGoldenTestPackedMessage()); $to->mergeFromString(TestUtil::getGoldenTestPackedMessage());
# TestUtil::assertTestPackedMessage($to); TestUtil::assertTestPackedMessage($to);
# } }
#
# public function testPackedDecodeUnpacked() public function testPackedDecodeUnpacked()
# { {
# $to = new TestPackedMessage(); $to = new TestPackedMessage();
# $to->mergeFromString(TestUtil::getGoldenTestUnpackedMessage()); $to->mergeFromString(TestUtil::getGoldenTestUnpackedMessage());
# TestUtil::assertTestPackedMessage($to); TestUtil::assertTestPackedMessage($to);
# } }
#
# public function testUnpackedEncode() public function testUnpackedEncode()
# { {
# $from = new TestUnpackedMessage(); $from = new TestUnpackedMessage();
# TestUtil::setTestPackedMessage($from); TestUtil::setTestPackedMessage($from);
# $this->assertSame(TestUtil::getGoldenTestUnpackedMessage(), $this->assertSame(TestUtil::getGoldenTestUnpackedMessage(),
# $from->serializeToString()); $from->serializeToString());
# } }
#
# public function testUnpackedDecodePacked() public function testUnpackedDecodePacked()
# { {
# $to = new TestUnpackedMessage(); $to = new TestUnpackedMessage();
# $to->mergeFromString(TestUtil::getGoldenTestPackedMessage()); $to->mergeFromString(TestUtil::getGoldenTestPackedMessage());
# TestUtil::assertTestPackedMessage($to); TestUtil::assertTestPackedMessage($to);
# } }
#
# public function testUnpackedDecodeUnpacked() public function testUnpackedDecodeUnpacked()
# { {
# $to = new TestUnpackedMessage(); $to = new TestUnpackedMessage();
# $to->mergeFromString(TestUtil::getGoldenTestUnpackedMessage()); $to->mergeFromString(TestUtil::getGoldenTestUnpackedMessage());
# TestUtil::assertTestPackedMessage($to); TestUtil::assertTestPackedMessage($to);
# } }
#
# public function testDecodeInt64() public function testDecodeInt64()
# { {
# // Read 64 testing // Read 64 testing
# $testVals = array( $testVals = array(
# '10' => '100a', '10' => '100a',
# '100' => '1064', '100' => '1064',
# '800' => '10a006', '800' => '10a006',
# '6400' => '108032', '6400' => '108032',
# '70400' => '1080a604', '70400' => '1080a604',
# '774400' => '1080a22f', '774400' => '1080a22f',
# '9292800' => '108098b704', '9292800' => '108098b704',
# '74342400' => '1080c0b923', '74342400' => '1080c0b923',
# '743424000' => '108080bfe202', '743424000' => '108080bfe202',
# '8177664000' => '108080b5bb1e', '8177664000' => '108080b5bb1e',
# '65421312000' => '108080a8dbf301', '65421312000' => '108080a8dbf301',
# '785055744000' => '108080e0c7ec16', '785055744000' => '108080e0c7ec16',
# '9420668928000' => '10808080dd969202', '9420668928000' => '10808080dd969202',
# '103627358208000' => '10808080fff9c717', '103627358208000' => '10808080fff9c717',
# '1139900940288000' => '10808080f5bd978302', '1139900940288000' => '10808080f5bd978302',
# '13678811283456000' => '10808080fce699a618', '13678811283456000' => '10808080fce699a618',
# '109430490267648000' => '10808080e0b7ceb1c201', '109430490267648000' => '10808080e0b7ceb1c201',
# '984874412408832000' => '10808080e0f5c1bed50d', '984874412408832000' => '10808080e0f5c1bed50d',
# ); );
#
# $msg = new TestMessage(); $msg = new TestMessage();
# foreach ($testVals as $original => $encoded) { foreach ($testVals as $original => $encoded) {
# $msg->setOptionalInt64($original); $msg->setOptionalInt64($original);
# $data = $msg->serializeToString(); $data = $msg->serializeToString();
# $this->assertSame($encoded, bin2hex($data)); $this->assertSame($encoded, bin2hex($data));
# $msg->setOptionalInt64(0); $msg->setOptionalInt64(0);
# $msg->mergeFromString($data); $msg->mergeFromString($data);
# $this->assertEquals($original, $msg->getOptionalInt64()); $this->assertEquals($original, $msg->getOptionalInt64());
# } }
# } }
#
# public function testDecodeToExistingMessage() public function testDecodeToExistingMessage()
# { {
# $m1 = new TestMessage(); $m1 = new TestMessage();
# $this->setFields($m1); $this->setFields($m1);
# $this->expectFields($m1); $this->expectFields($m1);
#
# $m2 = new TestMessage(); $m2 = new TestMessage();
# $this->setFields2($m2); $this->setFields2($m2);
# $data = $m2->serializeToString(); $data = $m2->serializeToString();
#
# $m1->mergeFromString($data); $m1->mergeFromString($data);
# $this->expectFieldsMerged($m1); $this->expectFieldsMerged($m1);
# } }
#
# public function testDecodeFieldNonExist() public function testDecodeFieldNonExist()
# { {
# $data = hex2bin('c80501'); $data = hex2bin('c80501');
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString($data); $m->mergeFromString($data);
# } }
#
# public function testEncodeNegativeInt32() public function testEncodeNegativeInt32()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->setOptionalInt32(-1); $m->setOptionalInt32(-1);
# $data = $m->serializeToString(); $data = $m->serializeToString();
# $this->assertSame("08ffffffffffffffffff01", bin2hex($data)); $this->assertSame("08ffffffffffffffffff01", bin2hex($data));
# } }
#
# public function testDecodeNegativeInt32() public function testDecodeNegativeInt32()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $this->assertEquals(0, $m->getOptionalInt32()); $this->assertEquals(0, $m->getOptionalInt32());
# $m->mergeFromString(hex2bin("08ffffffffffffffffff01")); $m->mergeFromString(hex2bin("08ffffffffffffffffff01"));
# $this->assertEquals(-1, $m->getOptionalInt32()); $this->assertEquals(-1, $m->getOptionalInt32());
#
# $m = new TestMessage(); $m = new TestMessage();
# $this->assertEquals(0, $m->getOptionalInt32()); $this->assertEquals(0, $m->getOptionalInt32());
# $m->mergeFromString(hex2bin("08ffffffff0f")); $m->mergeFromString(hex2bin("08ffffffff0f"));
# $this->assertEquals(-1, $m->getOptionalInt32()); $this->assertEquals(-1, $m->getOptionalInt32());
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidInt32() public function testDecodeInvalidInt32()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('08')); $m->mergeFromString(hex2bin('08'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidSubMessage() public function testDecodeInvalidSubMessage()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('9A010108')); $m->mergeFromString(hex2bin('9A010108'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidInt64() public function testDecodeInvalidInt64()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('10')); $m->mergeFromString(hex2bin('10'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidUInt32() public function testDecodeInvalidUInt32()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('18')); $m->mergeFromString(hex2bin('18'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidUInt64() public function testDecodeInvalidUInt64()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('20')); $m->mergeFromString(hex2bin('20'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidSInt32() public function testDecodeInvalidSInt32()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('28')); $m->mergeFromString(hex2bin('28'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidSInt64() public function testDecodeInvalidSInt64()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('30')); $m->mergeFromString(hex2bin('30'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidFixed32() public function testDecodeInvalidFixed32()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('3D')); $m->mergeFromString(hex2bin('3D'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidFixed64() public function testDecodeInvalidFixed64()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('41')); $m->mergeFromString(hex2bin('41'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidSFixed32() public function testDecodeInvalidSFixed32()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('4D')); $m->mergeFromString(hex2bin('4D'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidSFixed64() public function testDecodeInvalidSFixed64()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('51')); $m->mergeFromString(hex2bin('51'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidFloat() public function testDecodeInvalidFloat()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('5D')); $m->mergeFromString(hex2bin('5D'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidDouble() public function testDecodeInvalidDouble()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('61')); $m->mergeFromString(hex2bin('61'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidBool() public function testDecodeInvalidBool()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('68')); $m->mergeFromString(hex2bin('68'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidStringLengthMiss() public function testDecodeInvalidStringLengthMiss()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('72')); $m->mergeFromString(hex2bin('72'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidStringDataMiss() public function testDecodeInvalidStringDataMiss()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('7201')); $m->mergeFromString(hex2bin('7201'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidBytesLengthMiss() public function testDecodeInvalidBytesLengthMiss()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('7A')); $m->mergeFromString(hex2bin('7A'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidBytesDataMiss() public function testDecodeInvalidBytesDataMiss()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('7A01')); $m->mergeFromString(hex2bin('7A01'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidEnum() public function testDecodeInvalidEnum()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('8001')); $m->mergeFromString(hex2bin('8001'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidMessageLengthMiss() public function testDecodeInvalidMessageLengthMiss()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('8A01')); $m->mergeFromString(hex2bin('8A01'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidMessageDataMiss() public function testDecodeInvalidMessageDataMiss()
# { {
# $m = new TestMessage(); $m = new TestMessage();
# $m->mergeFromString(hex2bin('8A0101')); $m->mergeFromString(hex2bin('8A0101'));
# } }
#
# /** /**
# * @expectedException Exception * @expectedException Exception
# */ */
# public function testDecodeInvalidPackedMessageLength() public function testDecodeInvalidPackedMessageLength()
# { {
# $m = new TestPackedMessage(); $m = new TestPackedMessage();
# $m->mergeFromString(hex2bin('D205')); $m->mergeFromString(hex2bin('D205'));
# } }
#
# public function testJsonEncode() public function testJsonEncode()
# { {
# $from = new TestMessage(); $from = new TestMessage();
# $this->setFields($from); $this->setFields($from);
# $data = $from->serializeToJsonString(); $data = $from->serializeToJsonString();
# $to = new TestMessage(); $to = new TestMessage();
# $to->mergeFromJsonString($data); $to->mergeFromJsonString($data);
# $this->expectFields($to); $this->expectFields($to);
# } }
} }

Write Preview
Loading…
Cancel
Save