Fix pure php implementation for 32-bit machine. (#2282)

6 files changed, 364 insertions, 157 deletions

diff --git a/php/tests/array_test.php b/php/tests/array_test.php
index 09d4dc82..a118b54c 100644
--- a/php/tests/array_test.php
+++ b/php/tests/array_test.php
@@ -225,46 +225,68 @@ class RepeatedFieldTest extends PHPUnit_Framework_TestCase
 
         // Test append.
         $arr []= MAX_INT64;
-        $this->assertSame(MAX_INT64, $arr[0]);
         $arr []= MIN_INT64;
-        $this->assertEquals(MIN_INT64, $arr[1]);
-
         $arr []= 1.1;
-        $this->assertSame(1, $arr[2]);
-
         $arr []= '2';
-        $this->assertSame(2, $arr[3]);
         $arr []= '3.1';
-        $this->assertSame(3, $arr[4]);
         $arr []= MAX_INT64_STRING;
-        $this->assertSame(MAX_INT64, $arr[5]);
         $arr []= MIN_INT64_STRING;
-        $this->assertEquals(MIN_INT64, $arr[6]);
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame(MAX_INT64, $arr[0]);
+            $this->assertSame(MIN_INT64, $arr[1]);
+            $this->assertSame('1', $arr[2]);
+            $this->assertSame('2', $arr[3]);
+            $this->assertSame('3', $arr[4]);
+            $this->assertSame(MAX_INT64_STRING, $arr[5]);
+            $this->assertSame(MIN_INT64_STRING, $arr[6]);
+        } else {
+            $this->assertSame(MAX_INT64, $arr[0]);
+            $this->assertSame(MIN_INT64, $arr[1]);
+            $this->assertSame(1, $arr[2]);
+            $this->assertSame(2, $arr[3]);
+            $this->assertSame(3, $arr[4]);
+            $this->assertSame(MAX_INT64, $arr[5]);
+            $this->assertSame(MIN_INT64, $arr[6]);
+        }
+
 
         $this->assertEquals(7, count($arr));
 
         for ($i = 0; $i < count($arr); $i++) {
             $arr[$i] = 0;
-            $this->assertSame(0, $arr[$i]);
+            if (PHP_INT_SIZE == 4) {
+                $this->assertSame('0', $arr[$i]);
+            } else {
+                $this->assertSame(0, $arr[$i]);
+            }
         }
 
         // Test set.
         $arr [0]= MAX_INT64;
-        $this->assertSame(MAX_INT64, $arr[0]);
         $arr [1]= MIN_INT64;
-        $this->assertEquals(MIN_INT64, $arr[1]);
-
         $arr [2]= 1.1;
-        $this->assertSame(1, $arr[2]);
-
         $arr [3]= '2';
-        $this->assertSame(2, $arr[3]);
         $arr [4]= '3.1';
-        $this->assertSame(3, $arr[4]);
         $arr [5]= MAX_INT64_STRING;
-        $this->assertSame(MAX_INT64, $arr[5]);
         $arr [6]= MIN_INT64_STRING;
