aboutsummaryrefslogtreecommitdiffhomepage
path: root/php/tests/php_implementation_test.php
diff options
context:
space:
mode:
Diffstat (limited to 'php/tests/php_implementation_test.php')
-rw-r--r--php/tests/php_implementation_test.php443
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());
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-30 22:50:58 +0000