msgpack-lite 0.1.17 → 0.1.26

package/test/10.encode.js

@@ -6,12 +6,32 @@ var isBrowser = ("undefined" !== typeof window);
 var msgpack = isBrowser && window.msgpack || require(msgpackJS);
 var TITLE = __filename.replace(/^.*\//, "");
 
+var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
+
 describe(TITLE, function() {
+  describe("Buffer", function() {
+    run_tests();
+  });
+
+  var describe_Uint8Array = HAS_UINT8ARRAY ? describe : describe.skip;
+  describe_Uint8Array("Uint8Array", function() {
+    run_tests({uint8array: true});
+  });
+});
+
+function run_tests(codecopt) {
+  var options;
+
+  if (codecopt) it(JSON.stringify(codecopt), function() {
+    var codec = msgpack.createCodec(codecopt);
+    assert.ok(codec);
+    options = {codec: codec};
+  });
 
   // positive fixint -- 0x00 - 0x7f
   it("00-7f: positive fixint", function() {
     for (var i = 0; i <= 0x7F; i++) {
-      assert.deepEqual(toArray(msgpack.encode(i)), [i]);
+      assert.deepEqual(toArray(msgpack.encode(i, options)), [i]);
     }
   });
 
@@ -21,7 +41,7 @@ describe(TITLE, function() {
     var src = {};
     var exp = [0x80];
     Object.keys(map).forEach(function(key) {
-      assert.deepEqual(toArray(msgpack.encode(src)), exp);
+      assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
       src[key] = map[key];
       exp[0]++;
       exp.push(0xa1);
@@ -36,7 +56,7 @@ describe(TITLE, function() {
     var src = [];
     var exp = [0x90];
     for (var i = 0; i < 16; i++) {
-      assert.deepEqual(toArray(msgpack.encode(src)), exp);
+      assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
       src.push(array[i]);
       exp[0]++;
       exp.push(array[i]);
@@ -45,13 +65,13 @@ describe(TITLE, function() {
 
   // fixstr -- 0xa0 - 0xbf
   it("a0-bf: fixstr", function() {
-    assert.deepEqual(toArray(msgpack.encode("")), [0xa0]);
+    assert.deepEqual(toArray(msgpack.encode("", options)), [0xa0]);
 
     var str = "0123456789abcdefghijklmnopqrstu";
     var exp = [0xa0];
     for (var i = 0; i < 32; i++) {
       var src = str.substr(0, i);
-      assert.deepEqual(toArray(msgpack.encode(src)), exp);
+      assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
       exp[0]++;
       exp.push(str.charCodeAt(i));
     }
@@ -59,20 +79,20 @@ describe(TITLE, function() {
 
   // nil -- 0xc0
   it("c0: nil (null)", function() {
-    assert.deepEqual(toArray(msgpack.encode(null)), [0xc0]);
+    assert.deepEqual(toArray(msgpack.encode(null, options)), [0xc0]);
   });
   it("c0: nil (undefined)", function() {
-    assert.deepEqual(toArray(msgpack.encode(undefined)), [0xc0]);
+    assert.deepEqual(toArray(msgpack.encode(undefined, options)), [0xc0]);
   });
   it("c0: nil (Function)", function() {
-    assert.deepEqual(toArray(msgpack.encode(NOP)), [0xc0]);
+    assert.deepEqual(toArray(msgpack.encode(NOP, options)), [0xc0]);
   });
 
   // false -- 0xc2
   // true -- 0xc3
   it("c2-c3: boolean", function() {
-    assert.deepEqual(toArray(msgpack.encode(false)), [0xc2]);
-    assert.deepEqual(toArray(msgpack.encode(true)), [0xc3]);
+    assert.deepEqual(toArray(msgpack.encode(false, options)), [0xc2]);
+    assert.deepEqual(toArray(msgpack.encode(true, options)), [0xc3]);
   });
 
   // bin 8 -- 0xc4
@@ -83,21 +103,21 @@ describe(TITLE, function() {
     var bin;
     bin = Buffer(1);
     bin.fill(0);
-    assert.deepEqual(toArray(msgpack.encode(bin)), concat([0xc4, 1], bin));
+    assert.deepEqual(toArray(msgpack.encode(bin, options)), concat([0xc4, 1], bin));
 
     bin = Buffer(256);
     bin.fill(0);
-    assert.deepEqual(toArray(msgpack.encode(bin)), concat([0xc5, 1, 0], bin));
+    assert.deepEqual(toArray(msgpack.encode(bin, options)), concat([0xc5, 1, 0], bin));
 
     bin = Buffer(65536);
     bin.fill(0);
-    assert.deepEqual(toArray(msgpack.encode(bin)), concat([0xc6, 0, 1, 0, 0], bin));
+    assert.deepEqual(toArray(msgpack.encode(bin, options)), concat([0xc6, 0, 1, 0, 0], bin));
   });
 
   // float 32 -- 0xca -- NOT SUPPORTED
   // float 64 -- 0xcb
   it("ca-cb: float 32/64", function() {
-    assert.deepEqual(toArray(msgpack.encode(0.5)), [0xcb, 63, 224, 0, 0, 0, 0, 0, 0]);
+    assert.deepEqual(toArray(msgpack.encode(0.5, options)), [0xcb, 63, 224, 0, 0, 0, 0, 0, 0]);
   });
 
   // uint 8 -- 0xcc
@@ -105,9 +125,9 @@ describe(TITLE, function() {
   // uint 32 -- 0xce
   // uint 64 -- 0xcf -- NOT SUPPORTED
   it("cc-cf: uint 8/16/32/64", function() {
-    assert.deepEqual(toArray(msgpack.encode(0xFF)), [0xcc, 0xFF]);
-    assert.deepEqual(toArray(msgpack.encode(0xFFFF)), [0xcd, 0xFF, 0xFF]);
-    assert.deepEqual(toArray(msgpack.encode(0x7FFFFFFF)), [0xce, 0x7F, 0xFF, 0xFF, 0xFF]);
+    assert.deepEqual(toArray(msgpack.encode(0xFF, options)), [0xcc, 0xFF]);
+    assert.deepEqual(toArray(msgpack.encode(0xFFFF, options)), [0xcd, 0xFF, 0xFF]);
+    assert.deepEqual(toArray(msgpack.encode(0x7FFFFFFF, options)), [0xce, 0x7F, 0xFF, 0xFF, 0xFF]);
   });
 
   // int 8 -- 0xd0
@@ -115,9 +135,9 @@ describe(TITLE, function() {
   // int 32 -- 0xd2
   // int 64 -- 0xd3 -- NOT SUPPORTED
   it("d0-d3: int 8/16/32/64", function() {
-    assert.deepEqual(toArray(msgpack.encode(-0x80)), [0xd0, 0x80]);
-    assert.deepEqual(toArray(msgpack.encode(-0x8000)), [0xd1, 0x80, 0x00]);
-    assert.deepEqual(toArray(msgpack.encode(-0x80000000)), [0xd2, 0x80, 0x00, 0x00, 0x00]);
+    assert.deepEqual(toArray(msgpack.encode(-0x80, options)), [0xd0, 0x80]);
+    assert.deepEqual(toArray(msgpack.encode(-0x8000, options)), [0xd1, 0x80, 0x00]);
+    assert.deepEqual(toArray(msgpack.encode(-0x80000000, options)), [0xd2, 0x80, 0x00, 0x00, 0x00]);
   });
 
   // str 8 -- 0xd9
@@ -129,16 +149,16 @@ describe(TITLE, function() {
     for (var i = 0; i < 17; i++) src += src;
 
     str = src.substr(0, 0xFF);
-    assert.deepEqual(toArray(msgpack.encode(str)), concat([0xd9, 0xFF], Buffer(str)));
+    assert.deepEqual(toArray(msgpack.encode(str, options)), concat([0xd9, 0xFF], Buffer(str)));
 
     str = src.substr(0, 0x0100);
-    assert.deepEqual(toArray(msgpack.encode(str)), concat([0xda, 0x01, 0x00], Buffer(str)));
+    assert.deepEqual(toArray(msgpack.encode(str, options)), concat([0xda, 0x01, 0x00], Buffer(str)));
 
     str = src.substr(0, 0xFFFF);
-    assert.deepEqual(toArray(msgpack.encode(str)), concat([0xda, 0xFF, 0xFF], Buffer(str)));
+    assert.deepEqual(toArray(msgpack.encode(str, options)), concat([0xda, 0xFF, 0xFF], Buffer(str)));
 
     str = src.substr(0, 0x010000);
-    assert.deepEqual(toArray(msgpack.encode(str)), concat([0xdb, 0x00, 0x01, 0x00, 0x00], Buffer(str)));
+    assert.deepEqual(toArray(msgpack.encode(str, options)), concat([0xdb, 0x00, 0x01, 0x00, 0x00], Buffer(str)));
   });
 
   // array 16 -- 0xdc
@@ -149,11 +169,11 @@ describe(TITLE, function() {
     var src = new Array(256);
     for (i = 0; i < 256; i++) src[i] = i & 0x7F;
     exp = [0xdc, 0x01, 0x00].concat(src);
-    assert.deepEqual(toArray(msgpack.encode(src)), exp);
+    assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
 
     for (i = 0; i < 8; i++) src = src.concat(src);
     exp = [0xdd, 0x00, 0x01, 0x00, 0x00].concat(src);
-    assert.deepEqual(toArray(msgpack.encode(src)), exp);
+    assert.deepEqual(toArray(msgpack.encode(src, options)), exp);
   });
 
   // map 16 -- 0xde
@@ -163,14 +183,14 @@ describe(TITLE, function() {
     var i, actual;
     var map = {};
     for (i = 0; i < 256; i++) map[i] = i;
-    actual = msgpack.encode(map);
+    actual = msgpack.encode(map, options);
     // check only headers because order may vary
     assert.equal(actual[0], 0xde);
     assert.equal(actual[1], 1);
     assert.equal(actual[2], 0);
 
     for (i = 256; i < 65536; i++) map[i] = i;
-    actual = msgpack.encode(map);
+    actual = msgpack.encode(map, options);
     assert.equal(actual[0], 0xdf);
     assert.equal(actual[1], 0);
     assert.equal(actual[2], 1);
@@ -181,10 +201,10 @@ describe(TITLE, function() {
   // negative fixint -- 0xe0 - 0xff
   it("e0-ff: negative fixint", function() {
     for (var i = -32; i <= -1; i++) {
-      assert.deepEqual(toArray(msgpack.encode(i)), [i & 0xFF]);
+      assert.deepEqual(toArray(msgpack.encode(i, options)), [i & 0xFF]);
     }
   });
-});
+}
 
 function toArray(buffer) {
   return Array.prototype.slice.call(buffer);

package/test/11.decode.js

@@ -176,6 +176,7 @@ function run_tests(BUFFER) {
     assert.deepEqual(msgpack.decode(BUFFER([0xce, 0x00, 0x00, 0x00, 0x01])), 0x00000001);
     assert.deepEqual(msgpack.decode(BUFFER([0xce, 0x7F, 0xFF, 0xFF, 0xFF])), 0x7FFFFFFF);
     assert.deepEqual(msgpack.decode(BUFFER([0xce, 0xFF, 0xFF, 0xFF, 0xFF])), 0xFFFFFFFF);
+    assert.deepEqual(msgpack.decode(BUFFER([0xce, 0x12, 0x34, 0x56, 0x78])), 0x12345678);
     assert.deepEqual(msgpack.decode(BUFFER([0xcf, 0, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF])), 0x00000000FFFFFFFF);
     assert.deepEqual(msgpack.decode(BUFFER([0xcf, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF, 0, 0])), 0x0000FFFFFFFF0000);
     assert.deepEqual(msgpack.decode(BUFFER([0xcf, 0xFF, 0xFF, 0xFF, 0xFF, 0, 0, 0, 0])), 0xFFFFFFFF00000000);
@@ -195,6 +196,7 @@ function run_tests(BUFFER) {
     assert.deepEqual(msgpack.decode(BUFFER([0xd2, 0x7F, 0xFF, 0xFF, 0xFF])), 0x7FFFFFFF);
     assert.deepEqual(msgpack.decode(BUFFER([0xd2, 0x80, 0x00, 0x00, 0x00])), -0x80000000);
     assert.deepEqual(msgpack.decode(BUFFER([0xd2, 0xFF, 0xFF, 0xFF, 0xFF])), -1);
+    assert.deepEqual(msgpack.decode(BUFFER([0xd2, 0x12, 0x34, 0x56, 0x78])), 0x12345678);
     assert.deepEqual(msgpack.decode(BUFFER([0xd3, 0, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF])), 0x00000000FFFFFFFF);
     assert.deepEqual(msgpack.decode(BUFFER([0xd3, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF, 0, 0])), 0x0000FFFFFFFF0000);
     assert.deepEqual(msgpack.decode(BUFFER([0xd3, 0x7F, 0xFF, 0xFF, 0xFF, 0, 0, 0, 0])), 0x7FFFFFFF00000000);

package/test/14.codec.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
+
+describe(TITLE, function() {
+  it("createCodec()", function() {
+    var codec = msgpack.createCodec();
+    var options = {codec: codec};
+    assert.ok(codec);
+
+    // this codec does not have preset codec
+    for (var i = 0; i < 256; i++) {
+      test(i);
+    }
+
+    function test(type) {
+      // fixext 1 -- 0xd4
+      var source = new Buffer([0xd4, type, type]);
+      var decoded = msgpack.decode(source, options);
+      assert.equal(decoded.type, type);
+      assert.equal(decoded.buffer.length, 1);
+      var encoded = msgpack.encode(decoded, options);
+      assert.deepEqual(toArray(encoded), toArray(source));
+    }
+  });
+
+  it("addExtPacker()", function() {
+    var codec = msgpack.createCodec();
+    codec.addExtPacker(0, MyClass, myClassPacker);
+    codec.addExtUnpacker(0, myClassUnpacker);
+    var options = {codec: codec};
+    [0, 1, 127, 255].forEach(test);
+
+    function test(type) {
+      var source = new MyClass(type);
+      var encoded = msgpack.encode(source, options);
+      var decoded = msgpack.decode(encoded, options);
+      assert.ok(decoded instanceof MyClass);
+      assert.equal(decoded.value, type);
+    }
+  });
+
+  // The safe mode works as same as the default mode. It'd be hard for test it.
+  it("createCodec({safe: true})", function() {
+    var options = {codec: msgpack.createCodec({safe: true})};
+    var source = 1;
+    var encoded = msgpack.encode(source, options);
+    var decoded = msgpack.decode(encoded, options);
+    assert.equal(decoded, source);
+  });
+
+  it("createCodec({preset: true})", function() {
+    var options1 = {codec: msgpack.createCodec({preset: true})};
+    var options2 = {codec: msgpack.createCodec({preset: false})};
+
+    var source = new Date();
+    var encoded = msgpack.encode(source, options1);
+    assert.equal(encoded[0], 0xC7, "preset ext format failure. (128 means map format)"); // ext 8
+    assert.equal(encoded[1], 0x09); // 1+8
+    assert.equal(encoded[2], 0x0D); // Date
+
+    // decode as Boolean instance
+    var decoded = msgpack.decode(encoded, options1);
+    assert.equal(decoded - 0, source - 0);
+    assert.ok(decoded instanceof Date);
+
+    // decode as ExtBuffer
+    decoded = msgpack.decode(encoded, options2);
+    assert.ok(!(decoded instanceof Date));
+    assert.equal(decoded.type, 0x0D);
+  });
+});
+
+function MyClass(value) {
+  this.value = value & 0xFF;
+}
+
+function myClassPacker(obj) {
+  return new Buffer([obj.value]);
+}
+
+function myClassUnpacker(buffer) {
+  return new MyClass(buffer[0]);
+}
+
+function toArray(array) {
+  if (HAS_UINT8ARRAY && array instanceof ArrayBuffer) array = new Uint8Array(array);
+  return Array.prototype.slice.call(array);
+}

package/test/15.useraw.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+var TESTS = [0, 1, 31, 32, 255, 256, 65535, 65536];
+
+function toArray(array) {
+  return Array.prototype.slice.call(array);
+}
+
+describe(TITLE, function() {
+  var options;
+
+  it("useraw (decode)", function() {
+    options = {codec: msgpack.createCodec({useraw: true})};
+
+    // raw
+    assert.deepEqual(toArray(msgpack.decode(new Buffer([0xa1, 65]), options)), [65]);
+
+    // str
+    assert.equal(msgpack.decode(new Buffer([0xa1, 65])), "A");
+  });
+
+  it("useraw (encode)", function() {
+    // raw (String)
+    assert.deepEqual(toArray(msgpack.encode("A", options)), [0xa1, 65]);
+
+    // raw (Buffer)
+    assert.deepEqual(toArray(msgpack.encode(new Buffer([65]), options)), [0xa1, 65]);
+
+    // str
+    assert.deepEqual(toArray(msgpack.encode("A")), [0xa1, 65]);
+  });
+
+  it("useraw (String)", function() {
+    TESTS.forEach(test);
+
+    function test(length) {
+      var source = "";
+      for (var i = 0; i < length; i++) {
+        source += "a";
+      }
+
+      // encode as raw
+      var encoded = msgpack.encode(source, options);
+      assert.ok(encoded.length);
+
+      // decode as raw (Buffer)
+      var buffer = msgpack.decode(encoded, options);
+      assert.ok(Buffer.isBuffer(buffer));
+      assert.equal(buffer.length, length);
+      if (length) assert.equal(buffer[0], 97);
+
+      // decode as str (String)
+      var string = msgpack.decode(encoded);
+      assert.equal(typeof string, "string");
+      assert.equal(string.length, length);
+      assert.equal(string, source);
+    }
+  });
+
+  it("useraw (Buffer)", function() {
+    TESTS.forEach(test);
+
+    function test(length) {
+      var source = new Buffer(length);
+      for (var i = 0; i < length; i++) {
+        source[i] = 65; // "A"
+      }
+
+      // encode as raw
+      var encoded = msgpack.encode(source, options);
+      assert.ok(encoded.length);
+
+      // decode as raw (Buffer)
+      var buffer = msgpack.decode(encoded, options);
+      assert.ok(Buffer.isBuffer(buffer));
+      assert.equal(buffer.length, length);
+      if (length) assert.equal(buffer[0], 65);
+
+      // decode as str (String)
+      var string = msgpack.decode(encoded);
+      assert.equal(typeof string, "string");
+      assert.equal(string.length, length);
+      if (length) assert.equal(string[0], "A");
+    }
+  });
+});

package/test/16.binarraybuffer.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
+
+var TESTS = [0, 1, 31, 32, 255, 256, 65535, 65536];
+
+function toArray(array) {
+  if (array instanceof ArrayBuffer) array = new Uint8Array(array);
+  return Array.prototype.slice.call(array);
+}
+
+// run this test when Uint8Array is available
+var describeSkip = HAS_UINT8ARRAY ? describe : describe.skip;
+
+describeSkip(TITLE, function() {
+  var options;
+
+  it("binarraybuffer (decode)", function() {
+    var decoded;
+    options = {codec: msgpack.createCodec({binarraybuffer: true, preset: true})};
+
+    // bin (Buffer)
+    decoded = msgpack.decode(new Buffer([0xc4, 2, 65, 66]), options);
+    assert.ok(decoded instanceof ArrayBuffer);
+    assert.ok(!Buffer.isBuffer(decoded));
+    assert.deepEqual(toArray(decoded), [65, 66]);
+
+    // bin (Uint8Array)
+    decoded = msgpack.decode(new Uint8Array([0xc4, 2, 97, 98]), options);
+    assert.ok(decoded instanceof ArrayBuffer);
+    assert.ok(!Buffer.isBuffer(decoded));
+    assert.deepEqual(toArray(decoded), [97, 98]);
+
+    // bin (Array)
+    decoded = msgpack.decode([0xc4, 2, 65, 66], options);
+    assert.ok(decoded instanceof ArrayBuffer);
+    assert.ok(!Buffer.isBuffer(decoded));
+    assert.deepEqual(toArray(decoded), [65, 66]);
+  });
+
+  it("binarraybuffer (encode)", function() {
+    // bin (ArrayBuffer)
+    var encoded = msgpack.encode(new Uint8Array([65, 66]).buffer, options);
+    assert.deepEqual(toArray(encoded), [0xc4, 2, 65, 66]);
+  });
+
+  it("binarraybuffer (large)", function() {
+    TESTS.forEach(test);
+
+    function test(length) {
+      var source = new Uint8Array(length);
+      for (var i = 0; i < length; i++) {
+        source[i] = 65; // "A"
+      }
+
+      var encoded = msgpack.encode(source.buffer, options);
+      assert.ok(encoded.length);
+
+      var decoded = msgpack.decode(encoded, options);
+      assert.ok(decoded instanceof ArrayBuffer);
+      assert.ok(!Buffer.isBuffer(decoded));
+      decoded = new Uint8Array(decoded);
+      assert.equal(decoded.length, length);
+      if (length) assert.equal(decoded[0], 65);
+    }
+  });
+
+  // addExtPacker() and getExtPacker() methods need a valid constructor name.
+  // IE10 and iOS7 Safari may give another constructor name than Buffer.
+  // At those cases, below will be encoded as Uint8Array: [0xd5, 0x12, 97, 98]
+  var b = new Buffer(1);
+  var c = b.constructor;
+  var d = (c && c.name === "Buffer") ? it : it.skip;
+  d("encode Buffer ext format 0x1B", function() {
+    // fixext 2 (Buffer)
+    var encoded = msgpack.encode(new Buffer([97, 98]), options);
+    assert.deepEqual(toArray(encoded), [0xd5, 0x1b, 97, 98]);
+  });
+
+  it("decode Buffer ext format 0x1B", function() {
+    // fixext 2 (Buffer)
+    var decoded = msgpack.decode([0xd5, 0x1b, 65, 66], options);
+    assert.ok(Buffer.isBuffer(decoded));
+    assert.deepEqual(toArray(decoded), [65, 66]);
+  });
+});

package/test/17.uint8array.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var Bufferish = require("../lib/bufferish");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
+
+describe(TITLE, function() {
+  it("{}", function() {
+    var encoded = msgpack.encode(1);
+    assert.ok(Buffer.isBuffer(encoded));
+    // assert.ok(!ArrayBuffer.isView(encoded));
+  });
+
+  var it_Uint8Array = HAS_UINT8ARRAY ? it : it.skip;
+  var codecopt = {uint8array: true};
+
+  it_Uint8Array(JSON.stringify(codecopt), function() {
+    var codec = msgpack.createCodec(codecopt);
+    assert.ok(codec);
+    var options = {codec: codec};
+
+    // small data
+    var encoded = msgpack.encode(1, options);
+    if (ArrayBuffer.isView) assert.ok(ArrayBuffer.isView(encoded));
+    assert.ok(Bufferish.isView(encoded));
+    assert.ok(!Buffer.isBuffer(encoded));
+
+    // bigger data
+    var big = new Buffer(8192); // 8KB
+    big[big.length - 1] = 99;
+    var source = [big, big, big, big, big, big, big, big]; // 64KB
+    encoded = msgpack.encode(source, options);
+    if (ArrayBuffer.isView) assert.ok(ArrayBuffer.isView(encoded));
+    assert.ok(Bufferish.isView(encoded));
+    assert.ok(!Buffer.isBuffer(encoded));
+    assert.equal(encoded[encoded.length - 1], 99); // last byte
+  });
+});

package/test/18.utf8.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env mocha -R spec
+
+var assert = require("assert");
+var msgpackJS = "../index";
+var isBrowser = ("undefined" !== typeof window);
+var msgpack = isBrowser && window.msgpack || require(msgpackJS);
+var TITLE = __filename.replace(/^.*\//, "");
+
+var OPTIONS = [{}, {safe: true}];
+
+describe(TITLE, function() {
+  OPTIONS.forEach(function(options) {
+    var suffix = " " + JSON.stringify(options);
+    it("string (ASCII)" + suffix, function() {
+      var string = "a";
+      var array = [0xa1, 0x61];
+      var encoded = msgpack.encode(string, options);
+      var decoded = msgpack.decode(array, options);
+      assert.deepEqual(toArray(encoded), array);
+      assert.equal(decoded, string);
+    });
+
+    it("string (Greek)" + suffix, function() {
+      var string = "α";
+      var array = [0xa2, 0xce, 0xb1];
+      var encoded = msgpack.encode(string, options);
+      var decoded = msgpack.decode(array, options);
+      assert.deepEqual(toArray(encoded), array);
+      assert.equal(decoded, string);
+    });
+
+    it("string (Asian)" + suffix, function() {
+      var string = "亜";
+      var array = [0xa3, 0xe4, 0xba, 0x9c];
+      var encoded = msgpack.encode(string, options);
+      var decoded = msgpack.decode(array, options);
+      assert.deepEqual(toArray(encoded), array);
+      assert.equal(decoded, string);
+    });
+
+    // U+1F426 "🐦" bird
+    // http://unicode.org/emoji/charts/full-emoji-list.html#1f426
+    it("string (Emoji)" + suffix, function() {
+      var string = "\uD83D\uDC26"; // surrogate pair
+      var array_utf8 = [0xa4, 0xf0, 0x9f, 0x90, 0xa6]; // UTF-8
+      var array_cesu8 = [0xa6, 0xed, 0xa0, 0xbd, 0xed, 0xb0, 0xa6]; // CESU-8
+      var encoded = msgpack.encode(string, options);
+      var decoded_utf8 = msgpack.decode(array_utf8, options);
+      var decoded_cesu8 = msgpack.decode(array_cesu8, options);
+      assert.deepEqual(toArray(encoded), array_utf8);
+      assert.equal(decoded_utf8, string);
+      assert.equal(decoded_cesu8, string);
+    });
+  });
+});
+
+function toArray(buffer) {
+  return Array.prototype.slice.call(buffer);
+}