msgpackr 1.5.7 → 1.6.2

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.
Files changed (11) hide show
  1. package/dist/index.js +1929 -1917
  2. package/dist/index.min.js +67 -68
  3. package/dist/node.cjs +1994 -1979
  4. package/dist/test.js +697 -674
  5. package/index.d.ts +23 -12
  6. package/node-index.js +23 -20
  7. package/pack.js +935 -931
  8. package/package.json +14 -2
  9. package/unpack.d.ts +52 -50
  10. package/unpack.js +1061 -1053
  11. package/dist/str.cjs +0 -100
package/dist/test.js CHANGED
@@ -3,680 +3,703 @@
3
3
 
4
4
  chai = chai && Object.prototype.hasOwnProperty.call(chai, 'default') ? chai['default'] : chai;
5
5
 
6
- const sampleData = JSON.parse(fs.readFileSync(new URL('./example4.json', (document.currentScript && document.currentScript.src || new URL('test.js', document.baseURI).href))));
7
- function tryRequire(module) {
8
- try {
9
- return require(module)
10
- } catch(error) {
11
- return {}
12
- }
13
- }
14
- //if (typeof chai === 'undefined') { chai = require('chai') }
15
- var assert = chai.assert;
16
- //if (typeof msgpackr === 'undefined') { msgpackr = require('..') }
17
- var Packr = msgpackr.Packr;
18
- var unpack = msgpackr.unpack;
19
- var unpackMultiple = msgpackr.unpackMultiple;
20
- var roundFloat32 = msgpackr.roundFloat32;
21
- var pack = msgpackr.pack;
22
- var DECIMAL_FIT = msgpackr.FLOAT32_OPTIONS.DECIMAL_FIT;
23
-
24
- var addExtension = msgpackr.addExtension;
25
- var zlib = tryRequire('zlib');
26
- var deflateSync = zlib.deflateSync;
27
- var inflateSync = zlib.inflateSync;
28
- var deflateSync = zlib.brotliCompressSync;
29
- var inflateSync = zlib.brotliDecompressSync;
30
- var constants = zlib.constants;
31
-
32
- var ITERATIONS = 4000;
33
-
34
- suite('msgpackr basic tests', function(){
35
- test('pack/unpack data', function(){
36
- var data = {
37
- data: [
38
- { a: 1, name: 'one', type: 'odd', isOdd: true },
39
- { a: 2, name: 'two', type: 'even'},
40
- { a: 3, name: 'three', type: 'odd', isOdd: true },
41
- { a: 4, name: 'four', type: 'even'},
42
- { a: 5, name: 'five', type: 'odd', isOdd: true },
43
- { a: 6, name: 'six', type: 'even', isOdd: null }
44
- ],
45
- description: 'some names',
46
- types: ['odd', 'even'],
47
- convertEnumToNum: [
48
- { prop: 'test' },
49
- { prop: 'test' },
50
- { prop: 'test' },
51
- { prop: 1 },
52
- { prop: 2 },
53
- { prop: [undefined] },
54
- { prop: null }
55
- ]
56
- };
57
- let structures = [];
58
- let packr = new Packr({ structures });
59
- var serialized = packr.pack(data);
60
- serialized = packr.pack(data);
61
- serialized = packr.pack(data);
62
- var deserialized = packr.unpack(serialized);
63
- assert.deepEqual(deserialized, data);
64
- });
65
-
66
- test('mixed structures', function(){
67
- let data1 = { a: 1, b: 2, c: 3 };
68
- let data2 = { a: 1, b: 2, d: 4 };
69
- let data3 = { a: 1, b: 2, e: 5 };
70
- let structures = [];
71
- let packr = new Packr({ structures });
72
- var serialized = packr.pack(data1);
73
- var deserialized = packr.unpack(serialized);
74
- assert.deepEqual(deserialized, data1);
75
- var serialized = packr.pack(data2);
76
- var deserialized = packr.unpack(serialized);
77
- assert.deepEqual(deserialized, data2);
78
- var serialized = packr.pack(data3);
79
- var deserialized = packr.unpack(serialized);
80
- assert.deepEqual(deserialized, data3);
81
- });
82
-
83
- test('mixed array', function(){
84
- var data = [
85
- 'one',
86
- 'two',
87
- 'one',
88
- 10,
89
- 11,
90
- null,
91
- true,
92
- 'three',
93
- 'three',
94
- 'one', [
95
- 3, -5, -50, -400,1.3, -5.3, true
96
- ]
97
- ];
98
- let structures = [];
99
- let packr = new Packr({ structures });
100
- var serialized = packr.pack(data);
101
- var deserialized = packr.unpack(serialized);
102
- assert.deepEqual(deserialized, data);
103
- });
104
-
105
- test('255 chars', function() {
106
- const data = 'RRZG9A6I7xupPeOZhxcOcioFsuhszGOdyDUcbRf4Zef2kdPIfC9RaLO4jTM5JhuZvTsF09fbRHMGtqk7YAgu3vespeTe9l61ziZ6VrMnYu2CamK96wCkmz0VUXyqaiUoTPgzk414LS9yYrd5uh7w18ksJF5SlC2e91rukWvNqAZJjYN3jpkqHNOFchCwFrhbxq2Lrv1kSJPYCx9blRg2hGmYqTbElLTZHv20iNqwZeQbRMgSBPT6vnbCBPnOh1W';
107
- var serialized = pack(data);
108
- var deserialized = unpack(serialized);
109
- assert.equal(deserialized, data);
110
- });
111
-
112
- test('pack/unpack sample data', function(){
113
- var data = sampleData;
114
- var serialized = pack(data);
115
- var deserialized = unpack(serialized);
116
- assert.deepEqual(deserialized, data);
117
- var serialized = pack(data);
118
- var deserialized = unpack(serialized);
119
- assert.deepEqual(deserialized, data);
120
- });
121
- test('pack/unpack sample data with records', function(){
122
- var data = sampleData;
123
- let structures = [];
124
- let packr = new Packr({ structures, useRecords: true });
125
- var serialized = packr.pack(data);
126
- var deserialized = packr.unpack(serialized);
127
- assert.deepEqual(deserialized, data);
128
- });
129
- test('pack/unpack sample data with bundled strings', function(){
130
- var data = sampleData;
131
- let packr = new Packr({ /*structures,*/ useRecords: false, bundleStrings: true });
132
- var serialized = packr.pack(data);
133
- var deserialized = packr.unpack(serialized);
134
- assert.deepEqual(deserialized, data);
135
- });
136
- if (typeof Buffer != 'undefined')
137
- test('replace data', function(){
138
- var data1 = {
139
- data: [
140
- { a: 1, name: 'one', type: 'odd', isOdd: true, a: '13 characters' },
141
- { a: 2, name: 'two', type: 'even', a: '11 characte' },
142
- { a: 3, name: 'three', type: 'odd', isOdd: true, a: '12 character' },
143
- { a: 4, name: 'four', type: 'even', a: '9 charact'},
144
- { a: 5, name: 'five', type: 'odd', isOdd: true, a: '14 characters!' },
145
- { a: 6, name: 'six', type: 'even', isOdd: null }
146
- ],
147
- };
148
- var data2 = {
149
- data: [
150
- { foo: 7, name: 'one', type: 'odd', isOdd: true },
151
- { foo: 8, name: 'two', type: 'even'},
152
- { foo: 9, name: 'three', type: 'odd', isOdd: true },
153
- { foo: 10, name: 'four', type: 'even'},
154
- { foo: 11, name: 'five', type: 'odd', isOdd: true },
155
- { foo: 12, name: 'six', type: 'even', isOdd: null }
156
- ],
157
- };
158
- var serialized1 = pack(data1);
159
- var serialized2 = pack(data2);
160
- var b = Buffer.alloc(8000);
161
- serialized1.copy(b);
162
- var deserialized1 = unpack(b, serialized1.length);
163
- serialized2.copy(b);
164
- var deserialized2 = unpack(b, serialized2.length);
165
- assert.deepEqual(deserialized1, data1);
166
- assert.deepEqual(deserialized2, data2);
167
- });
168
-
169
- test('extended class pack/unpack', function(){
170
- function Extended() {
171
-
172
- }
173
- Extended.prototype.getDouble = function() {
174
- return this.value * 2
175
- };
176
- var instance = new Extended();
177
- instance.value = 4;
178
- instance.string = 'decode this: ᾜ';
179
- var data = {
180
- prop1: 'has multi-byte: ᾜ',
181
- extendedInstance: instance,
182
- prop2: 'more string',
183
- num: 3,
184
- };
185
- let packr = new Packr();
186
- addExtension({
187
- Class: Extended,
188
- type: 11,
189
- unpack: function(buffer) {
190
- let e = new Extended();
191
- let data = packr.unpack(buffer);
192
- e.value = data[0];
193
- e.string = data[1];
194
- return e
195
- },
196
- pack: function(instance) {
197
- return packr.pack([instance.value, instance.string])
198
- }
199
- });
200
- var serialized = pack(data);
201
- var deserialized = unpack(serialized);
202
- assert.deepEqual(data, deserialized);
203
- assert.equal(deserialized.extendedInstance.getDouble(), 8);
204
- });
205
- test('extended class pack/unpack custom size', function(){
206
- function TestClass() {
207
-
208
- }
209
- addExtension({
210
- Class: TestClass,
211
- type: 0x01,
212
- pack() {
213
- return typeof Buffer != 'undefined' ? Buffer.alloc(256) : new Uint8Array(256)
214
- },
215
- unpack(data) {
216
- return data.length
217
- }
218
- });
219
- let result = unpack(pack(new TestClass()));
220
- assert.equal(result, 256);
221
- });
222
-
223
- test('extended class read/write', function(){
224
- function Extended() {
225
-
226
- }
227
- Extended.prototype.getDouble = function() {
228
- return this.value * 2
229
- };
230
- var instance = new Extended();
231
- instance.value = 4;
232
- instance.string = 'decode this: ᾜ';
233
- var data = {
234
- prop1: 'has multi-byte: ᾜ',
235
- extendedInstance: instance,
236
- prop2: 'more string',
237
- num: 3,
238
- };
239
- let packr = new Packr();
240
- addExtension({
241
- Class: Extended,
242
- type: 12,
243
- read: function(data) {
244
- let e = new Extended();
245
- e.value = data[0];
246
- e.string = data[1];
247
- return e
248
- },
249
- write: function(instance) {
250
- return [instance.value, instance.string]
251
- }
252
- });
253
- var serialized = pack(data);
254
- var deserialized = unpack(serialized);
255
- assert.deepEqual(data, deserialized);
256
- assert.equal(deserialized.extendedInstance.getDouble(), 8);
257
- });
258
-
259
- test.skip('text decoder', function() {
260
- let td = new TextDecoder('ISO-8859-15');
261
- let b = Buffer.alloc(3);
262
- for (var i = 0; i < 256; i++) {
263
- b[0] = i;
264
- b[1] = 0;
265
- b[2] = 0;
266
- let s = td.decode(b);
267
- if (!require('msgpackr-extract').isOneByte(s)) {
268
- console.log(i.toString(16), s.length);
269
- }
270
- }
271
- });
272
-
273
- test('structured cloning: self reference', function() {
274
- let object = {
275
- test: 'string',
276
- children: [
277
- { name: 'child' }
278
- ]
279
- };
280
- object.self = object;
281
- object.children[1] = object;
282
- object.children[2] = object.children[0];
283
- object.childrenAgain = object.children;
284
- let packr = new Packr({
285
- moreTypes: true,
286
- structuredClone: true,
287
- });
288
- var serialized = packr.pack(object);
289
- var deserialized = packr.unpack(serialized);
290
- assert.equal(deserialized.self, deserialized);
291
- assert.equal(deserialized.children[0].name, 'child');
292
- assert.equal(deserialized.children[1], deserialized);
293
- assert.equal(deserialized.children[0], deserialized.children[2]);
294
- assert.equal(deserialized.children, deserialized.childrenAgain);
295
- });
296
-
297
- test('structured cloning: types', function() {
298
- let b = typeof Buffer != 'undefined' ? Buffer.alloc(20) : new Uint8Array(20);
299
- let fa = new Float32Array(b.buffer, 8, 2);
300
- fa[0] = 2.25;
301
- fa[1] = 6;
302
- let object = {
303
- error: new Error('test'),
304
- set: new Set(['a', 'b']),
305
- regexp: /test/gi,
306
- float32Array: fa,
307
- uint16Array: new Uint16Array([3,4])
308
- };
309
- let packr = new Packr({
310
- moreTypes: true,
311
- structuredClone: true,
312
- });
313
- var serialized = packr.pack(object);
314
- var deserialized = packr.unpack(serialized);
315
- assert.deepEqual(Array.from(deserialized.set), Array.from(object.set));
316
- assert.equal(deserialized.error.message, object.error.message);
317
- assert.equal(deserialized.regexp.test('TEST'), true);
318
- assert.equal(deserialized.float32Array.constructor.name, 'Float32Array');
319
- assert.equal(deserialized.float32Array[0], 2.25);
320
- assert.equal(deserialized.float32Array[1], 6);
321
- assert.equal(deserialized.uint16Array.constructor.name, 'Uint16Array');
322
- assert.equal(deserialized.uint16Array[0], 3);
323
- assert.equal(deserialized.uint16Array[1], 4);
324
- });
325
-
326
- test('object without prototype', function(){
327
- var data = Object.create(null);
328
- data.test = 3;
329
- var serialized = pack(data);
330
- var deserialized = unpack(serialized);
331
- assert.deepEqual(deserialized, data);
332
- });
333
-
334
- test('many shared structures', function() {
335
- let data = [];
336
- for (let i = 0; i < 200; i++) {
337
- data.push({['a' + i]: i});
338
- }
339
- let structures = [];
340
- let savedStructures;
341
- let packr = new Packr({
342
- structures,
343
- saveStructures(structures) {
344
- savedStructures = structures;
345
- }
346
- });
347
- var serializedWith32 = packr.pack(data);
348
- assert.equal(savedStructures.length, 32);
349
- var deserialized = packr.unpack(serializedWith32);
350
- assert.deepEqual(deserialized, data);
351
- structures = structures.slice(0, 32);
352
- packr = new Packr({
353
- structures,
354
- maxSharedStructures: 100,
355
- saveStructures(structures) {
356
- savedStructures = structures;
357
- }
358
- });
359
- deserialized = packr.unpack(serializedWith32);
360
- assert.deepEqual(deserialized, data);
361
- structures = structures.slice(0, 32);
362
- packr = new Packr({
363
- structures,
364
- maxSharedStructures: 100,
365
- saveStructures(structures) {
366
- savedStructures = structures;
367
- }
368
- });
369
- let serialized = packr.pack(data);
370
- assert.equal(savedStructures.length, 100);
371
- deserialized = packr.unpack(serialized);
372
- assert.deepEqual(deserialized, data);
373
-
374
- deserialized = packr.unpack(serializedWith32);
375
- assert.deepEqual(deserialized, data);
376
- assert.equal(savedStructures.length, 100);
377
-
378
- deserialized = packr.unpack(serialized);
379
- assert.deepEqual(deserialized, data);
380
- assert.equal(packr.structures.sharedLength, 100);
381
- });
382
- test('more shared structures', function() {
383
- const structures = [];
384
- for (let i = 0; i < 40; i++) {
385
- structures.push(['a' + i]);
386
- }
387
- const structures2 = [...structures];
388
- const packr = new Packr({
389
- getStructures() {
390
- return structures
391
- },
392
- saveStructures(structures) {
393
- },
394
- maxSharedStructures: 100
395
- });
396
- const packr2 = new Packr({
397
- getStructures() {
398
- return structures2
399
- },
400
- saveStructures(structures) {
401
- },
402
- maxSharedStructures: 100
403
- });
404
- const inputData = {a35: 35};
405
- const buffer = packr.pack(inputData);
406
- const outputData = packr2.decode(buffer);
407
- assert.deepEqual(inputData, outputData);
408
- });
409
-
410
- test('big buffer', function() {
411
- var size = 100000000;
412
- var data = new Uint8Array(size).fill(1);
413
- var packed = pack(data);
414
- var unpacked = unpack(packed);
415
- assert.equal(unpacked.length, size);
416
- });
417
-
418
- test('random strings', function(){
419
- var data = [];
420
- for (var i = 0; i < 2000; i++) {
421
- var str = 'test';
422
- while (Math.random() < 0.7 && str.length < 0x100000) {
423
- str = str + String.fromCharCode(90/(Math.random() + 0.01)) + str;
424
- }
425
- data.push(str);
426
- }
427
- var serialized = pack(data);
428
- var deserialized = unpack(serialized);
429
- assert.deepEqual(deserialized, data);
430
- });
431
-
432
- test('map/date', function(){
433
- var map = new Map();
434
- map.set(4, 'four');
435
- map.set('three', 3);
436
-
437
-
438
- var data = {
439
- map: map,
440
- date: new Date(1532219539733),
441
- farFutureDate: new Date(3532219539133),
442
- fartherFutureDate: new Date('2106-08-05T18:48:20.323Z'),
443
- ancient: new Date(-3532219539133),
444
- invalidDate: new Date('invalid')
445
- };
446
- let packr = new Packr();
447
- var serialized = packr.pack(data);
448
- var deserialized = packr.unpack(serialized);
449
- assert.equal(deserialized.map.get(4), 'four');
450
- assert.equal(deserialized.map.get('three'), 3);
451
- assert.equal(deserialized.date.getTime(), 1532219539733);
452
- assert.equal(deserialized.farFutureDate.getTime(), 3532219539133);
453
- assert.equal(deserialized.fartherFutureDate.toISOString(), '2106-08-05T18:48:20.323Z');
454
- assert.equal(deserialized.ancient.getTime(), -3532219539133);
455
- assert.equal(deserialized.invalidDate.toString(), 'Invalid Date');
456
- });
457
- test('map/date with options', function(){
458
- var map = new Map();
459
- map.set(4, 'four');
460
- map.set('three', 3);
461
-
462
-
463
- var data = {
464
- map: map,
465
- date: new Date(1532219539011),
466
- invalidDate: new Date('invalid')
467
- };
468
- let packr = new Packr({
469
- mapsAsObjects: true,
470
- useTimestamp32: true,
471
- onInvalidDate: () => 'Custom invalid date'
472
- });
473
- var serialized = packr.pack(data);
474
- var deserialized = packr.unpack(serialized);
475
- assert.equal(deserialized.map[4], 'four');
476
- assert.equal(deserialized.map.three, 3);
477
- assert.equal(deserialized.date.getTime(), 1532219539000);
478
- assert.equal(deserialized.invalidDate, 'Custom invalid date');
479
- });
480
- test('key caching', function() {
481
- var data = {
482
- foo: 2,
483
- bar: 'test',
484
- four: 4,
485
- seven: 7,
486
- foz: 3,
487
- };
488
- var serialized = pack(data);
489
- var deserialized = unpack(serialized);
490
- assert.deepEqual(deserialized, data);
491
- // do multiple times to test caching
492
- var serialized = pack(data);
493
- var deserialized = unpack(serialized);
494
- assert.deepEqual(deserialized, data);
495
- var serialized = pack(data);
496
- var deserialized = unpack(serialized);
497
- assert.deepEqual(deserialized, data);
498
- });
499
- test('strings', function() {
500
- var data = [''];
501
- var serialized = pack(data);
502
- var deserialized = unpack(serialized);
503
- assert.deepEqual(deserialized, data);
504
- // do multiple times
505
- var serialized = pack(data);
506
- var deserialized = unpack(serialized);
507
- assert.deepEqual(deserialized, data);
508
- data = 'decode this: ᾜ';
509
- var serialized = pack(data);
510
- var deserialized = unpack(serialized);
511
- assert.deepEqual(deserialized, data);
512
- data = 'decode this that is longer but without any non-latin characters';
513
- var serialized = pack(data);
514
- var deserialized = unpack(serialized);
515
- assert.deepEqual(deserialized, data);
516
- });
517
- test('decimal float32', function() {
518
- var data = {
519
- a: 2.526,
520
- b: 0.0035235,
521
- c: 0.00000000000352501,
522
- d: 3252.77,
523
- };
524
- let packr = new Packr({
525
- useFloat32: DECIMAL_FIT
526
- });
527
- var serialized = packr.pack(data);
528
- assert.equal(serialized.length, 32);
529
- var deserialized = packr.unpack(serialized);
530
- assert.deepEqual(deserialized, data);
531
- });
532
- test('bigint to float', function() {
533
- var data = {
534
- a: 325283295382932843n
535
- };
536
- let packr = new Packr({
537
- int64AsNumber: true
538
- });
539
- var serialized = packr.pack(data);
540
- var deserialized = packr.unpack(serialized);
541
- assert.deepEqual(deserialized.a, 325283295382932843);
542
- });
543
- test('numbers', function(){
544
- var data = {
545
- bigEncodable: 48978578104322,
546
- dateEpoch: 1530886513200,
547
- realBig: 3432235352353255323,
548
- decimal: 32.55234,
549
- negative: -34.11,
550
- exponential: 0.234e123,
551
- tiny: 3.233e-120,
552
- zero: 0,
553
- //negativeZero: -0,
554
- Infinity: Infinity
555
- };
556
- var serialized = pack(data);
557
- var deserialized = unpack(serialized);
558
- assert.deepEqual(deserialized, data);
559
- });
560
- test('bigint', function(){
561
- var data = {
562
- bigintSmall: 352n,
563
- bigintSmallNegative: -333335252n,
564
- bigintBig: 2n**64n - 1n, // biggest possible
565
- bigintBigNegative: -(2n**63n), // largest negative
566
- mixedWithNormal: 44,
567
- };
568
- var serialized = pack(data);
569
- var deserialized = unpack(serialized);
570
- assert.deepEqual(deserialized, data);
571
- var tooBigInt = {
572
- tooBig: 2n**66n
573
- };
574
- assert.throws(function(){ serialized = pack(tooBigInt); });
575
- let packr = new Packr({
576
- largeBigIntToFloat: true
577
- });
578
- serialized = packr.pack(tooBigInt);
579
- deserialized = unpack(serialized);
580
- assert.isTrue(deserialized.tooBig > 2n**65n);
581
- });
582
-
583
- test('roundFloat32', function() {
584
- assert.equal(roundFloat32(0.00333000003), 0.00333);
585
- assert.equal(roundFloat32(43.29999999993), 43.3);
586
- });
587
-
588
- test('buffers', function(){
589
- var data = {
590
- buffer1: new Uint8Array([2,3,4]),
591
- buffer2: new Uint8Array(pack(sampleData))
592
- };
593
- var serialized = pack(data);
594
- var deserialized = unpack(serialized);
595
- assert.deepEqual(deserialized, data);
596
- });
597
-
598
- test('notepack test', function() {
599
- const data = {
600
- foo: 1,
601
- bar: [1, 2, 3, 4, 'abc', 'def'],
602
- foobar: {
603
- foo: true,
604
- bar: -2147483649,
605
- foobar: {
606
- foo: new Uint8Array([1, 2, 3, 4, 5]),
607
- bar: 1.5,
608
- foobar: [true, false, 'abcdefghijkmonpqrstuvwxyz']
609
- }
610
- }
611
- };
612
- var serialized = pack(data);
613
- var deserialized = unpack(serialized);
614
- var deserialized = unpack(serialized);
615
- var deserialized = unpack(serialized);
616
- assert.deepEqual(deserialized, data);
617
- });
618
-
619
- test('utf16 causing expansion', function() {
620
- this.timeout(10000);
621
- let data = {fixstr: 'ᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝ', str8:'ᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝ'};
622
- var serialized = pack(data);
623
- var deserialized = unpack(serialized);
624
- assert.deepEqual(deserialized, data);
625
- });
626
- test('unpackMultiple', () => {
627
- let values = unpackMultiple(new Uint8Array([1, 2, 3, 4]));
628
- assert.deepEqual(values, [1, 2, 3, 4]);
629
- values = [];
630
- unpackMultiple(new Uint8Array([1, 2, 3, 4]), value => values.push(value));
631
- assert.deepEqual(values, [1, 2, 3, 4]);
632
- });
633
-
634
- });
635
- suite('msgpackr performance tests', function(){
636
- test('performance JSON.parse', function() {
637
- var data = sampleData;
638
- this.timeout(10000);
639
- var serialized = JSON.stringify(data);
640
- console.log('JSON size', serialized.length);
641
- for (var i = 0; i < ITERATIONS; i++) {
642
- var deserialized = JSON.parse(serialized);
643
- }
644
- });
645
- test('performance JSON.stringify', function() {
646
- var data = sampleData;
647
- this.timeout(10000);
648
- for (var i = 0; i < ITERATIONS; i++) {
649
- var serialized = JSON.stringify(data);
650
- }
651
- });
652
- test('performance unpack', function() {
653
- var data = sampleData;
654
- this.timeout(10000);
655
- let structures = [];
656
- var serialized = pack(data);
657
- console.log('MessagePack size', serialized.length);
658
- let packr = new Packr({ structures, bundleStrings: false });
659
- var serialized = packr.pack(data);
660
- console.log('msgpackr w/ record ext size', serialized.length);
661
- for (var i = 0; i < ITERATIONS; i++) {
662
- var deserialized = packr.unpack(serialized);
663
- }
664
- });
665
- test('performance pack', function() {
666
- var data = sampleData;
667
- this.timeout(10000);
668
- let structures = [];
669
- let packr = new Packr({ structures, bundleStrings: false });
670
- let buffer = typeof Buffer != 'undefined' ? Buffer.alloc(0x10000) : new Uint8Array(0x10000);
671
-
672
- for (var i = 0; i < ITERATIONS; i++) {
673
- //serialized = pack(data, { shared: sharedStructure })
674
- packr.useBuffer(buffer);
675
- var serialized = packr.pack(data);
676
- //var serializedGzip = deflateSync(serialized)
677
- }
678
- //console.log('serialized', serialized.length, global.propertyComparisons)
679
- });
6
+ const sampleData = JSON.parse(fs.readFileSync(new URL('./example4.json', (document.currentScript && document.currentScript.src || new URL('test.js', document.baseURI).href))));
7
+ function tryRequire(module) {
8
+ try {
9
+ return require(module)
10
+ } catch(error) {
11
+ return {}
12
+ }
13
+ }
14
+ //if (typeof chai === 'undefined') { chai = require('chai') }
15
+ var assert = chai.assert;
16
+ //if (typeof msgpackr === 'undefined') { msgpackr = require('..') }
17
+ var Packr = msgpackr.Packr;
18
+ var Unpackr = msgpackr.Unpackr;
19
+ var unpack = msgpackr.unpack;
20
+ var unpackMultiple = msgpackr.unpackMultiple;
21
+ var roundFloat32 = msgpackr.roundFloat32;
22
+ var pack = msgpackr.pack;
23
+ var DECIMAL_FIT = msgpackr.FLOAT32_OPTIONS.DECIMAL_FIT;
24
+
25
+ var addExtension = msgpackr.addExtension;
26
+ var zlib = tryRequire('zlib');
27
+ var deflateSync = zlib.deflateSync;
28
+ var inflateSync = zlib.inflateSync;
29
+ var deflateSync = zlib.brotliCompressSync;
30
+ var inflateSync = zlib.brotliDecompressSync;
31
+ var constants = zlib.constants;
32
+
33
+ var ITERATIONS = 4000;
34
+
35
+ suite('msgpackr basic tests', function(){
36
+ test('pack/unpack data', function(){
37
+ var data = {
38
+ data: [
39
+ { a: 1, name: 'one', type: 'odd', isOdd: true },
40
+ { a: 2, name: 'two', type: 'even'},
41
+ { a: 3, name: 'three', type: 'odd', isOdd: true },
42
+ { a: 4, name: 'four', type: 'even'},
43
+ { a: 5, name: 'five', type: 'odd', isOdd: true },
44
+ { a: 6, name: 'six', type: 'even', isOdd: null }
45
+ ],
46
+ description: 'some names',
47
+ types: ['odd', 'even'],
48
+ convertEnumToNum: [
49
+ { prop: 'test' },
50
+ { prop: 'test' },
51
+ { prop: 'test' },
52
+ { prop: 1 },
53
+ { prop: 2 },
54
+ { prop: [undefined] },
55
+ { prop: null }
56
+ ]
57
+ };
58
+ let structures = [];
59
+ let packr = new Packr({ structures });
60
+ var serialized = packr.pack(data);
61
+ serialized = packr.pack(data);
62
+ serialized = packr.pack(data);
63
+ var deserialized = packr.unpack(serialized);
64
+ assert.deepEqual(deserialized, data);
65
+ });
66
+
67
+ test('mixed structures', function(){
68
+ let data1 = { a: 1, b: 2, c: 3 };
69
+ let data2 = { a: 1, b: 2, d: 4 };
70
+ let data3 = { a: 1, b: 2, e: 5 };
71
+ let structures = [];
72
+ let packr = new Packr({ structures });
73
+ var serialized = packr.pack(data1);
74
+ var deserialized = packr.unpack(serialized);
75
+ assert.deepEqual(deserialized, data1);
76
+ var serialized = packr.pack(data2);
77
+ var deserialized = packr.unpack(serialized);
78
+ assert.deepEqual(deserialized, data2);
79
+ var serialized = packr.pack(data3);
80
+ var deserialized = packr.unpack(serialized);
81
+ assert.deepEqual(deserialized, data3);
82
+ });
83
+
84
+ test('mixed array', function(){
85
+ var data = [
86
+ 'one',
87
+ 'two',
88
+ 'one',
89
+ 10,
90
+ 11,
91
+ null,
92
+ true,
93
+ 'three',
94
+ 'three',
95
+ 'one', [
96
+ 3, -5, -50, -400,1.3, -5.3, true
97
+ ]
98
+ ];
99
+ let structures = [];
100
+ let packr = new Packr({ structures });
101
+ var serialized = packr.pack(data);
102
+ var deserialized = packr.unpack(serialized);
103
+ assert.deepEqual(deserialized, data);
104
+ });
105
+
106
+ test('255 chars', function() {
107
+ const data = 'RRZG9A6I7xupPeOZhxcOcioFsuhszGOdyDUcbRf4Zef2kdPIfC9RaLO4jTM5JhuZvTsF09fbRHMGtqk7YAgu3vespeTe9l61ziZ6VrMnYu2CamK96wCkmz0VUXyqaiUoTPgzk414LS9yYrd5uh7w18ksJF5SlC2e91rukWvNqAZJjYN3jpkqHNOFchCwFrhbxq2Lrv1kSJPYCx9blRg2hGmYqTbElLTZHv20iNqwZeQbRMgSBPT6vnbCBPnOh1W';
108
+ var serialized = pack(data);
109
+ var deserialized = unpack(serialized);
110
+ assert.equal(deserialized, data);
111
+ });
112
+
113
+ test('pack/unpack sample data', function(){
114
+ var data = sampleData;
115
+ var serialized = pack(data);
116
+ var deserialized = unpack(serialized);
117
+ assert.deepEqual(deserialized, data);
118
+ var serialized = pack(data);
119
+ var deserialized = unpack(serialized);
120
+ assert.deepEqual(deserialized, data);
121
+ });
122
+ test('pack/unpack sample data with records', function(){
123
+ var data = sampleData;
124
+ let structures = [];
125
+ let packr = new Packr({ structures, useRecords: true });
126
+ var serialized = packr.pack(data);
127
+ var deserialized = packr.unpack(serialized);
128
+ assert.deepEqual(deserialized, data);
129
+ });
130
+ test('pack/unpack sample data with bundled strings', function(){
131
+ var data = sampleData;
132
+ let packr = new Packr({ /*structures,*/ useRecords: false, bundleStrings: true });
133
+ var serialized = packr.pack(data);
134
+ var deserialized = packr.unpack(serialized);
135
+ assert.deepEqual(deserialized, data);
136
+ });
137
+ test('pack/unpack empty data with bundled strings', function(){
138
+ var data = {};
139
+ let packr = new Packr({ bundleStrings: true });
140
+ var serialized = packr.pack(data);
141
+ var deserialized = packr.unpack(serialized);
142
+ assert.deepEqual(deserialized, data);
143
+ });
144
+ test('pack/unpack sequential data', function(){
145
+ var data = { foo:1, bar: 2 };
146
+ let packr = new Packr({ sequential: true });
147
+ let unpackr = new Unpackr({ sequential: true });
148
+ var serialized = packr.pack(data);
149
+ var deserialized = unpackr.unpack(serialized);
150
+ assert.deepEqual(deserialized, data);
151
+ var serialized = packr.pack(data);
152
+ var deserialized = unpackr.unpack(serialized);
153
+ assert.deepEqual(deserialized, data);
154
+ });
155
+ if (typeof Buffer != 'undefined')
156
+ test('replace data', function(){
157
+ var data1 = {
158
+ data: [
159
+ { a: 1, name: 'one', type: 'odd', isOdd: true, a: '13 characters' },
160
+ { a: 2, name: 'two', type: 'even', a: '11 characte' },
161
+ { a: 3, name: 'three', type: 'odd', isOdd: true, a: '12 character' },
162
+ { a: 4, name: 'four', type: 'even', a: '9 charact'},
163
+ { a: 5, name: 'five', type: 'odd', isOdd: true, a: '14 characters!' },
164
+ { a: 6, name: 'six', type: 'even', isOdd: null }
165
+ ],
166
+ };
167
+ var data2 = {
168
+ data: [
169
+ { foo: 7, name: 'one', type: 'odd', isOdd: true },
170
+ { foo: 8, name: 'two', type: 'even'},
171
+ { foo: 9, name: 'three', type: 'odd', isOdd: true },
172
+ { foo: 10, name: 'four', type: 'even'},
173
+ { foo: 11, name: 'five', type: 'odd', isOdd: true },
174
+ { foo: 12, name: 'six', type: 'even', isOdd: null }
175
+ ],
176
+ };
177
+ var serialized1 = pack(data1);
178
+ var serialized2 = pack(data2);
179
+ var b = Buffer.alloc(8000);
180
+ serialized1.copy(b);
181
+ var deserialized1 = unpack(b, serialized1.length);
182
+ serialized2.copy(b);
183
+ var deserialized2 = unpack(b, serialized2.length);
184
+ assert.deepEqual(deserialized1, data1);
185
+ assert.deepEqual(deserialized2, data2);
186
+ });
187
+
188
+ test('compact 123', function() {
189
+ assert.equal(pack(123).length, 1);
190
+ });
191
+
192
+ test('extended class pack/unpack', function(){
193
+ function Extended() {
194
+
195
+ }
196
+ Extended.prototype.getDouble = function() {
197
+ return this.value * 2
198
+ };
199
+ var instance = new Extended();
200
+ instance.value = 4;
201
+ instance.string = 'decode this: ᾜ';
202
+ var data = {
203
+ prop1: 'has multi-byte: ᾜ',
204
+ extendedInstance: instance,
205
+ prop2: 'more string',
206
+ num: 3,
207
+ };
208
+ let packr = new Packr();
209
+ addExtension({
210
+ Class: Extended,
211
+ type: 11,
212
+ unpack: function(buffer) {
213
+ let e = new Extended();
214
+ let data = packr.unpack(buffer);
215
+ e.value = data[0];
216
+ e.string = data[1];
217
+ return e
218
+ },
219
+ pack: function(instance) {
220
+ return packr.pack([instance.value, instance.string])
221
+ }
222
+ });
223
+ var serialized = pack(data);
224
+ var deserialized = unpack(serialized);
225
+ assert.deepEqual(data, deserialized);
226
+ assert.equal(deserialized.extendedInstance.getDouble(), 8);
227
+ });
228
+ test('extended class pack/unpack custom size', function(){
229
+ function TestClass() {
230
+
231
+ }
232
+ addExtension({
233
+ Class: TestClass,
234
+ type: 0x01,
235
+ pack() {
236
+ return typeof Buffer != 'undefined' ? Buffer.alloc(256) : new Uint8Array(256)
237
+ },
238
+ unpack(data) {
239
+ return data.length
240
+ }
241
+ });
242
+ let result = unpack(pack(new TestClass()));
243
+ assert.equal(result, 256);
244
+ });
245
+
246
+ test('extended class read/write', function(){
247
+ function Extended() {
248
+
249
+ }
250
+ Extended.prototype.getDouble = function() {
251
+ return this.value * 2
252
+ };
253
+ var instance = new Extended();
254
+ instance.value = 4;
255
+ instance.string = 'decode this: ᾜ';
256
+ var data = {
257
+ prop1: 'has multi-byte: ᾜ',
258
+ extendedInstance: instance,
259
+ prop2: 'more string',
260
+ num: 3,
261
+ };
262
+ let packr = new Packr();
263
+ addExtension({
264
+ Class: Extended,
265
+ type: 12,
266
+ read: function(data) {
267
+ let e = new Extended();
268
+ e.value = data[0];
269
+ e.string = data[1];
270
+ return e
271
+ },
272
+ write: function(instance) {
273
+ return [instance.value, instance.string]
274
+ }
275
+ });
276
+ var serialized = pack(data);
277
+ var deserialized = unpack(serialized);
278
+ assert.deepEqual(data, deserialized);
279
+ assert.equal(deserialized.extendedInstance.getDouble(), 8);
280
+ });
281
+
282
+ test.skip('text decoder', function() {
283
+ let td = new TextDecoder('ISO-8859-15');
284
+ let b = Buffer.alloc(3);
285
+ for (var i = 0; i < 256; i++) {
286
+ b[0] = i;
287
+ b[1] = 0;
288
+ b[2] = 0;
289
+ let s = td.decode(b);
290
+ if (!require('msgpackr-extract').isOneByte(s)) {
291
+ console.log(i.toString(16), s.length);
292
+ }
293
+ }
294
+ });
295
+
296
+ test('structured cloning: self reference', function() {
297
+ let object = {
298
+ test: 'string',
299
+ children: [
300
+ { name: 'child' }
301
+ ]
302
+ };
303
+ object.self = object;
304
+ object.children[1] = object;
305
+ object.children[2] = object.children[0];
306
+ object.childrenAgain = object.children;
307
+ let packr = new Packr({
308
+ moreTypes: true,
309
+ structuredClone: true,
310
+ });
311
+ var serialized = packr.pack(object);
312
+ var deserialized = packr.unpack(serialized);
313
+ assert.equal(deserialized.self, deserialized);
314
+ assert.equal(deserialized.children[0].name, 'child');
315
+ assert.equal(deserialized.children[1], deserialized);
316
+ assert.equal(deserialized.children[0], deserialized.children[2]);
317
+ assert.equal(deserialized.children, deserialized.childrenAgain);
318
+ });
319
+
320
+ test('structured cloning: types', function() {
321
+ let b = typeof Buffer != 'undefined' ? Buffer.alloc(20) : new Uint8Array(20);
322
+ let fa = new Float32Array(b.buffer, 8, 2);
323
+ fa[0] = 2.25;
324
+ fa[1] = 6;
325
+ let object = {
326
+ error: new Error('test'),
327
+ set: new Set(['a', 'b']),
328
+ regexp: /test/gi,
329
+ float32Array: fa,
330
+ uint16Array: new Uint16Array([3,4])
331
+ };
332
+ let packr = new Packr({
333
+ moreTypes: true,
334
+ structuredClone: true,
335
+ });
336
+ var serialized = packr.pack(object);
337
+ var deserialized = packr.unpack(serialized);
338
+ assert.deepEqual(Array.from(deserialized.set), Array.from(object.set));
339
+ assert.equal(deserialized.error.message, object.error.message);
340
+ assert.equal(deserialized.regexp.test('TEST'), true);
341
+ assert.equal(deserialized.float32Array.constructor.name, 'Float32Array');
342
+ assert.equal(deserialized.float32Array[0], 2.25);
343
+ assert.equal(deserialized.float32Array[1], 6);
344
+ assert.equal(deserialized.uint16Array.constructor.name, 'Uint16Array');
345
+ assert.equal(deserialized.uint16Array[0], 3);
346
+ assert.equal(deserialized.uint16Array[1], 4);
347
+ });
348
+
349
+ test('object without prototype', function(){
350
+ var data = Object.create(null);
351
+ data.test = 3;
352
+ var serialized = pack(data);
353
+ var deserialized = unpack(serialized);
354
+ assert.deepEqual(deserialized, data);
355
+ });
356
+
357
+ test('many shared structures', function() {
358
+ let data = [];
359
+ for (let i = 0; i < 200; i++) {
360
+ data.push({['a' + i]: i});
361
+ }
362
+ let structures = [];
363
+ let savedStructures;
364
+ let packr = new Packr({
365
+ structures,
366
+ saveStructures(structures) {
367
+ savedStructures = structures;
368
+ }
369
+ });
370
+ var serializedWith32 = packr.pack(data);
371
+ assert.equal(savedStructures.length, 32);
372
+ var deserialized = packr.unpack(serializedWith32);
373
+ assert.deepEqual(deserialized, data);
374
+ structures = structures.slice(0, 32);
375
+ packr = new Packr({
376
+ structures,
377
+ maxSharedStructures: 100,
378
+ saveStructures(structures) {
379
+ savedStructures = structures;
380
+ }
381
+ });
382
+ deserialized = packr.unpack(serializedWith32);
383
+ assert.deepEqual(deserialized, data);
384
+ structures = structures.slice(0, 32);
385
+ packr = new Packr({
386
+ structures,
387
+ maxSharedStructures: 100,
388
+ saveStructures(structures) {
389
+ savedStructures = structures;
390
+ }
391
+ });
392
+ let serialized = packr.pack(data);
393
+ assert.equal(savedStructures.length, 100);
394
+ deserialized = packr.unpack(serialized);
395
+ assert.deepEqual(deserialized, data);
396
+
397
+ deserialized = packr.unpack(serializedWith32);
398
+ assert.deepEqual(deserialized, data);
399
+ assert.equal(savedStructures.length, 100);
400
+
401
+ deserialized = packr.unpack(serialized);
402
+ assert.deepEqual(deserialized, data);
403
+ assert.equal(packr.structures.sharedLength, 100);
404
+ });
405
+ test('more shared structures', function() {
406
+ const structures = [];
407
+ for (let i = 0; i < 40; i++) {
408
+ structures.push(['a' + i]);
409
+ }
410
+ const structures2 = [...structures];
411
+ const packr = new Packr({
412
+ getStructures() {
413
+ return structures
414
+ },
415
+ saveStructures(structures) {
416
+ },
417
+ maxSharedStructures: 100
418
+ });
419
+ const packr2 = new Packr({
420
+ getStructures() {
421
+ return structures2
422
+ },
423
+ saveStructures(structures) {
424
+ },
425
+ maxSharedStructures: 100
426
+ });
427
+ const inputData = {a35: 35};
428
+ const buffer = packr.pack(inputData);
429
+ const outputData = packr2.decode(buffer);
430
+ assert.deepEqual(inputData, outputData);
431
+ });
432
+
433
+ test('big buffer', function() {
434
+ var size = 100000000;
435
+ var data = new Uint8Array(size).fill(1);
436
+ var packed = pack(data);
437
+ var unpacked = unpack(packed);
438
+ assert.equal(unpacked.length, size);
439
+ });
440
+
441
+ test('random strings', function(){
442
+ var data = [];
443
+ for (var i = 0; i < 2000; i++) {
444
+ var str = 'test';
445
+ while (Math.random() < 0.7 && str.length < 0x100000) {
446
+ str = str + String.fromCharCode(90/(Math.random() + 0.01)) + str;
447
+ }
448
+ data.push(str);
449
+ }
450
+ var serialized = pack(data);
451
+ var deserialized = unpack(serialized);
452
+ assert.deepEqual(deserialized, data);
453
+ });
454
+
455
+ test('map/date', function(){
456
+ var map = new Map();
457
+ map.set(4, 'four');
458
+ map.set('three', 3);
459
+
460
+
461
+ var data = {
462
+ map: map,
463
+ date: new Date(1532219539733),
464
+ farFutureDate: new Date(3532219539133),
465
+ fartherFutureDate: new Date('2106-08-05T18:48:20.323Z'),
466
+ ancient: new Date(-3532219539133),
467
+ invalidDate: new Date('invalid')
468
+ };
469
+ let packr = new Packr();
470
+ var serialized = packr.pack(data);
471
+ var deserialized = packr.unpack(serialized);
472
+ assert.equal(deserialized.map.get(4), 'four');
473
+ assert.equal(deserialized.map.get('three'), 3);
474
+ assert.equal(deserialized.date.getTime(), 1532219539733);
475
+ assert.equal(deserialized.farFutureDate.getTime(), 3532219539133);
476
+ assert.equal(deserialized.fartherFutureDate.toISOString(), '2106-08-05T18:48:20.323Z');
477
+ assert.equal(deserialized.ancient.getTime(), -3532219539133);
478
+ assert.equal(deserialized.invalidDate.toString(), 'Invalid Date');
479
+ });
480
+ test('map/date with options', function(){
481
+ var map = new Map();
482
+ map.set(4, 'four');
483
+ map.set('three', 3);
484
+
485
+
486
+ var data = {
487
+ map: map,
488
+ date: new Date(1532219539011),
489
+ invalidDate: new Date('invalid')
490
+ };
491
+ let packr = new Packr({
492
+ mapsAsObjects: true,
493
+ useTimestamp32: true,
494
+ onInvalidDate: () => 'Custom invalid date'
495
+ });
496
+ var serialized = packr.pack(data);
497
+ var deserialized = packr.unpack(serialized);
498
+ assert.equal(deserialized.map[4], 'four');
499
+ assert.equal(deserialized.map.three, 3);
500
+ assert.equal(deserialized.date.getTime(), 1532219539000);
501
+ assert.equal(deserialized.invalidDate, 'Custom invalid date');
502
+ });
503
+ test('key caching', function() {
504
+ var data = {
505
+ foo: 2,
506
+ bar: 'test',
507
+ four: 4,
508
+ seven: 7,
509
+ foz: 3,
510
+ };
511
+ var serialized = pack(data);
512
+ var deserialized = unpack(serialized);
513
+ assert.deepEqual(deserialized, data);
514
+ // do multiple times to test caching
515
+ var serialized = pack(data);
516
+ var deserialized = unpack(serialized);
517
+ assert.deepEqual(deserialized, data);
518
+ var serialized = pack(data);
519
+ var deserialized = unpack(serialized);
520
+ assert.deepEqual(deserialized, data);
521
+ });
522
+ test('strings', function() {
523
+ var data = [''];
524
+ var serialized = pack(data);
525
+ var deserialized = unpack(serialized);
526
+ assert.deepEqual(deserialized, data);
527
+ // do multiple times
528
+ var serialized = pack(data);
529
+ var deserialized = unpack(serialized);
530
+ assert.deepEqual(deserialized, data);
531
+ data = 'decode this: ᾜ';
532
+ var serialized = pack(data);
533
+ var deserialized = unpack(serialized);
534
+ assert.deepEqual(deserialized, data);
535
+ data = 'decode this that is longer but without any non-latin characters';
536
+ var serialized = pack(data);
537
+ var deserialized = unpack(serialized);
538
+ assert.deepEqual(deserialized, data);
539
+ });
540
+ test('decimal float32', function() {
541
+ var data = {
542
+ a: 2.526,
543
+ b: 0.0035235,
544
+ c: 0.00000000000352501,
545
+ d: 3252.77,
546
+ };
547
+ let packr = new Packr({
548
+ useFloat32: DECIMAL_FIT
549
+ });
550
+ var serialized = packr.pack(data);
551
+ assert.equal(serialized.length, 32);
552
+ var deserialized = packr.unpack(serialized);
553
+ assert.deepEqual(deserialized, data);
554
+ });
555
+ test('bigint to float', function() {
556
+ var data = {
557
+ a: 325283295382932843n
558
+ };
559
+ let packr = new Packr({
560
+ int64AsNumber: true
561
+ });
562
+ var serialized = packr.pack(data);
563
+ var deserialized = packr.unpack(serialized);
564
+ assert.deepEqual(deserialized.a, 325283295382932843);
565
+ });
566
+ test('numbers', function(){
567
+ var data = {
568
+ bigEncodable: 48978578104322,
569
+ dateEpoch: 1530886513200,
570
+ realBig: 3432235352353255323,
571
+ decimal: 32.55234,
572
+ negative: -34.11,
573
+ exponential: 0.234e123,
574
+ tiny: 3.233e-120,
575
+ zero: 0,
576
+ //negativeZero: -0,
577
+ Infinity: Infinity
578
+ };
579
+ var serialized = pack(data);
580
+ var deserialized = unpack(serialized);
581
+ assert.deepEqual(deserialized, data);
582
+ });
583
+ test('bigint', function(){
584
+ var data = {
585
+ bigintSmall: 352n,
586
+ bigintSmallNegative: -333335252n,
587
+ bigintBig: 2n**64n - 1n, // biggest possible
588
+ bigintBigNegative: -(2n**63n), // largest negative
589
+ mixedWithNormal: 44,
590
+ };
591
+ var serialized = pack(data);
592
+ var deserialized = unpack(serialized);
593
+ assert.deepEqual(deserialized, data);
594
+ var tooBigInt = {
595
+ tooBig: 2n**66n
596
+ };
597
+ assert.throws(function(){ serialized = pack(tooBigInt); });
598
+ let packr = new Packr({
599
+ largeBigIntToFloat: true
600
+ });
601
+ serialized = packr.pack(tooBigInt);
602
+ deserialized = unpack(serialized);
603
+ assert.isTrue(deserialized.tooBig > 2n**65n);
604
+ });
605
+
606
+ test('roundFloat32', function() {
607
+ assert.equal(roundFloat32(0.00333000003), 0.00333);
608
+ assert.equal(roundFloat32(43.29999999993), 43.3);
609
+ });
610
+
611
+ test('buffers', function(){
612
+ var data = {
613
+ buffer1: new Uint8Array([2,3,4]),
614
+ buffer2: new Uint8Array(pack(sampleData))
615
+ };
616
+ var serialized = pack(data);
617
+ var deserialized = unpack(serialized);
618
+ assert.deepEqual(deserialized, data);
619
+ });
620
+
621
+ test('notepack test', function() {
622
+ const data = {
623
+ foo: 1,
624
+ bar: [1, 2, 3, 4, 'abc', 'def'],
625
+ foobar: {
626
+ foo: true,
627
+ bar: -2147483649,
628
+ foobar: {
629
+ foo: new Uint8Array([1, 2, 3, 4, 5]),
630
+ bar: 1.5,
631
+ foobar: [true, false, 'abcdefghijkmonpqrstuvwxyz']
632
+ }
633
+ }
634
+ };
635
+ var serialized = pack(data);
636
+ var deserialized = unpack(serialized);
637
+ var deserialized = unpack(serialized);
638
+ var deserialized = unpack(serialized);
639
+ assert.deepEqual(deserialized, data);
640
+ });
641
+
642
+ test('utf16 causing expansion', function() {
643
+ this.timeout(10000);
644
+ let data = {fixstr: 'ᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝ', str8:'ᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝᾐᾑᾒᾓᾔᾕᾖᾗᾘᾙᾚᾛᾜᾝ'};
645
+ var serialized = pack(data);
646
+ var deserialized = unpack(serialized);
647
+ assert.deepEqual(deserialized, data);
648
+ });
649
+ test('unpackMultiple', () => {
650
+ let values = unpackMultiple(new Uint8Array([1, 2, 3, 4]));
651
+ assert.deepEqual(values, [1, 2, 3, 4]);
652
+ values = [];
653
+ unpackMultiple(new Uint8Array([1, 2, 3, 4]), value => values.push(value));
654
+ assert.deepEqual(values, [1, 2, 3, 4]);
655
+ });
656
+
657
+ });
658
+ suite('msgpackr performance tests', function(){
659
+ test('performance JSON.parse', function() {
660
+ var data = sampleData;
661
+ this.timeout(10000);
662
+ var serialized = JSON.stringify(data);
663
+ console.log('JSON size', serialized.length);
664
+ for (var i = 0; i < ITERATIONS; i++) {
665
+ var deserialized = JSON.parse(serialized);
666
+ }
667
+ });
668
+ test('performance JSON.stringify', function() {
669
+ var data = sampleData;
670
+ this.timeout(10000);
671
+ for (var i = 0; i < ITERATIONS; i++) {
672
+ var serialized = JSON.stringify(data);
673
+ }
674
+ });
675
+ test('performance unpack', function() {
676
+ var data = sampleData;
677
+ this.timeout(10000);
678
+ let structures = [];
679
+ var serialized = pack(data);
680
+ console.log('MessagePack size', serialized.length);
681
+ let packr = new Packr({ structures, bundleStrings: false });
682
+ var serialized = packr.pack(data);
683
+ console.log('msgpackr w/ record ext size', serialized.length);
684
+ for (var i = 0; i < ITERATIONS; i++) {
685
+ var deserialized = packr.unpack(serialized);
686
+ }
687
+ });
688
+ test('performance pack', function() {
689
+ var data = sampleData;
690
+ this.timeout(10000);
691
+ let structures = [];
692
+ let packr = new Packr({ structures, bundleStrings: false });
693
+ let buffer = typeof Buffer != 'undefined' ? Buffer.alloc(0x10000) : new Uint8Array(0x10000);
694
+
695
+ for (var i = 0; i < ITERATIONS; i++) {
696
+ //serialized = pack(data, { shared: sharedStructure })
697
+ packr.useBuffer(buffer);
698
+ var serialized = packr.pack(data);
699
+ //var serializedGzip = deflateSync(serialized)
700
+ }
701
+ //console.log('serialized', serialized.length, global.propertyComparisons)
702
+ });
680
703
  });
681
704
 
682
705
  }(msgpackr, chai, fs));