function test($type, $variable, $test)
{
    $serialized = msgpack_serialize($variable);
    $unserialized = msgpack_unserialize($serialized);
    var_dump($variable);
    var_dump($unserialized);
}

function test($type, $variable)
{
    $unserialized = msgpack_unserialize(pack('H*', $variable));
    echo $type, PHP_EOL;
    echo $variable, PHP_EOL;
    var_dump($unserialized);
}

function test($type, $variable, $test)
{
    $serialized = pack('H*', $variable);
    $unserialized = msgpack_unserialize($serialized);
    echo $type, PHP_EOL;
    echo bin2hex($serialized), PHP_EOL;
    var_dump($unserialized);
}

function test($type, $variable)
{
    $serialized = msgpack_serialize($variable);
    $unserialized = msgpack_unserialize($serialized);
    echo $type, PHP_EOL;
    echo bin2hex($serialized), PHP_EOL;
    var_dump($unserialized);
    echo $unserialized === $variable ? 'OK' : 'ERROR', PHP_EOL;
}

function test($type, $variable, $test)
{
    $serialized = msgpack_serialize($variable);
    $unserialized = msgpack_unserialize($serialized);
    echo $type, PHP_EOL;
    echo bin2hex($serialized), PHP_EOL;
    var_dump($unserialized);
    echo $test || $unserialized === null ? 'OK' : 'FAIL', PHP_EOL;
}

 /**
  */
 public function unpack($data)
 {
     ini_set('track_errors', 1);
     $out = @msgpack_unserialize($data);
     ini_restore('track_errors');
     if (!isset($php_errormsg)) {
         return $out;
     }
     throw new Horde_Pack_Exception('Error when unpacking Msgpack data.');
 }

 /**
  * Deserialize msgpack string to PHP value
  *
  * @param  string $serialized
  * @return mixed
  * @throws Exception\RuntimeException on msgpack error
  */
 public function unserialize($serialized)
 {
     if ($serialized === static::$serialized0) {
         return 0;
     }
     ErrorHandler::start();
     $ret = msgpack_unserialize($serialized);
     $err = ErrorHandler::stop();
     if ($ret === 0) {
         throw new Exception\RuntimeException('Unserialization failed', 0, $err);
     }
     return $ret;
 }

function test()
{
    $serialized = msgpack_serialize(null);
    $serialized = substr($serialized, 0, -1);
    $length = mt_rand(1, 255);
    for ($i = 0; $i < $length; ++$i) {
        $serialized .= chr(mt_rand(0, 255));
    }
    // if returned null everything is OK
    if (($unserialized = msgpack_unserialize($serialized)) === null) {
        return true;
    }
    // whole data is read?
    if ($serialized !== msgpack_serialize($unserialized)) {
        return true;
    }
    echo bin2hex($serialized), "\n";
    var_dump($unserialized);
    return false;
}

}
class Foo
{
    public $parent;
    public $children;
    public function __construct()
    {
        $this->parent = null;
        $this->children = array();
    }
    public function addChild(Foo $obj)
    {
        $this->children[] = $obj;
        $obj->setParent($this);
    }
    public function setParent(Foo $obj)
    {
        $this->parent = $obj;
    }
}
$obj1 = new Foo();
for ($i = 0; $i < 10; $i++) {
    $obj = new Foo();
    $obj1->addChild($obj);
}
$o = msgpack_unserialize(msgpack_serialize($obj1->children));
foreach ($obj1->children as $k => $v) {
    $obj_v = $v;
    $o_v = $o[$k];
    echo gettype($obj_v), "  ", gettype($o_v), PHP_EOL;
}

<?php

class test
{
}
print_r(msgpack_unserialize(msgpack_serialize(new test())));

         $igbinary_size += strlen($pack);
         if ($unpack === $value || is_object($value) && $unpack == $value) {
             $igbinary_status = 'OK';
         }
     }
     //msgpack
     $pack = null;
     $unpack = null;
     $t = new Benchmark_Timer();
     $t->start();
     for ($i = 0; $i < $loop; $i++) {
         $pack = msgpack_serialize($value);
     }
     $t->setMarker('msgpack_serialize');
     for ($i = 0; $i < $loop; $i++) {
         $unpack = msgpack_unserialize($pack);
     }
     $t->stop();
     //$t->display();
     $profiling = $t->getProfiling();
     unset($t);
     $msgpack_pack += $profiling[1]['diff'];
     $msgpack_unpack += $profiling[2]['diff'];
     $msgpack_size += strlen($pack);
     if ($unpack === $value || is_object($value) && $unpack == $value) {
         $msgpack_status = 'OK';
     }
 }
 $serialize_pack /= $retry;
 $serialize_unpack /= $retry;
 $serialize_size /= $retry;

