diff options
author | Paul Yang <TeBoring@users.noreply.github.com> | 2016-09-15 11:09:01 -0700 |
---|---|---|
committer | GitHub <noreply@github.com> | 2016-09-15 11:09:01 -0700 |
commit | e0e54661f76183684dca66694967a60cbb10f04e (patch) | |
tree | 0a2a20f984705fdf6ef13de8829901b80f88efb5 /php/tests/php_implementation_test.php | |
parent | 86fcd879b38505446799b2f2a2929415ddad620a (diff) | |
download | protobuf-e0e54661f76183684dca66694967a60cbb10f04e.tar.gz protobuf-e0e54661f76183684dca66694967a60cbb10f04e.tar.bz2 protobuf-e0e54661f76183684dca66694967a60cbb10f04e.zip |
Check in php implementation. (#2052)
This pull request includes two implementation: C extension and PHP
package. Both implementations support encode/decode of singular,
repeated and map fields.
Diffstat (limited to 'php/tests/php_implementation_test.php')
-rw-r--r-- | php/tests/php_implementation_test.php | 443 |
1 files changed, 443 insertions, 0 deletions
diff --git a/php/tests/php_implementation_test.php b/php/tests/php_implementation_test.php new file mode 100644 index 00000000..82941dd2 --- /dev/null +++ b/php/tests/php_implementation_test.php @@ -0,0 +1,443 @@ +<?php + +require_once('test.pb.php'); +require_once('test_base.php'); +require_once('test_util.php'); + +use Foo\TestMessage; +use Foo\TestMessage_Sub; +use Foo\TestPackedMessage; +use Google\Protobuf\Internal\InputStream; +use Google\Protobuf\Internal\FileDescriptorSet; +use Google\Protobuf\Internal\GPBUtil; +use Google\Protobuf\Internal\Int64; +use Google\Protobuf\Internal\Uint64; +use Google\Protobuf\Internal\GPBLabel; +use Google\Protobuf\Internal\GPBType; +use Google\Protobuf\Internal\GPBWire; +use Google\Protobuf\Internal\OutputStream; +use Google\Protobuf\Internal\RepeatedField; + +class ImplementationTest extends TestBase +{ + + public function testReadInt32() + { + $value = null; + + // Positive number. + $input = new InputStream(hex2bin("01")); + GPBWire::readInt32($input, $value); + $this->assertSame(1, $value); + + // Negative number. + $input = new InputStream(hex2bin("ffffffff0f")); + GPBWire::readInt32($input, $value); + $this->assertSame(-1, $value); + + // Discard overflow bits. + $input = new InputStream(hex2bin("ffffffff7f")); + GPBWire::readInt32($input, $value); + $this->assertSame(-1, $value); + } + + public function testReadUint32() + { + $value = null; + + // Positive number. + $input = new InputStream(hex2bin("01")); + GPBWire::readUint32($input, $value); + $this->assertSame(1, $value); + + // Max uint32. + $input = new InputStream(hex2bin("ffffffff0f")); + GPBWire::readUint32($input, $value); + $this->assertSame(-1, $value); + + // Discard overflow bits. + $input = new InputStream(hex2bin("ffffffff7f")); + GPBWire::readUint32($input, $value); + $this->assertSame(-1, $value); + } + + public function testReadInt64() + { + $value = null; + + // Positive number. + $input = new InputStream(hex2bin("01")); + GPBWire::readInt64($input, $value); + $this->assertSame(1, $value->toInteger()); + + // Negative number. + $input = new InputStream(hex2bin("ffffffffffffffffff01")); + GPBWire::readInt64($input, $value); + $this->assertSame(-1, $value->toInteger()); + + // Discard overflow bits. + $input = new InputStream(hex2bin("ffffffffffffffffff0f")); + GPBWire::readInt64($input, $value); + $this->assertSame(-1, $value->toInteger()); + } + + public function testReadUint64() + { + $value = null; + + // Positive number. + $input = new InputStream(hex2bin("01")); + GPBWire::readUint64($input, $value); + $this->assertSame(1, $value->toInteger()); + + // Negative number. + $input = new InputStream(hex2bin("FFFFFFFFFFFFFFFFFF01")); + GPBWire::readUint64($input, $value); + $this->assertSame(-1, $value->toInteger()); + + // Discard overflow bits. + $input = new InputStream(hex2bin("FFFFFFFFFFFFFFFFFF0F")); + GPBWire::readUint64($input, $value); + $this->assertSame(-1, $value->toInteger()); + } + + public function testReadSint32() + { + $value = null; + + $input = new InputStream(hex2bin("00")); + GPBWire::readSint32($input, $value); + $this->assertSame(0, $value); + + $input = new InputStream(hex2bin("01")); + GPBWire::readSint32($input, $value); + $this->assertSame(-1, $value); + + $input = new InputStream(hex2bin("02")); + GPBWire::readSint32($input, $value); + $this->assertSame(1, $value); + } + + public function testReadSint64() + { + $value = null; + + $input = new InputStream(hex2bin("00")); + GPBWire::readSint64($input, $value); + $this->assertEquals(GPBUtil::Int64(0), $value); + + $input = new InputStream(hex2bin("01")); + GPBWire::readSint64($input, $value); + $this->assertEquals(GPBUtil::Int64(-1), $value); + + $input = new InputStream(hex2bin("02")); + GPBWire::readSint64($input, $value); + $this->assertEquals(GPBUtil::Int64(1), $value); + } + + public function testReadFixed32() + { + $value = null; + $input = new InputStream(hex2bin("12345678")); + GPBWire::readFixed32($input, $value); + $this->assertSame(0x78563412, $value); + } + + public function testReadFixed64() + { + $value = null; + $input = new InputStream(hex2bin("1234567812345678")); + GPBWire::readFixed64($input, $value); + $this->assertEquals(Uint64::newValue(0x78563412, 0x78563412), $value); + } + + public function testReadSfixed32() + { + $value = null; + $input = new InputStream(hex2bin("12345678")); + GPBWire::readSfixed32($input, $value); + $this->assertSame(0x78563412, $value); + } + + public function testReadFloat() + { + $value = null; + $input = new InputStream(hex2bin("0000803F")); + GPBWire::readFloat($input, $value); + $this->assertSame(1.0, $value); + } + + public function testReadBool() + { + $value = null; + + $input = new InputStream(hex2bin("00")); + GPBWire::readBool($input, $value); + $this->assertSame(false, $value); + + $input = new InputStream(hex2bin("01")); + GPBWire::readBool($input, $value); + $this->assertSame(true, $value); + } + + public function testReadDouble() + { + $value = null; + $input = new InputStream(hex2bin("000000000000F03F")); + GPBWire::readDouble($input, $value); + $this->assertSame(1.0, $value); + } + + public function testReadSfixed64() + { + $value = null; + $input = new InputStream(hex2bin("1234567812345678")); + GPBWire::readSfixed64($input, $value); + $this->assertEquals(Int64::newValue(0x78563412, 0x78563412), $value); + } + + public function testZigZagEncodeDecode() + { + $this->assertSame(0, GPBWire::zigZagEncode32(0)); + $this->assertSame(1, GPBWire::zigZagEncode32(-1)); + $this->assertSame(2, GPBWire::zigZagEncode32(1)); + $this->assertSame(3, GPBWire::zigZagEncode32(-2)); + $this->assertSame(0x7FFFFFFE, GPBWire::zigZagEncode32(0x3FFFFFFF)); + $this->assertSame(0x7FFFFFFF, GPBWire::zigZagEncode32(0xC0000000)); + $this->assertSame(-2, GPBWire::zigZagEncode32(0x7FFFFFFF)); + $this->assertSame(-1, GPBWire::zigZagEncode32(0x80000000)); + + $this->assertSame(0, GPBWire::zigZagDecode32(0)); + $this->assertSame(-1, GPBWire::zigZagDecode32(1)); + $this->assertSame(1, GPBWire::zigZagDecode32(2)); + $this->assertSame(-2, GPBWire::zigZagDecode32(3)); + $this->assertSame(0x3FFFFFFF, GPBWire::zigZagDecode32(0x7FFFFFFE)); + $this->assertSame(-1073741824, GPBWire::zigZagDecode32(0x7FFFFFFF)); + $this->assertSame(0x7FFFFFFF, GPBWire::zigZagDecode32(0xFFFFFFFE)); + $this->assertSame(-2147483648, GPBWire::zigZagDecode32(0xFFFFFFFF)); + + $this->assertEquals(GPBUtil::Uint64(0), + GPBWire::zigZagEncode64(GPBUtil::Int64(0))); + $this->assertEquals(GPBUtil::Uint64(1), + GPBWire::zigZagEncode64(GPBUtil::Int64(-1))); + $this->assertEquals(GPBUtil::Uint64(2), + GPBWire::zigZagEncode64(GPBUtil::Int64(1))); + $this->assertEquals(GPBUtil::Uint64(3), + GPBWire::zigZagEncode64(GPBUtil::Int64(-2))); + $this->assertEquals( + GPBUtil::Uint64(0x000000007FFFFFFE), + GPBWire::zigZagEncode64(GPBUtil::Int64(0x000000003FFFFFFF))); + $this->assertEquals( + GPBUtil::Uint64(0x000000007FFFFFFF), + GPBWire::zigZagEncode64(GPBUtil::Int64(0xFFFFFFFFC0000000))); + $this->assertEquals( + GPBUtil::Uint64(0x00000000FFFFFFFE), + GPBWire::zigZagEncode64(GPBUtil::Int64(0x000000007FFFFFFF))); + $this->assertEquals( + GPBUtil::Uint64(0x00000000FFFFFFFF), + GPBWire::zigZagEncode64(GPBUtil::Int64(0xFFFFFFFF80000000))); + $this->assertEquals( + Uint64::newValue(4294967295, 4294967294), + GPBWire::zigZagEncode64(GPBUtil::Int64(0x7FFFFFFFFFFFFFFF))); + $this->assertEquals( + Uint64::newValue(4294967295, 4294967295), + GPBWire::zigZagEncode64(GPBUtil::Int64(0x8000000000000000))); + + $this->assertEquals(GPBUtil::Int64(0), + GPBWire::zigZagDecode64(GPBUtil::Uint64(0))); + $this->assertEquals(GPBUtil::Int64(-1), + GPBWire::zigZagDecode64(GPBUtil::Uint64(1))); + $this->assertEquals(GPBUtil::Int64(1), + GPBWire::zigZagDecode64(GPBUtil::Uint64(2))); + $this->assertEquals(GPBUtil::Int64(-2), + GPBWire::zigZagDecode64(GPBUtil::Uint64(3))); + + // Round trip + $this->assertSame(0, GPBWire::zigZagDecode32(GPBWire::zigZagEncode32(0))); + $this->assertSame(1, GPBWire::zigZagDecode32(GPBWire::zigZagEncode32(1))); + $this->assertSame(-1, GPBWire::zigZagDecode32(GPBWire::zigZagEncode32(-1))); + $this->assertSame(14927, + GPBWire::zigZagDecode32(GPBWire::zigZagEncode32(14927))); + $this->assertSame(-3612, + GPBWire::zigZagDecode32(GPBWire::zigZagEncode32(-3612))); + } + + public function testDecode() + { + $m = new TestMessage(); + $m->decode(TestUtil::getGoldenTestMessage()); + TestUtil::assertTestMessage($m); + } + + public function testDescriptorDecode() + { + $file_desc_set = new FileDescriptorSet(); + $file_desc_set->decode(hex2bin( + "0a3b0a12746573745f696e636c7564652e70726f746f120362617222180a" . + "0b54657374496e636c75646512090a0161180120012805620670726f746f33")); + + $this->assertSame(1, sizeof($file_desc_set->getFile())); + + $file_desc = $file_desc_set->getFile()[0]; + $this->assertSame("test_include.proto", $file_desc->getName()); + $this->assertSame("bar", $file_desc->getPackage()); + $this->assertSame(0, sizeof($file_desc->getDependency())); + $this->assertSame(1, sizeof($file_desc->getMessageType())); + $this->assertSame(0, sizeof($file_desc->getEnumType())); + $this->assertSame("proto3", $file_desc->getSyntax()); + + $desc = $file_desc->getMessageType()[0]; + $this->assertSame("TestInclude", $desc->getName()); + $this->assertSame(1, sizeof($desc->getField())); + $this->assertSame(0, sizeof($desc->getNestedType())); + $this->assertSame(0, sizeof($desc->getEnumType())); + $this->assertSame(0, sizeof($desc->getOneofDecl())); + + $field = $desc->getField()[0]; + $this->assertSame("a", $field->getName()); + $this->assertSame(1, $field->getNumber()); + $this->assertSame(GPBLabel::OPTIONAL, $field->getLabel()); + $this->assertSame(GPBType::INT32, $field->getType()); + } + + public function testReadVarint64() + { + $var = 0; + + // Empty buffer. + $input = new InputStream(hex2bin('')); + $this->assertFalse($input->readVarint64($var)); + + // The largest varint is 10 bytes long. + $input = new InputStream(hex2bin('8080808080808080808001')); + $this->assertFalse($input->readVarint64($var)); + + // Corrupted varint. + $input = new InputStream(hex2bin('808080')); + $this->assertFalse($input->readVarint64($var)); + + // Normal case. + $input = new InputStream(hex2bin('808001')); + $this->assertTrue($input->readVarint64($var)); + $this->assertSame(16384, $var->toInteger()); + $this->assertFalse($input->readVarint64($var)); + + // Read two varint. + $input = new InputStream(hex2bin('808001808002')); + $this->assertTrue($input->readVarint64($var)); + $this->assertSame(16384, $var->toInteger()); + $this->assertTrue($input->readVarint64($var)); + $this->assertSame(32768, $var->toInteger()); + $this->assertFalse($input->readVarint64($var)); + } + + public function testReadVarint32() + { + $var = 0; + + // Empty buffer. + $input = new InputStream(hex2bin('')); + $this->assertFalse($input->readVarint32($var)); + + // The largest varint is 10 bytes long. + $input = new InputStream(hex2bin('8080808080808080808001')); + $this->assertFalse($input->readVarint32($var)); + + // Corrupted varint. + $input = new InputStream(hex2bin('808080')); + $this->assertFalse($input->readVarint32($var)); + + // Normal case. + $input = new InputStream(hex2bin('808001')); + $this->assertTrue($input->readVarint32($var)); + $this->assertSame(16384, $var); + $this->assertFalse($input->readVarint32($var)); + + // Read two varint. + $input = new InputStream(hex2bin('808001808002')); + $this->assertTrue($input->readVarint32($var)); + $this->assertSame(16384, $var); + $this->assertTrue($input->readVarint32($var)); + $this->assertSame(32768, $var); + $this->assertFalse($input->readVarint32($var)); + + // Read a 64-bit integer. High-order bits should be discarded. + $input = new InputStream(hex2bin('808081808001')); + $this->assertTrue($input->readVarint32($var)); + $this->assertSame(16384, $var); + $this->assertFalse($input->readVarint32($var)); + } + + public function testReadTag() + { + $input = new InputStream(hex2bin('808001')); + $tag = $input->readTag(); + $this->assertSame(16384, $tag); + $tag = $input->readTag(); + $this->assertSame(0, $tag); + } + + public function testPushPopLimit() + { + $input = new InputStream(hex2bin('808001')); + $old_limit = $input->pushLimit(0); + $tag = $input->readTag(); + $this->assertSame(0, $tag); + $input->popLimit($old_limit); + $tag = $input->readTag(); + $this->assertSame(16384, $tag); + } + + public function testReadRaw() + { + $input = new InputStream(hex2bin('808001')); + $buffer = null; + + $this->assertTrue($input->readRaw(3, $buffer)); + $this->assertSame(hex2bin('808001'), $buffer); + + $this->assertFalse($input->readRaw(1, $buffer)); + } + + public function testWriteVarint32() + { + $output = new OutputStream(3); + $output->writeVarint32(16384); + $this->assertSame(hex2bin('808001'), $output->getData()); + } + + public function testWriteVarint64() + { + $output = new OutputStream(10); + $output->writeVarint64(-43); + $this->assertSame(hex2bin('D5FFFFFFFFFFFFFFFF01'), $output->getData()); + } + + public function testWriteLittleEndian32() + { + $output = new OutputStream(4); + $output->writeLittleEndian32(46); + $this->assertSame(hex2bin('2E000000'), $output->getData()); + } + + public function testWriteLittleEndian64() + { + $output = new OutputStream(8); + $output->writeLittleEndian64(47); + $this->assertSame(hex2bin('2F00000000000000'), $output->getData()); + } + + public function testByteSize() + { + $m = new TestMessage(); + TestUtil::setTestMessage($m); + $this->assertSame(447, $m->byteSize()); + } + + public function testPackedByteSize() + { + $m = new TestPackedMessage(); + TestUtil::setTestPackedMessage($m); + $this->assertSame(156, $m->byteSize()); + } +} |