-        $this->assertEquals(MIN_INT64, $arr[6]);
+
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame(MAX_INT64_STRING, $arr[0]);
+            $this->assertSame(MIN_INT64_STRING, $arr[1]);
+            $this->assertSame('1', $arr[2]);
+            $this->assertSame('2', $arr[3]);
+            $this->assertSame('3', $arr[4]);
+            $this->assertSame(MAX_INT64_STRING, $arr[5]);
+            $this->assertEquals(MIN_INT64_STRING, $arr[6]);
+        } else {
+            $this->assertSame(MAX_INT64, $arr[0]);
+            $this->assertSame(MIN_INT64, $arr[1]);
+            $this->assertSame(1, $arr[2]);
+            $this->assertSame(2, $arr[3]);
+            $this->assertSame(3, $arr[4]);
+            $this->assertSame(MAX_INT64, $arr[5]);
+            $this->assertEquals(MIN_INT64, $arr[6]);
+        }
     }
 
     /**
@@ -315,38 +337,57 @@ class RepeatedFieldTest extends PHPUnit_Framework_TestCase
 
         // Test append.
         $arr []= MAX_UINT64;
-        $this->assertEquals(MAX_UINT64, $arr[0]);
-
         $arr []= 1.1;
-        $this->assertSame(1, $arr[1]);
-
         $arr []= '2';
-        $this->assertSame(2, $arr[2]);
         $arr []= '3.1';
-        $this->assertSame(3, $arr[3]);
         $arr []= MAX_UINT64_STRING;
-        $this->assertEquals(MAX_UINT64, $arr[4]);
 
-        $this->assertEquals(5, count($arr));
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame(MAX_UINT64_STRING, $arr[0]);
+            $this->assertSame('1', $arr[1]);
+            $this->assertSame('2', $arr[2]);
+            $this->assertSame('3', $arr[3]);
+            $this->assertSame(MAX_UINT64_STRING, $arr[4]);
+        } else {
+            $this->assertSame(MAX_UINT64, $arr[0]);
+            $this->assertSame(1, $arr[1]);
+            $this->assertSame(2, $arr[2]);
+            $this->assertSame(3, $arr[3]);
+            $this->assertSame(MAX_UINT64, $arr[4]);
+            $this->assertSame(5, count($arr));
+        }
+
+        $this->assertSame(5, count($arr));
 
         for ($i = 0; $i < count($arr); $i++) {
             $arr[$i] = 0;
-            $this->assertSame(0, $arr[$i]);
+            if (PHP_INT_SIZE == 4) {
+                $this->assertSame('0', $arr[$i]);
+            } else {
+                $this->assertSame(0, $arr[$i]);
+            }
         }
 
         // Test set.
         $arr [0]= MAX_UINT64;
-        $this->assertEquals(MAX_UINT64, $arr[0]);
-
         $arr [1]= 1.1;
-        $this->assertSame(1, $arr[1]);
-
         $arr [2]= '2';
-        $this->assertSame(2, $arr[2]);
         $arr [3]= '3.1';
-        $this->assertSame(3, $arr[3]);
         $arr [4]= MAX_UINT64_STRING;
-        $this->assertEquals(MAX_UINT64, $arr[4]);
+
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame(MAX_UINT64_STRING, $arr[0]);
+            $this->assertSame('1', $arr[1]);
+            $this->assertSame('2', $arr[2]);
+            $this->assertSame('3', $arr[3]);
+            $this->assertSame(MAX_UINT64_STRING, $arr[4]);
+        } else {
+            $this->assertSame(MAX_UINT64, $arr[0]);
+            $this->assertSame(1, $arr[1]);
+            $this->assertSame(2, $arr[2]);
+            $this->assertSame(3, $arr[3]);
+            $this->assertSame(MAX_UINT64, $arr[4]);
+        }
     }
 
     /**
diff --git a/php/tests/generated_class_test.php b/php/tests/generated_class_test.php
index d1a0bd51..b3ecd3a1 100644
--- a/php/tests/generated_class_test.php
+++ b/php/tests/generated_class_test.php
@@ -148,17 +148,40 @@ class GeneratedClassTest extends PHPUnit_Framework_TestCase
 
         // Set float.
         $m->setOptionalInt64(1.1);
-        $this->assertSame(1, $m->getOptionalInt64());
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame('1', $m->getOptionalInt64());
+        } else {
+            $this->assertSame(1, $m->getOptionalInt64());
+        }
 
         // Set string.
         $m->setOptionalInt64('2');
-        $this->assertSame(2, $m->getOptionalInt64());
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame('2', $m->getOptionalInt64());
+        } else {
+            $this->assertSame(2, $m->getOptionalInt64());
+        }
+
         $m->setOptionalInt64('3.1');
-        $this->assertSame(3, $m->getOptionalInt64());
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame('3', $m->getOptionalInt64());
+        } else {
+            $this->assertSame(3, $m->getOptionalInt64());
+        }
+
         $m->setOptionalInt64(MAX_INT64_STRING);
-        $this->assertSame(MAX_INT64, $m->getOptionalInt64());
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame(MAX_INT64_STRING, $m->getOptionalInt64());
+        } else {
+            $this->assertSame(MAX_INT64, $m->getOptionalInt64());
+        }
+
         $m->setOptionalInt64(MIN_INT64_STRING);
-        $this->assertEquals(MIN_INT64, $m->getOptionalInt64());
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame(MIN_INT64_STRING, $m->getOptionalInt64());
+        } else {
+            $this->assertSame(MIN_INT64, $m->getOptionalInt64());
+        }
     }
 
     /**
@@ -189,19 +212,41 @@ class GeneratedClassTest extends PHPUnit_Framework_TestCase
 
         // Set integer.
         $m->setOptionalUint64(MAX_UINT64);
-        $this->assertEquals(MAX_UINT64, $m->getOptionalUint64());
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame(MAX_UINT64_STRING, $m->getOptionalUint64());
+        } else {
+            $this->assertSame(MAX_UINT64, $m->getOptionalUint64());
+        }
 
         // Set float.
         $m->setOptionalUint64(1.1);
-        $this->assertSame(1, $m->getOptionalUint64());
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame('1', $m->getOptionalUint64());
+        } else {
+            $this->assertSame(1, $m->getOptionalUint64());
+        }
 
         // Set string.
         $m->setOptionalUint64('2');
-        $this->assertSame(2, $m->getOptionalUint64());
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame('2', $m->getOptionalUint64());
+        } else {
+            $this->assertSame(2, $m->getOptionalUint64());
+        }
+
         $m->setOptionalUint64('3.1');
-        $this->assertSame(3, $m->getOptionalUint64());
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame('3', $m->getOptionalUint64());
+        } else {
+            $this->assertSame(3, $m->getOptionalUint64());
+        }
+
         $m->setOptionalUint64(MAX_UINT64_STRING);
-        $this->assertEquals(MAX_UINT64, $m->getOptionalUint64());
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame(MAX_UINT64_STRING, $m->getOptionalUint64());
+        } else {
+            $this->assertSame(MAX_UINT64, $m->getOptionalUint64());
+        }
     }
 
     /**
diff --git a/php/tests/map_field_test.php b/php/tests/map_field_test.php
index d79d0da3..4e42361d 100644
--- a/php/tests/map_field_test.php
+++ b/php/tests/map_field_test.php
@@ -205,9 +205,14 @@ class MapFieldTest extends PHPUnit_Framework_TestCase {
 
         // Test integer argument.
         $arr[MAX_INT64] = MAX_INT64;
-        $this->assertSame(MAX_INT64, $arr[MAX_INT64]);
         $arr[MIN_INT64] = MIN_INT64;
-        $this->assertEquals(MIN_INT64, $arr[MIN_INT64]);
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame(MAX_INT64_STRING, $arr[MAX_INT64_STRING]);
+            $this->assertSame(MIN_INT64_STRING, $arr[MIN_INT64_STRING]);
+        } else {
+            $this->assertSame(MAX_INT64, $arr[MAX_INT64]);
+            $this->assertSame(MIN_INT64, $arr[MIN_INT64]);
+        }
         $this->assertEquals(2, count($arr));
         unset($arr[MAX_INT64]);
         unset($arr[MIN_INT64]);
@@ -215,20 +220,31 @@ class MapFieldTest extends PHPUnit_Framework_TestCase {
 
         // Test float argument.
         $arr[1.1] = 1.1;
-        $this->assertSame(1, $arr[1]);
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame('1', $arr['1']);
+        } else {
+            $this->assertSame(1, $arr[1]);
+        }
         $this->assertEquals(1, count($arr));
         unset($arr[1.1]);
         $this->assertEquals(0, count($arr));
 
         // Test string argument.
         $arr['2'] = '2';
-        $this->assertSame(2, $arr[2]);
         $arr['3.1'] = '3.1';
-        $this->assertSame(3, $arr[3]);
         $arr[MAX_INT64_STRING] = MAX_INT64_STRING;
-        $this->assertSame(MAX_INT64, $arr[MAX_INT64]);
         $arr[MIN_INT64_STRING] = MIN_INT64_STRING;
-        $this->assertEquals(MIN_INT64, $arr[MIN_INT64]);
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame('2', $arr['2']);
+            $this->assertSame('3', $arr['3']);
+            $this->assertSame(MAX_INT64_STRING, $arr[MAX_INT64_STRING]);
+            $this->assertSame(MIN_INT64_STRING, $arr[MIN_INT64_STRING]);
+        } else {
+            $this->assertSame(2, $arr[2]);
+            $this->assertSame(3, $arr[3]);
+            $this->assertSame(MAX_INT64, $arr[MAX_INT64]);
+            $this->assertSame(MIN_INT64, $arr[MIN_INT64]);
+        }
         $this->assertEquals(4, count($arr));
         unset($arr['2']);
         unset($arr['3.1']);
@@ -282,25 +298,41 @@ class MapFieldTest extends PHPUnit_Framework_TestCase {
 
         // Test integer argument.
         $arr[MAX_UINT64] = MAX_UINT64;
-        $this->assertEquals(MAX_UINT64, $arr[MAX_UINT64]);
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame(MAX_UINT64_STRING, $arr[MAX_UINT64_STRING]);
+        } else {
+            $this->assertSame(MAX_UINT64, $arr[MAX_UINT64]);
+        }
         $this->assertEquals(1, count($arr));
         unset($arr[MAX_UINT64]);
         $this->assertEquals(0, count($arr));
 
         // Test float argument.
         $arr[1.1] = 1.1;
-        $this->assertSame(1, $arr[1]);
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame('1', $arr['1']);
+        } else {
+            $this->assertSame(1, $arr[1]);
+        }
         $this->assertEquals(1, count($arr));
         unset($arr[1.1]);
         $this->assertEquals(0, count($arr));
 
         // Test string argument.
         $arr['2'] = '2';
-        $this->assertSame(2, $arr[2]);
         $arr['3.1'] = '3.1';
-        $this->assertSame(3, $arr[3]);
         $arr[MAX_UINT64_STRING] = MAX_UINT64_STRING;
-        $this->assertEquals(MAX_UINT64, $arr[MAX_UINT64]);
+
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame('2', $arr['2']);
+            $this->assertSame('3', $arr['3']);
+            $this->assertSame(MAX_UINT64_STRING, $arr[MAX_UINT64_STRING]);
+        } else {
+            $this->assertSame(2, $arr[2]);
+            $this->assertSame(3, $arr[3]);
+            $this->assertSame(MAX_UINT64, $arr[MAX_UINT64]);
+        }
+
         $this->assertEquals(3, count($arr));
         unset($arr['2']);
         unset($arr['3.1']);
diff --git a/php/tests/php_implementation_test.php b/php/tests/php_implementation_test.php
index 82941dd2..485956cc 100644
--- a/php/tests/php_implementation_test.php
+++ b/php/tests/php_implementation_test.php
@@ -9,14 +9,10 @@ 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
 {
@@ -68,17 +64,17 @@ class ImplementationTest extends TestBase
         // Positive number.
         $input = new InputStream(hex2bin("01"));
         GPBWire::readInt64($input, $value);
-        $this->assertSame(1, $value->toInteger());
+        $this->assertEquals(1, $value);
 
         // Negative number.
         $input = new InputStream(hex2bin("ffffffffffffffffff01"));
         GPBWire::readInt64($input, $value);
-        $this->assertSame(-1, $value->toInteger());
+        $this->assertEquals(-1, $value);
 
         // Discard overflow bits.
         $input = new InputStream(hex2bin("ffffffffffffffffff0f"));
         GPBWire::readInt64($input, $value);
-        $this->assertSame(-1, $value->toInteger());
+        $this->assertEquals(-1, $value);
     }
 
     public function testReadUint64()
@@ -88,17 +84,17 @@ class ImplementationTest extends TestBase
         // Positive number.
         $input = new InputStream(hex2bin("01"));
         GPBWire::readUint64($input, $value);
-        $this->assertSame(1, $value->toInteger());
+        $this->assertEquals(1, $value);
 
         // Negative number.
         $input = new InputStream(hex2bin("FFFFFFFFFFFFFFFFFF01"));
         GPBWire::readUint64($input, $value);
-        $this->assertSame(-1, $value->toInteger());
+        $this->assertEquals(-1, $value);
 
         // Discard overflow bits.
         $input = new InputStream(hex2bin("FFFFFFFFFFFFFFFFFF0F"));
         GPBWire::readUint64($input, $value);
-        $this->assertSame(-1, $value->toInteger());
+        $this->assertEquals(-1, $value);
     }
 
     public function testReadSint32()
@@ -124,15 +120,15 @@ class ImplementationTest extends TestBase
 
         $input = new InputStream(hex2bin("00"));
         GPBWire::readSint64($input, $value);
-        $this->assertEquals(GPBUtil::Int64(0), $value);
+        $this->assertEquals(0, $value);
 
         $input = new InputStream(hex2bin("01"));
         GPBWire::readSint64($input, $value);
-        $this->assertEquals(GPBUtil::Int64(-1), $value);
+        $this->assertEquals(-1, $value);
 
         $input = new InputStream(hex2bin("02"));
         GPBWire::readSint64($input, $value);
-        $this->assertEquals(GPBUtil::Int64(1), $value);
+        $this->assertEquals(1, $value);
     }
 
     public function testReadFixed32()
@@ -148,7 +144,11 @@ class ImplementationTest extends TestBase
         $value = null;
         $input = new InputStream(hex2bin("1234567812345678"));
         GPBWire::readFixed64($input, $value);
-        $this->assertEquals(Uint64::newValue(0x78563412, 0x78563412), $value);
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame("8671175386481439762", $value);
+        } else {
+            $this->assertSame(0x7856341278563412, $value);
+        }
     }
 
     public function testReadSfixed32()
@@ -193,7 +193,11 @@ class ImplementationTest extends TestBase
         $value = null;
         $input = new InputStream(hex2bin("1234567812345678"));
         GPBWire::readSfixed64($input, $value);
-        $this->assertEquals(Int64::newValue(0x78563412, 0x78563412), $value);
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame("8671175386481439762", $value);
+        } else {
+            $this->assertSame(0x7856341278563412, $value);
+        }
     }
 
     public function testZigZagEncodeDecode()
@@ -214,43 +218,65 @@ class ImplementationTest extends TestBase
         $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)));
+        $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)));
@@ -319,15 +345,27 @@ class ImplementationTest extends TestBase
         // Normal case.
         $input = new InputStream(hex2bin('808001'));
         $this->assertTrue($input->readVarint64($var));
-        $this->assertSame(16384, $var->toInteger());
+        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));
-        $this->assertSame(16384, $var->toInteger());
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame('16384', $var);
+        } else {
+            $this->assertSame(16384, $var);
+        }
         $this->assertTrue($input->readVarint64($var));
-        $this->assertSame(32768, $var->toInteger());
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame('32768', $var);
+        } else {
+            $this->assertSame(32768, $var);
+        }
         $this->assertFalse($input->readVarint64($var));
     }
 
diff --git a/php/tests/test_base.php b/php/tests/test_base.php
index 25f18f74..49886050 100644
--- a/php/tests/test_base.php
+++ b/php/tests/test_base.php
@@ -13,22 +13,28 @@ class TestBase extends PHPUnit_Framework_TestCase
 
     public function expectFields(TestMessage $m)
     {
-        $this->assertSame(-42,  $m->getOptionalInt32());
-        $this->assertSame(42,   $m->getOptionalUint32());
-        $this->assertSame(-43,  $m->getOptionalInt64());
-        $this->assertSame(43,   $m->getOptionalUint64());
         $this->assertSame(-44,  $m->getOptionalSint32());
-        $this->assertSame(-45,  $m->getOptionalSint64());
         $this->assertSame(46,   $m->getOptionalFixed32());
-        $this->assertSame(47,   $m->getOptionalFixed64());
         $this->assertSame(-46,  $m->getOptionalSfixed32());
-        $this->assertSame(-47,  $m->getOptionalSfixed64());
         $this->assertSame(1.5,  $m->getOptionalFloat());
         $this->assertSame(1.6,  $m->getOptionalDouble());
         $this->assertSame(true, $m->getOptionalBool());
         $this->assertSame('a',  $m->getOptionalString());
         $this->assertSame('b',  $m->getOptionalBytes());
         $this->assertSame(33,   $m->getOptionalMessage()->getA());
+        if (PHP_INT_SIZE == 4) {
+            $this->assertSame('-43',  $m->getOptionalInt64());
+            $this->assertSame('43',   $m->getOptionalUint64());
+            $this->assertSame('-45',  $m->getOptionalSint64());
+            $this->assertSame('47',   $m->getOptionalFixed64());
+            $this->assertSame('-47',  $m->getOptionalSfixed64());
+        } else {
+            $this->assertSame(-43,  $m->getOptionalInt64());
+            $this->assertSame(43,   $m->getOptionalUint64());
+            $this->assertSame(-45,  $m->getOptionalSint64());
+            $this->assertSame(47,   $m->getOptionalFixed64());
+            $this->assertSame(-47,  $m->getOptionalSfixed64());
+        }
 
         $this->assertEquals(-42,  $m->getRepeatedInt32()[0]);
         $this->assertEquals(42,   $m->getRepeatedUint32()[0]);
diff --git a/php/tests/test_util.php b/php/tests/test_util.php
index 2f6e4dd8..7f2aae15 100644
--- a/php/tests/test_util.php
+++ b/php/tests/test_util.php
@@ -20,7 +20,7 @@ define('MAX_INT32', 2147483647);
 define('MAX_INT32_FLOAT', 2147483647.0);
 define('MAX_INT32_STRING', '2147483647');
 
-define('MIN_INT32', -2147483648);
+define('MIN_INT32', (int)-2147483648);
 define('MIN_INT32_FLOAT', -2147483648.0);
 define('MIN_INT32_STRING', '-2147483648');
 
@@ -28,23 +28,24 @@ define('MAX_UINT32', 4294967295);
 define('MAX_UINT32_FLOAT', 4294967295.0);
 define('MAX_UINT32_STRING', '4294967295');
 
-define('MIN_UINT32', -2147483648);
+define('MIN_UINT32', (int)-2147483648);
 define('MIN_UINT32_FLOAT', -2147483648.0);
 define('MIN_UINT32_STRING', '-2147483648');
 
-define('MAX_INT64', 9223372036854775807);
-define('MAX_INT64_STRING', '9223372036854775807');
+define('MAX_INT64_STRING',  '9223372036854775807');
+define('MIN_INT64_STRING',  '-9223372036854775808');
+define('MAX_UINT64_STRING', '-9223372036854775808');
 
-define('MIN_INT64_STRING', '-9223372036854775808');
 if (PHP_INT_SIZE === 8) {
-    define('MIN_INT64', -9223372036854775808);
+    define('MAX_INT64',  (int)9223372036854775807);
+    define('MIN_INT64',  (int)-9223372036854775808);
+    define('MAX_UINT64', (int)-9223372036854775808);
 } else {
+    define('MAX_INT64', MAX_INT64_STRING);
     define('MIN_INT64', MIN_INT64_STRING);
+    define('MAX_UINT64', MAX_UINT64_STRING);
 }
 
-define('MAX_UINT64_STRING', '-9223372036854775808');
-define('MAX_UINT64', MAX_UINT64_STRING);
-
 class TestUtil
 {
 
@@ -129,16 +130,24 @@ class TestUtil
 
     public static function assertTestMessage(TestMessage $m)
     {
+        if (PHP_INT_SIZE == 4) {
+            assert('-43' === $m->getOptionalInt64());
+            assert('43'  === $m->getOptionalUint64());
+            assert('-45' === $m->getOptionalSint64());
+            assert('47'  === $m->getOptionalFixed64());
+            assert('-47' === $m->getOptionalSfixed64());
+        } else {
+            assert(-43 === $m->getOptionalInt64());
+            assert(43  === $m->getOptionalUint64());
+            assert(-45 === $m->getOptionalSint64());
+            assert(47  === $m->getOptionalFixed64());
+            assert(-47 === $m->getOptionalSfixed64());
+        }
         assert(-42 === $m->getOptionalInt32());
         assert(42  === $m->getOptionalUint32());
-        assert(-43 === $m->getOptionalInt64());
-        assert(43  === $m->getOptionalUint64());
         assert(-44 === $m->getOptionalSint32());
-        assert(-45 === $m->getOptionalSint64());
         assert(46  === $m->getOptionalFixed32());
-        assert(47  === $m->getOptionalFixed64());
         assert(-46 === $m->getOptionalSfixed32());
-        assert(-47 === $m->getOptionalSfixed64());
         assert(1.5 === $m->getOptionalFloat());
         assert(1.6 === $m->getOptionalDouble());
         assert(true=== $m->getOptionalBool());
@@ -147,16 +156,24 @@ class TestUtil
         assert(TestEnum::ONE === $m->getOptionalEnum());
         assert(33  === $m->getOptionalMessage()->getA());
 
+        if (PHP_INT_SIZE == 4) {
+            assert('-43' === $m->getRepeatedInt64()[0]);
+            assert('43'  === $m->getRepeatedUint64()[0]);
+            assert('-45' === $m->getRepeatedSint64()[0]);
+            assert('47'  === $m->getRepeatedFixed64()[0]);
+            assert('-47' === $m->getRepeatedSfixed64()[0]);
+        } else {
+            assert(-43 === $m->getRepeatedInt64()[0]);
+            assert(43  === $m->getRepeatedUint64()[0]);
+            assert(-45 === $m->getRepeatedSint64()[0]);
+            assert(47  === $m->getRepeatedFixed64()[0]);
+            assert(-47 === $m->getRepeatedSfixed64()[0]);
+        }
         assert(-42 === $m->getRepeatedInt32()[0]);
         assert(42  === $m->getRepeatedUint32()[0]);
-        assert(-43 === $m->getRepeatedInt64()[0]);
-        assert(43  === $m->getRepeatedUint64()[0]);
         assert(-44 === $m->getRepeatedSint32()[0]);
-        assert(-45 === $m->getRepeatedSint64()[0]);
         assert(46  === $m->getRepeatedFixed32()[0]);
-        assert(47  === $m->getRepeatedFixed64()[0]);
         assert(-46 === $m->getRepeatedSfixed32()[0]);
-        assert(-47 === $m->getRepeatedSfixed64()[0]);
         assert(1.5 === $m->getRepeatedFloat()[0]);
         assert(1.6 === $m->getRepeatedDouble()[0]);
         assert(true=== $m->getRepeatedBool()[0]);
@@ -165,16 +182,24 @@ class TestUtil
         assert(TestEnum::ZERO === $m->getRepeatedEnum()[0]);
         assert(34  === $m->getRepeatedMessage()[0]->getA());
 
+        if (PHP_INT_SIZE == 4) {
+            assert('-53' === $m->getRepeatedInt64()[1]);
+            assert('53'  === $m->getRepeatedUint64()[1]);
+            assert('-55' === $m->getRepeatedSint64()[1]);
+            assert('57'  === $m->getRepeatedFixed64()[1]);
+            assert('-57' === $m->getRepeatedSfixed64()[1]);
+        } else {
+            assert(-53 === $m->getRepeatedInt64()[1]);
+            assert(53  === $m->getRepeatedUint64()[1]);
+            assert(-55 === $m->getRepeatedSint64()[1]);
+            assert(57  === $m->getRepeatedFixed64()[1]);
+            assert(-57 === $m->getRepeatedSfixed64()[1]);
+        }
         assert(-52 === $m->getRepeatedInt32()[1]);
         assert(52  === $m->getRepeatedUint32()[1]);
-        assert(-53 === $m->getRepeatedInt64()[1]);
-        assert(53  === $m->getRepeatedUint64()[1]);
         assert(-54 === $m->getRepeatedSint32()[1]);
-        assert(-55 === $m->getRepeatedSint64()[1]);
         assert(56  === $m->getRepeatedFixed32()[1]);
-        assert(57  === $m->getRepeatedFixed64()[1]);
         assert(-56 === $m->getRepeatedSfixed32()[1]);
-        assert(-57 === $m->getRepeatedSfixed64()[1]);
         assert(2.5 === $m->getRepeatedFloat()[1]);
         assert(2.6 === $m->getRepeatedDouble()[1]);
         assert(false === $m->getRepeatedBool()[1]);
@@ -183,14 +208,21 @@ class TestUtil
         assert(TestEnum::ONE === $m->getRepeatedEnum()[1]);
         assert(35  === $m->getRepeatedMessage()[1]->getA());
 
+        if (PHP_INT_SIZE == 4) {
+            assert('-63' === $m->getMapInt64Int64()['-63']);
+            assert('63'  === $m->getMapUint64Uint64()['63']);
+            assert('-65' === $m->getMapSint64Sint64()['-65']);
+            assert('67'  === $m->getMapFixed64Fixed64()['67']);
+        } else {
+            assert(-63 === $m->getMapInt64Int64()[-63]);
+            assert(63  === $m->getMapUint64Uint64()[63]);
+            assert(-65 === $m->getMapSint64Sint64()[-65]);
+            assert(67  === $m->getMapFixed64Fixed64()[67]);
+        }
         assert(-62 === $m->getMapInt32Int32()[-62]);
-        assert(-63 === $m->getMapInt64Int64()[-63]);
         assert(62  === $m->getMapUint32Uint32()[62]);
-        assert(63  === $m->getMapUint64Uint64()[63]);
         assert(-64 === $m->getMapSint32Sint32()[-64]);
-        assert(-65 === $m->getMapSint64Sint64()[-65]);
         assert(66  === $m->getMapFixed32Fixed32()[66]);
-        assert(67  === $m->getMapFixed64Fixed64()[67]);
         assert(3.5 === $m->getMapInt32Float()[1]);
         assert(3.6 === $m->getMapInt32Double()[1]);
         assert(true === $m->getMapBoolBool()[true]);
@@ -325,24 +357,14 @@ class TestUtil
 
         assert(-42 === $m->getRepeatedInt32()[0]);
         assert(-52 === $m->getRepeatedInt32()[1]);
-        assert(-43 === $m->getRepeatedInt64()[0]);
-        assert(-53 === $m->getRepeatedInt64()[1]);
         assert(42  === $m->getRepeatedUint32()[0]);
         assert(52  === $m->getRepeatedUint32()[1]);
-        assert(43  === $m->getRepeatedUint64()[0]);
-        assert(53  === $m->getRepeatedUint64()[1]);
         assert(-44 === $m->getRepeatedSint32()[0]);
         assert(-54 === $m->getRepeatedSint32()[1]);
-        assert(-45 === $m->getRepeatedSint64()[0]);
-        assert(-55 === $m->getRepeatedSint64()[1]);
         assert(46  === $m->getRepeatedFixed32()[0]);
         assert(56  === $m->getRepeatedFixed32()[1]);
-        assert(47  === $m->getRepeatedFixed64()[0]);
-        assert(57  === $m->getRepeatedFixed64()[1]);
         assert(-46 === $m->getRepeatedSfixed32()[0]);
         assert(-56 === $m->getRepeatedSfixed32()[1]);
-        assert(-47 === $m->getRepeatedSfixed64()[0]);
-        assert(-57 === $m->getRepeatedSfixed64()[1]);
         assert(1.5 === $m->getRepeatedFloat()[0]);
         assert(2.5 === $m->getRepeatedFloat()[1]);
         assert(1.6 === $m->getRepeatedDouble()[0]);
@@ -351,6 +373,29 @@ class TestUtil
         assert(false === $m->getRepeatedBool()[1]);
         assert(TestEnum::ONE  === $m->getRepeatedEnum()[0]);
         assert(TestEnum::ZERO === $m->getRepeatedEnum()[1]);
+        if (PHP_INT_SIZE == 4) {
+            assert('-43' === $m->getRepeatedInt64()[0]);
+            assert('-53' === $m->getRepeatedInt64()[1]);
+            assert('43'  === $m->getRepeatedUint64()[0]);
+            assert('53'  === $m->getRepeatedUint64()[1]);
+            assert('-45' === $m->getRepeatedSint64()[0]);
+            assert('-55' === $m->getRepeatedSint64()[1]);
+            assert('47'  === $m->getRepeatedFixed64()[0]);
+            assert('57'  === $m->getRepeatedFixed64()[1]);
+            assert('-47' === $m->getRepeatedSfixed64()[0]);
+            assert('-57' === $m->getRepeatedSfixed64()[1]);
+        } else {
+            assert(-43 === $m->getRepeatedInt64()[0]);
+            assert(-53 === $m->getRepeatedInt64()[1]);
+            assert(43  === $m->getRepeatedUint64()[0]);
+            assert(53  === $m->getRepeatedUint64()[1]);
+            assert(-45 === $m->getRepeatedSint64()[0]);
+            assert(-55 === $m->getRepeatedSint64()[1]);
+            assert(47  === $m->getRepeatedFixed64()[0]);
+            assert(57  === $m->getRepeatedFixed64()[1]);
+            assert(-47 === $m->getRepeatedSfixed64()[0]);
+            assert(-57 === $m->getRepeatedSfixed64()[1]);
+        }
     }
 
     public static function getGoldenTestPackedMessage()