<?php

class Demo extends ArrayObject
{
}
$obj = new StdClass();
$demo = new Demo();
$demo[] = $obj;
$demo[] = $obj;
$data = array($demo, $obj, $obj);
print_r(msgpack_unserialize(msgpack_serialize($data)));

    // truncated
    for ($i = 0; $i < $len - 1; $i++) {
        $v = msgpack_unserialize(substr($str, 0, $i));
        if (is_object($data) || is_array($data)) {
            if ($v !== null && $v !== false && $v != $data) {
                echo "output at {$i}:\n";
                var_dump($v);
            }
        } else {
            if ($v !== null && $v == $data) {
                continue;
            } else {
                if ($v !== null && $v !== $data) {
                    echo "output at {$i}:\n";
                    var_dump($v);
                    echo "vs.\n";
                    var_dump($data);
                }
            }
        }
    }
    // padded
    $str .= "98398afay21_ ";
    $v = msgpack_unserialize($str);
    if ($v !== $data && !(is_object($data) && $v == $data)) {
        echo "padded should get original\n";
        var_dump($v);
        echo "vs.\n";
        var_dump($data);
    }
}

 /**
  * 数据解码。
  * 
  * @param string $data 指定数据对象。
  * @param int $format 指定编码格式。(默认值: 1 | JSON, 其它可用值: Encoder::MSGPACK, Encoder::XML)
  * @return array|mixed
  * @throws NotImplementedException
  */
 static function decode($data, $format = 1)
 {
     $s = false;
     switch ($format) {
         case self::JSON:
             $s = json_decode($data, true);
             break;
         case self::MSGPACK:
             $s = msgpack_unserialize($data);
             break;
         case self::IGBINARY:
             $s = igbinary_unserialize($data);
             break;
         case self::XML:
             throw new NotImplementedException('尚未实现此接口。', -1);
             break;
     }
     return $s;
 }

<?php

$data_array = array();
for ($i = 0; $i < 5000; $i++) {
    $data_array[mcrypt_create_iv(10, MCRYPT_DEV_URANDOM)] = mcrypt_create_iv(10, MCRYPT_DEV_URANDOM);
}
$time_start = microtime(true);
for ($i = 0; $i < 4000; $i++) {
    $s = msgpack_serialize($data_array);
    $array = msgpack_unserialize($s);
    unset($array);
    unset($s);
}
$time_end = microtime(true);
if ($time_end <= $time_start) {
    echo "Strange, {$i} iterations ran in infinite speed: {$time_end} <= {$time_start}", PHP_EOL;
} else {
    $speed = $i / ($time_end - $time_start);
    printf("%d iterations took %f seconds: %d/s (%s)\n", $i, $time_end - $time_start, $speed, $speed > 400 ? "GOOD" : "BAD");
}

<?php

if (!extension_loaded('msgpack')) {
    dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
$closure = function ($x) {
    return $x + 1;
};
class Foo implements Serializable
{
    public function serialize()
    {
        echo "Should not be run.\n";
    }
    public function unserialize($str)
    {
        echo "Should not be run.\n";
    }
}
$array = array($closure, new Foo());
try {
    $ser = msgpack_serialize($array);
    echo "Serialized closure.\n";
    $unser = msgpack_unserialize($ser);
    echo "Unserialized closure.\n";
    var_dump($unser);
} catch (Exception $e) {
    echo "Got exception.\n";
}

<?php

if (!extension_loaded('msgpack')) {
    dl('msgpack.' . PHP_SHLIB_SUFFIX);
}
$datas = array(87817, -1, array(1, 2, 3, "testing" => 10, "foo"), true, false, 0.187182, "dakjdh98389", null, (object) array(1, 2, 3));
error_reporting(0);
foreach ($datas as $data) {
    $str = msgpack_serialize($data);
    $len = strlen($str);
    for ($j = 0; $j < 200; $j++) {
        for ($i = 0; $i < $len - 1; $i++) {
            $sub = substr($str, 0, $i);
            $sub .= mcrypt_create_iv(30, MCRYPT_DEV_URANDOM);
            $php_errormsg = null;
            $v = msgpack_unserialize($sub);
        }
    }
}

<?php

$data = array();
$tmp =& $data;
for ($i = 0; $i < 1024; $i++) {
    $tmp[] = array();
    $tmp =& $tmp[0];
}
$newdata = msgpack_unserialize(msgpack_serialize($data));
var_dump($newdata == $data);