msgpack-lite 0.1.26 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,91 +0,0 @@
1
- #!/usr/bin/env mocha -R spec
2
-
3
- var assert = require("assert");
4
- var msgpackJS = "../index";
5
- var isBrowser = ("undefined" !== typeof window);
6
- var msgpack = isBrowser && window.msgpack || require(msgpackJS);
7
- var TITLE = __filename.replace(/^.*\//, "");
8
- var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
9
-
10
- var TESTS = [0, 1, 31, 32, 255, 256, 65535, 65536];
11
-
12
- function toArray(array) {
13
- if (array instanceof ArrayBuffer) array = new Uint8Array(array);
14
- return Array.prototype.slice.call(array);
15
- }
16
-
17
- // run this test when Uint8Array is available
18
- var describeSkip = HAS_UINT8ARRAY ? describe : describe.skip;
19
-
20
- describeSkip(TITLE, function() {
21
- var options;
22
-
23
- it("binarraybuffer (decode)", function() {
24
- var decoded;
25
- options = {codec: msgpack.createCodec({binarraybuffer: true, preset: true})};
26
-
27
- // bin (Buffer)
28
- decoded = msgpack.decode(new Buffer([0xc4, 2, 65, 66]), options);
29
- assert.ok(decoded instanceof ArrayBuffer);
30
- assert.ok(!Buffer.isBuffer(decoded));
31
- assert.deepEqual(toArray(decoded), [65, 66]);
32
-
33
- // bin (Uint8Array)
34
- decoded = msgpack.decode(new Uint8Array([0xc4, 2, 97, 98]), options);
35
- assert.ok(decoded instanceof ArrayBuffer);
36
- assert.ok(!Buffer.isBuffer(decoded));
37
- assert.deepEqual(toArray(decoded), [97, 98]);
38
-
39
- // bin (Array)
40
- decoded = msgpack.decode([0xc4, 2, 65, 66], options);
41
- assert.ok(decoded instanceof ArrayBuffer);
42
- assert.ok(!Buffer.isBuffer(decoded));
43
- assert.deepEqual(toArray(decoded), [65, 66]);
44
- });
45
-
46
- it("binarraybuffer (encode)", function() {
47
- // bin (ArrayBuffer)
48
- var encoded = msgpack.encode(new Uint8Array([65, 66]).buffer, options);
49
- assert.deepEqual(toArray(encoded), [0xc4, 2, 65, 66]);
50
- });
51
-
52
- it("binarraybuffer (large)", function() {
53
- TESTS.forEach(test);
54
-
55
- function test(length) {
56
- var source = new Uint8Array(length);
57
- for (var i = 0; i < length; i++) {
58
- source[i] = 65; // "A"
59
- }
60
-
61
- var encoded = msgpack.encode(source.buffer, options);
62
- assert.ok(encoded.length);
63
-
64
- var decoded = msgpack.decode(encoded, options);
65
- assert.ok(decoded instanceof ArrayBuffer);
66
- assert.ok(!Buffer.isBuffer(decoded));
67
- decoded = new Uint8Array(decoded);
68
- assert.equal(decoded.length, length);
69
- if (length) assert.equal(decoded[0], 65);
70
- }
71
- });
72
-
73
- // addExtPacker() and getExtPacker() methods need a valid constructor name.
74
- // IE10 and iOS7 Safari may give another constructor name than Buffer.
75
- // At those cases, below will be encoded as Uint8Array: [0xd5, 0x12, 97, 98]
76
- var b = new Buffer(1);
77
- var c = b.constructor;
78
- var d = (c && c.name === "Buffer") ? it : it.skip;
79
- d("encode Buffer ext format 0x1B", function() {
80
- // fixext 2 (Buffer)
81
- var encoded = msgpack.encode(new Buffer([97, 98]), options);
82
- assert.deepEqual(toArray(encoded), [0xd5, 0x1b, 97, 98]);
83
- });
84
-
85
- it("decode Buffer ext format 0x1B", function() {
86
- // fixext 2 (Buffer)
87
- var decoded = msgpack.decode([0xd5, 0x1b, 65, 66], options);
88
- assert.ok(Buffer.isBuffer(decoded));
89
- assert.deepEqual(toArray(decoded), [65, 66]);
90
- });
91
- });
@@ -1,43 +0,0 @@
1
- #!/usr/bin/env mocha -R spec
2
-
3
- var assert = require("assert");
4
- var Bufferish = require("../lib/bufferish");
5
- var msgpackJS = "../index";
6
- var isBrowser = ("undefined" !== typeof window);
7
- var msgpack = isBrowser && window.msgpack || require(msgpackJS);
8
- var TITLE = __filename.replace(/^.*\//, "");
9
-
10
- var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
11
-
12
- describe(TITLE, function() {
13
- it("{}", function() {
14
- var encoded = msgpack.encode(1);
15
- assert.ok(Buffer.isBuffer(encoded));
16
- // assert.ok(!ArrayBuffer.isView(encoded));
17
- });
18
-
19
- var it_Uint8Array = HAS_UINT8ARRAY ? it : it.skip;
20
- var codecopt = {uint8array: true};
21
-
22
- it_Uint8Array(JSON.stringify(codecopt), function() {
23
- var codec = msgpack.createCodec(codecopt);
24
- assert.ok(codec);
25
- var options = {codec: codec};
26
-
27
- // small data
28
- var encoded = msgpack.encode(1, options);
29
- if (ArrayBuffer.isView) assert.ok(ArrayBuffer.isView(encoded));
30
- assert.ok(Bufferish.isView(encoded));
31
- assert.ok(!Buffer.isBuffer(encoded));
32
-
33
- // bigger data
34
- var big = new Buffer(8192); // 8KB
35
- big[big.length - 1] = 99;
36
- var source = [big, big, big, big, big, big, big, big]; // 64KB
37
- encoded = msgpack.encode(source, options);
38
- if (ArrayBuffer.isView) assert.ok(ArrayBuffer.isView(encoded));
39
- assert.ok(Bufferish.isView(encoded));
40
- assert.ok(!Buffer.isBuffer(encoded));
41
- assert.equal(encoded[encoded.length - 1], 99); // last byte
42
- });
43
- });
package/test/18.utf8.js DELETED
@@ -1,59 +0,0 @@
1
- #!/usr/bin/env mocha -R spec
2
-
3
- var assert = require("assert");
4
- var msgpackJS = "../index";
5
- var isBrowser = ("undefined" !== typeof window);
6
- var msgpack = isBrowser && window.msgpack || require(msgpackJS);
7
- var TITLE = __filename.replace(/^.*\//, "");
8
-
9
- var OPTIONS = [{}, {safe: true}];
10
-
11
- describe(TITLE, function() {
12
- OPTIONS.forEach(function(options) {
13
- var suffix = " " + JSON.stringify(options);
14
- it("string (ASCII)" + suffix, function() {
15
- var string = "a";
16
- var array = [0xa1, 0x61];
17
- var encoded = msgpack.encode(string, options);
18
- var decoded = msgpack.decode(array, options);
19
- assert.deepEqual(toArray(encoded), array);
20
- assert.equal(decoded, string);
21
- });
22
-
23
- it("string (Greek)" + suffix, function() {
24
- var string = "α";
25
- var array = [0xa2, 0xce, 0xb1];
26
- var encoded = msgpack.encode(string, options);
27
- var decoded = msgpack.decode(array, options);
28
- assert.deepEqual(toArray(encoded), array);
29
- assert.equal(decoded, string);
30
- });
31
-
32
- it("string (Asian)" + suffix, function() {
33
- var string = "亜";
34
- var array = [0xa3, 0xe4, 0xba, 0x9c];
35
- var encoded = msgpack.encode(string, options);
36
- var decoded = msgpack.decode(array, options);
37
- assert.deepEqual(toArray(encoded), array);
38
- assert.equal(decoded, string);
39
- });
40
-
41
- // U+1F426 "🐦" bird
42
- // http://unicode.org/emoji/charts/full-emoji-list.html#1f426
43
- it("string (Emoji)" + suffix, function() {
44
- var string = "\uD83D\uDC26"; // surrogate pair
45
- var array_utf8 = [0xa4, 0xf0, 0x9f, 0x90, 0xa6]; // UTF-8
46
- var array_cesu8 = [0xa6, 0xed, 0xa0, 0xbd, 0xed, 0xb0, 0xa6]; // CESU-8
47
- var encoded = msgpack.encode(string, options);
48
- var decoded_utf8 = msgpack.decode(array_utf8, options);
49
- var decoded_cesu8 = msgpack.decode(array_cesu8, options);
50
- assert.deepEqual(toArray(encoded), array_utf8);
51
- assert.equal(decoded_utf8, string);
52
- assert.equal(decoded_cesu8, string);
53
- });
54
- });
55
- });
56
-
57
- function toArray(buffer) {
58
- return Array.prototype.slice.call(buffer);
59
- }
@@ -1,220 +0,0 @@
1
- #!/usr/bin/env mocha -R spec
2
-
3
- var assert = require("assert");
4
- var msgpackJS = "../index";
5
- var isBrowser = ("undefined" !== typeof window);
6
- var msgpack = isBrowser && window.msgpack || require(msgpackJS);
7
- var TITLE = __filename.replace(/^.*\//, "");
8
-
9
- var STRING_ASCII = "a";
10
- var STRING_GREEK = "α";
11
- var STRING_ASIAN = "亜";
12
-
13
- // 128K characters
14
- for (var i = 0; i < 17; i++) {
15
- STRING_ASCII = STRING_ASCII + STRING_ASCII;
16
- STRING_GREEK = STRING_GREEK + STRING_GREEK;
17
- STRING_ASIAN = STRING_ASIAN + STRING_ASIAN;
18
- }
19
-
20
- function pattern(min, max, offset) {
21
- var array = [];
22
- var check = {};
23
- var val = min - 1;
24
- while (val <= max) {
25
- if (min <= val && !check[val]) array.push(val);
26
- check[val++] = 1;
27
- if (val <= max && !check[val]) array.push(val);
28
- check[val++] = 1;
29
- if (val <= max && !check[val]) array.push(val);
30
- check[val--] = 1;
31
- val = val ? val * 2 - 1 : 1;
32
- }
33
- return array;
34
- }
35
-
36
- var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
37
-
38
- describe(TITLE, function() {
39
- describe("Buffer", function() {
40
- run_tests();
41
- });
42
-
43
- var describe_Uint8Array = HAS_UINT8ARRAY ? describe : describe.skip;
44
- describe_Uint8Array("Uint8Array", function() {
45
- run_tests({uint8array: true});
46
- });
47
- });
48
-
49
- function run_tests(codecopt) {
50
- var options;
51
-
52
- if (codecopt) it(JSON.stringify(codecopt), function() {
53
- var codec = msgpack.createCodec(codecopt);
54
- assert.ok(codec);
55
- options = {codec: codec};
56
- });
57
-
58
- it("null", function() {
59
- [null, undefined].forEach(function(value) {
60
- var encoded = msgpack.encode(value, options);
61
- var decoded = msgpack.decode(encoded, options);
62
- assert.equal(decoded, value);
63
- });
64
- });
65
-
66
- it("boolean", function() {
67
- [true, false].forEach(function(value) {
68
- var encoded = msgpack.encode(value, options);
69
- var decoded = msgpack.decode(encoded, options);
70
- assert.equal(decoded, value);
71
- });
72
- });
73
-
74
- it("positive int (small)", function() {
75
- pattern(0, 0x40000000).forEach(function(value) {
76
- value = value | 0; // integer
77
- var encoded = msgpack.encode(value, options);
78
- var decoded = msgpack.decode(encoded, options);
79
- assert.equal(decoded, value);
80
- });
81
- });
82
-
83
- it("positive int (large)", function() {
84
- pattern(0x40000000, 0xFFFFFFFF).forEach(function(value) {
85
- var encoded = msgpack.encode(value, options);
86
- var decoded = msgpack.decode(encoded, options);
87
- assert.equal(decoded, value);
88
- });
89
- });
90
-
91
- it("negative int (small)", function() {
92
- pattern(0, 0x40000000).forEach(function(value) {
93
- value = -value | 0; // integer
94
- var encoded = msgpack.encode(value, options);
95
- var decoded = msgpack.decode(encoded, options);
96
- assert.equal(decoded, value);
97
- });
98
- });
99
-
100
- it("negative int (large)", function() {
101
- pattern(0x40000000, 0xFFFFFFFF).forEach(function(value) {
102
- value = -value;
103
- var encoded = msgpack.encode(value, options);
104
- var decoded = msgpack.decode(encoded, options);
105
- assert.equal(decoded, value);
106
- });
107
- });
108
-
109
- it("float", function() {
110
- [1.1, 10.01, 100.001, 1000.0001, 10000.00001, 100000.000001, 1000000.0000001].forEach(function(value) {
111
- var encoded = msgpack.encode(value, options);
112
- var decoded = msgpack.decode(encoded, options);
113
- assert.equal(decoded, value);
114
- });
115
- });
116
-
117
- it("string (ASCII)", function() {
118
- this.timeout(30000);
119
- pattern(0, 65537).forEach(function(length) {
120
- var value = STRING_ASCII.substr(0, length);
121
- var encoded = msgpack.encode(value, options);
122
- var decoded = msgpack.decode(encoded, options);
123
- assert.equal(decoded, value);
124
- });
125
- });
126
-
127
- it("string (GREEK)", function() {
128
- this.timeout(30000);
129
- pattern(0, 65537).forEach(function(length) {
130
- var value = STRING_GREEK.substr(0, length);
131
- var encoded = msgpack.encode(value, options);
132
- var decoded = msgpack.decode(encoded, options);
133
- assert.equal(decoded, value);
134
- });
135
- });
136
-
137
- it("string (ASIAN)", function() {
138
- this.timeout(30000);
139
- pattern(0, 65537).forEach(function(length) {
140
- var value = STRING_ASIAN.substr(0, length);
141
- var encoded = msgpack.encode(value, options);
142
- var decoded = msgpack.decode(encoded, options);
143
- assert.equal(decoded, value);
144
- });
145
- });
146
-
147
- it("array (small)", function() {
148
- pattern(0, 257).forEach(function(length, idx) {
149
- var value = new Array(length);
150
- for (var i = 0; i < length; i++) {
151
- value[i] = String.fromCharCode(i);
152
- }
153
- assert.equal(value.length, length);
154
- var encoded = msgpack.encode(value, options);
155
- var decoded = msgpack.decode(encoded, options);
156
- assert.equal(decoded.length, length);
157
- assert.equal(decoded[0], value[0]);
158
- assert.equal(decoded[length - 1], value[length - 1]);
159
- });
160
- });
161
-
162
- it("array (large)", function() {
163
- this.timeout(30000);
164
- pattern(0, 65537).forEach(function(length) {
165
- var value = new Array(length);
166
- assert.equal(value.length, length);
167
- var encoded = msgpack.encode(value, options);
168
- var decoded = msgpack.decode(encoded, options);
169
- assert.equal(decoded.length, length);
170
- assert.equal(decoded[0], value[0]);
171
- assert.equal(decoded[length - 1], value[length - 1]);
172
- });
173
- });
174
-
175
- it("object map (small)", function() {
176
- pattern(0, 257).forEach(function(length) {
177
- var value = {};
178
- for (var i = 0; i < length; i++) {
179
- var key = String.fromCharCode(i);
180
- value[key] = length;
181
- }
182
- assert.equal(Object.keys(value).length, length);
183
- var encoded = msgpack.encode(value, options);
184
- var decoded = msgpack.decode(encoded, options);
185
- assert.equal(Object.keys(decoded).length, length);
186
- assert.equal(decoded[0], value[0]);
187
- assert.equal(decoded[length - 1], value[length - 1]);
188
- });
189
- });
190
-
191
- it("object map (large)", function() {
192
- this.timeout(30000);
193
- pattern(65536, 65537).forEach(function(length) {
194
- var value = {};
195
- for (var i = 0; i < length; i++) {
196
- value[i] = length;
197
- }
198
- assert.equal(Object.keys(value).length, length);
199
- var encoded = msgpack.encode(value, options);
200
- var decoded = msgpack.decode(encoded, options);
201
- assert.equal(Object.keys(decoded).length, length);
202
- assert.equal(decoded[0], value[0]);
203
- assert.equal(decoded[length - 1], value[length - 1]);
204
- });
205
- });
206
-
207
- it("buffer", function() {
208
- this.timeout(30000);
209
- pattern(2, 65537).forEach(function(length, idx) {
210
- var value = new Buffer(length);
211
- value.fill(idx);
212
- assert.equal(value.length, length);
213
- var encoded = msgpack.encode(value, options);
214
- var decoded = msgpack.decode(encoded, options);
215
- assert.equal(decoded.length, length);
216
- assert.equal(decoded[0], value[0]);
217
- assert.equal(decoded[length - 1], value[length - 1]);
218
- });
219
- });
220
- }
package/test/21.ext.js DELETED
@@ -1,85 +0,0 @@
1
- #!/usr/bin/env mocha -R spec
2
-
3
- /*jshint -W053 */
4
-
5
- var assert = require("assert");
6
- var msgpackJS = "../index";
7
- var isBrowser = ("undefined" !== typeof window);
8
- var msgpack = isBrowser && window.msgpack || require(msgpackJS);
9
- var TITLE = __filename.replace(/^.*\//, "");
10
-
11
- describe(TITLE, function() {
12
- it("Boolean", function() {
13
- [true, false].forEach(function(value) {
14
- var source = new Boolean(value);
15
- assert.equal(source - 0, value - 0);
16
- var encoded = msgpack.encode(source);
17
- assert.equal(encoded[0], 0xD4, "preset ext format failure. (128 means map format)"); // fixext 1
18
- assert.equal(encoded[1], 0x0B); // Boolean
19
- var decoded = msgpack.decode(encoded);
20
- assert.equal(decoded - 0, source - 0);
21
- assert.ok(decoded instanceof Boolean);
22
- });
23
- });
24
-
25
- it("Date", function() {
26
- var source = new Date();
27
- var encoded = msgpack.encode(source);
28
- assert.equal(encoded[0], 0xC7, "preset ext format failure. (128 means map format)"); // ext 8
29
- assert.equal(encoded[1], 0x09); // 1+8
30
- assert.equal(encoded[2], 0x0D); // Date
31
- var decoded = msgpack.decode(encoded);
32
- assert.equal(decoded - 0, source - 0);
33
- assert.ok(decoded instanceof Date);
34
- });
35
-
36
- var ERROR_TYPES = ["Error", "EvalError", "RangeError", "ReferenceError", "SyntaxError", "TypeError", "URIError"];
37
- ERROR_TYPES.forEach(function(name, idx) {
38
- var Class = global[name];
39
- it(name, function() {
40
- var message = "foo:" + idx;
41
- var source = new Class(message);
42
- var encoded = msgpack.encode(source);
43
- var decoded = msgpack.decode(encoded);
44
- assert.equal(decoded + "", source + "");
45
- assert.equal(decoded.name, name);
46
- assert.equal(decoded.message, message);
47
- assert.ok(decoded instanceof Class);
48
- });
49
- });
50
-
51
- it("RegExp", function() {
52
- var source = new RegExp("foo");
53
- var encoded = msgpack.encode(source);
54
- var decoded = msgpack.decode(encoded);
55
- assert.equal(decoded + "", source + "");
56
- assert.ok(decoded instanceof RegExp);
57
- });
58
-
59
- it("RegExp //g", function() {
60
- var source = /foo\/bar/g;
61
- var encoded = msgpack.encode(source);
62
- var decoded = msgpack.decode(encoded);
63
- assert.equal(decoded + "", source + "");
64
- assert.ok(decoded instanceof RegExp);
65
- });
66
-
67
- it("Number", function() {
68
- var source = new Number(123.456);
69
- var encoded = msgpack.encode(source);
70
- assert.equal(encoded[0], 0xC7); // ext 8
71
- assert.equal(encoded[1], 0x09); // 1+8
72
- assert.equal(encoded[2], 0x0F); // Number
73
- var decoded = msgpack.decode(encoded);
74
- assert.equal(decoded - 0, source - 0);
75
- assert.ok(decoded instanceof Number);
76
- });
77
-
78
- it("String", function() {
79
- var source = new String("qux");
80
- var encoded = msgpack.encode(source);
81
- var decoded = msgpack.decode(encoded);
82
- assert.equal(decoded + "", source + "");
83
- assert.ok(decoded instanceof String);
84
- });
85
- });
@@ -1,79 +0,0 @@
1
- #!/usr/bin/env mocha -R spec
2
-
3
- /*jshint -W053 */
4
-
5
- var assert = require("assert");
6
- var msgpackJS = "../index";
7
- var isBrowser = ("undefined" !== typeof window);
8
- var msgpack = isBrowser && window.msgpack || require(msgpackJS);
9
- var TITLE = __filename.replace(/^.*\//, "");
10
-
11
- var TYPED_ARRAY = {
12
- "Int8Array": [0, 1, 2, 126, 127, -128, -127, -2, -1],
13
- "Uint8Array": [0, 1, 2, 253, 254, 255],
14
- "Uint8ClampedArray": [0, 1, 2, 253, 254, 255],
15
- "Int16Array": [0, 1, 2, 32766, 32767, -32768, -32767, -2, -1],
16
- "Uint16Array": [0, 1, 2, 65534, 65535],
17
- "Int32Array": [0, 1, 2, 2147483646, 2147483647],
18
- "Uint32Array": [0, 1, 2, 4294967294, 4294967295],
19
- "Float32Array": [0, 1, 0.5, 0.25, -0.25, -0.5, -1],
20
- "Float64Array": [0, 1, 0.5, 0.25, -0.25, -0.5, -1]
21
- };
22
-
23
- var ARRAY_BUFFER = {
24
- "ArrayBuffer": [0, 1, 2, 253, 254, 255]
25
- };
26
-
27
- var DATA_VIEW = {
28
- "DataView": [0, 1, 2, 253, 254, 255]
29
- };
30
-
31
- describe(TITLE, function() {
32
- Object.keys(TYPED_ARRAY).forEach(function(name) {
33
- var Class = global[name];
34
- var skip = Class ? it : it.skip;
35
- skip(name, function() {
36
- var sample = TYPED_ARRAY[name];
37
- var source = new Class(sample);
38
- assert.ok(source instanceof Class);
39
- assert.equal(source.length, sample.length);
40
- var encoded = msgpack.encode(source);
41
- var decoded = msgpack.decode(encoded);
42
- var actual = Array.prototype.slice.call(decoded);
43
- assert.deepEqual(actual, sample);
44
- assert.ok(decoded instanceof Class);
45
- });
46
- });
47
-
48
- Object.keys(ARRAY_BUFFER).forEach(function(name) {
49
- var Class = global[name];
50
- var skip = Class ? it : it.skip;
51
- skip(name, function() {
52
- var sample = ARRAY_BUFFER[name];
53
- var source = (new Uint8Array(sample)).buffer;
54
- assert.ok(source instanceof Class);
55
- assert.equal(source.byteLength, sample.length);
56
- var encoded = msgpack.encode(source);
57
- var decoded = msgpack.decode(encoded);
58
- var actual = Array.prototype.slice.call(new Uint8Array(decoded));
59
- assert.deepEqual(actual, sample);
60
- assert.ok(decoded instanceof Class);
61
- });
62
- });
63
-
64
- Object.keys(DATA_VIEW).forEach(function(name) {
65
- var Class = global[name];
66
- var skip = Class ? it : it.skip;
67
- skip(name, function() {
68
- var sample = DATA_VIEW[name];
69
- var source = new DataView((new Uint8Array(sample)).buffer);
70
- assert.ok(source instanceof Class);
71
- assert.equal(source.byteLength, sample.length);
72
- var encoded = msgpack.encode(source);
73
- var decoded = msgpack.decode(encoded);
74
- var actual = Array.prototype.slice.call(new Uint8Array(decoded.buffer));
75
- assert.deepEqual(actual, sample);
76
- assert.ok(decoded instanceof Class);
77
- });
78
- });
79
- });
@@ -1,79 +0,0 @@
1
- #!/usr/bin/env mocha -R spec
2
-
3
- /*jshint -W053 */
4
-
5
- var assert = require("assert");
6
- var msgpackJS = "../index";
7
- var isBrowser = ("undefined" !== typeof window);
8
- var msgpack = isBrowser && window.msgpack || require(msgpackJS);
9
- var TITLE = __filename.replace(/^.*\//, "");
10
-
11
- var HAS_UINT8ARRAY = ("undefined" !== typeof Uint8Array);
12
-
13
- describe(TITLE, function() {
14
- it("ExtBuffer (0x00)", function() {
15
- testExtBuffer(0);
16
- });
17
-
18
- it("ExtBuffer (0x20-0xFF)", function() {
19
- for (var i = 32; i < 256; i++) {
20
- testExtBuffer(i);
21
- }
22
- });
23
-
24
- it("ExtBuffer Array (0x20-0xFF)", function() {
25
- for (var i = 32; i < 256; i++) {
26
- testExtBufferArray(i);
27
- }
28
- });
29
-
30
- function testExtBuffer(type) {
31
- // fixext 8 -- 0xd7
32
- var header = new Buffer([0xd7, type]);
33
- var content = new Buffer(8);
34
- for (var i = 0; i < 8; i++) {
35
- content[i] = (type + i) & 0x7F;
36
- }
37
- var source = Buffer.concat([header, content]);
38
- var decoded = msgpack.decode(source);
39
- assert.equal(decoded.type, type);
40
- assert.equal(decoded.buffer.length, content.length);
41
- assert.deepEqual(toArray(decoded.buffer), toArray(content));
42
- var encoded = msgpack.encode(decoded);
43
- assert.deepEqual(toArray(encoded), toArray(source));
44
- }
45
-
46
- // Unpack and re-pack an array of extension types.
47
- // Tests, among other things, that the right number of bytes are
48
- // consumed with each ext type read.
49
- function testExtBufferArray(type) {
50
- function content(j) {
51
- var x = j * type;
52
- return Buffer([x & 0x7F, (x + 1) & 0x7F]);
53
- }
54
- // fixarray len 10
55
- var arrayHeader = new Buffer([0x9a]);
56
- var fullBuffer = arrayHeader;
57
- for (var j = 0; j < 10; j++) {
58
- // fixext 2 -- 0xd5
59
- var header = new Buffer([0xd5, type]);
60
- fullBuffer = Buffer.concat([fullBuffer, header, content(j)]);
61
- }
62
- var decoded = msgpack.decode(fullBuffer);
63
- assert.equal(true, decoded instanceof Array);
64
- assert.equal(decoded.length, 10);
65
- for (j = 0; j < 10; j++) {
66
- assert.equal(decoded[j].type, type);
67
- assert.equal(decoded[j].buffer.length, 2);
68
- assert.deepEqual(decoded[j].buffer, content(j));
69
- }
70
- var encoded = msgpack.encode(decoded);
71
- assert.deepEqual(encoded, fullBuffer);
72
- }
73
-
74
- });
75
-
76
- function toArray(array) {
77
- if (HAS_UINT8ARRAY && array instanceof ArrayBuffer) array = new Uint8Array(array);
78
- return Array.prototype.slice.call(array);
79
- }