third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/php/tests/php_implementation_test.php

Index: third_party/protobuf/php/tests/php_implementation_test.php
diff --git a/third_party/protobuf/php/tests/php_implementation_test.php b/third_party/protobuf/php/tests/php_implementation_test.php
new file mode 100644
index 0000000000000000000000000000000000000000..4f626f1c9b0cb6e973d4bd3265dceebd2e753ba2
--- /dev/null
+++ b/third_party/protobuf/php/tests/php_implementation_test.php
@@ -0,0 +1,480 @@
+<?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\GPBLabel;
+use Google\Protobuf\Internal\GPBType;
+use Google\Protobuf\Internal\GPBWire;
+use Google\Protobuf\Internal\OutputStream;
+
+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->assertEquals(1, $value);
+
+        // Negative number.
+        $input = new InputStream(hex2bin("ffffffffffffffffff01"));
+        GPBWire::readInt64($input, $value);
+        $this->assertEquals(-1, $value);
+
+        // Discard overflow bits.
+        $input = new InputStream(hex2bin("ffffffffffffffffff0f"));
+        GPBWire::readInt64($input, $value);
+        $this->assertEquals(-1, $value);
+    }
+
+    public function testReadUint64()
+    {
+        $value = null;
+
+        // Positive number.
+        $input = new InputStream(hex2bin("01"));
+        GPBWire::readUint64($input, $value);
+        $this->assertEquals(1, $value);
+
+        // Negative number.
+        $input = new InputStream(hex2bin("FFFFFFFFFFFFFFFFFF01"));
+        GPBWire::readUint64($input, $value);
+        $this->assertEquals(-1, $value);
+
+        // Discard overflow bits.
+        $input = new InputStream(hex2bin("FFFFFFFFFFFFFFFFFF0F"));
+        GPBWire::readUint64($input, $value);
+        $this->assertEquals(-1, $value);
+    }
+
+    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(0, $value);
+
+        $input = new InputStream(hex2bin("01"));
+        GPBWire::readSint64($input, $value);
+        $this->assertEquals(-1, $value);
+
+        $input = new InputStream(hex2bin("02"));
+        GPBWire::readSint64($input, $value);
+        $this->assertEquals(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);
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame("8671175386481439762", $value);
+        } else {
+            $this->assertSame(0x7856341278563412, $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);
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame("8671175386481439762", $value);
+        } else {
+            $this->assertSame(0x7856341278563412, $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((int)-2147483648,GPBWire::zigZagDecode32(0xFFFFFFFF));
+
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame('0', GPBWire::zigZagEncode64(0));
+            $this->assertSame('1', GPBWire::zigZagEncode64(-1));
+            $this->assertSame('2', GPBWire::zigZagEncode64(1));
+            $this->assertSame('3', GPBWire::zigZagEncode64(-2));
+            $this->assertSame(
+                '2147483646',  // 0x7FFFFFE
+                GPBWire::zigZagEncode64(0x3FFFFFFF));
+            $this->assertSame(
+                '2147483647',  // 0x7FFFFFF
+                GPBWire::zigZagEncode64(-1073741824));  // 0xFFFFFFFFC0000000
+            $this->assertSame(
+                '4294967294',                           // 0xFFFFFFFE
+                GPBWire::zigZagEncode64(2147483647));   // 0x7FFFFFFF
+            $this->assertSame(
+                '4294967295',                           // 0xFFFFFFFF
+                GPBWire::zigZagEncode64(-2147483648));  // 0xFFFFFFFF80000000
+            $this->assertSame(
+                '18446744073709551614',  // 0xFFFFFFFFFFFFFFFE
+                                         // 0x7FFFFFFFFFFFFFFF
+                GPBWire::zigZagEncode64("9223372036854775807"));
+            $this->assertSame(
+                '18446744073709551615',  // 0xFFFFFFFFFFFFFFFF
+                                         // 0x8000000000000000
+                GPBWire::zigZagEncode64("-9223372036854775808"));
+
+            $this->assertSame('0', GPBWire::zigZagDecode64(0));
+            $this->assertSame('-1', GPBWire::zigZagDecode64(1));
+            $this->assertSame('1', GPBWire::zigZagDecode64(2));
+            $this->assertSame('-2', GPBWire::zigZagDecode64(3));
+        } else {
+            $this->assertSame(0, GPBWire::zigZagEncode64(0));
+            $this->assertSame(1, GPBWire::zigZagEncode64(-1));
+            $this->assertSame(2, GPBWire::zigZagEncode64(1));
+            $this->assertSame(3, GPBWire::zigZagEncode64(-2));
+            $this->assertSame(0x7FFFFFFE, GPBWire::zigZagEncode64(0x3FFFFFFF));
+            $this->assertSame(
+                0x7FFFFFFF,
+                GPBWire::zigZagEncode64(0xFFFFFFFFC0000000));
+            $this->assertSame(
+                0xFFFFFFFE,
+                GPBWire::zigZagEncode64(0x7FFFFFFF));
+            $this->assertSame(
+                0xFFFFFFFF,
+                GPBWire::zigZagEncode64(0xFFFFFFFF80000000));
+            $this->assertSame(
+                -2,  // 0xFFFFFFFFFFFFFFFE
+                GPBWire::zigZagEncode64(0x7FFFFFFFFFFFFFFF));
+            $this->assertSame(
+                -1,  // 0xFFFFFFFFFFFFFFFF
+                GPBWire::zigZagEncode64(0x8000000000000000));
+
+            $this->assertSame(0, GPBWire::zigZagDecode64(0));
+            $this->assertSame(-1, GPBWire::zigZagDecode64(1));
+            $this->assertSame(1, GPBWire::zigZagDecode64(2));
+            $this->assertSame(-2, GPBWire::zigZagDecode64(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));
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame('16384', $var);
+        } else {
+            $this->assertSame(16384, $var);
+        }
+        $this->assertFalse($input->readVarint64($var));
+
+        // Read two varint.
+        $input = new InputStream(hex2bin('808001808002'));
+        $this->assertTrue($input->readVarint64($var));
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame('16384', $var);
+        } else {
+            $this->assertSame(16384, $var);
+        }
+        $this->assertTrue($input->readVarint64($var));
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame('32768', $var);
+        } else {
+            $this->assertSame(32768, $var);
+        }
+        $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());
+    }
+}