cbor-x 1.3.2 → 1.3.3

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