mirror of
https://github.com/flynx/serialize.js.git
synced 2026-07-10 19:20:56 +00:00
291 lines
7.6 KiB
JavaScript
Executable File
291 lines
7.6 KiB
JavaScript
Executable File
#!/usr/bin/env node
|
|
/**********************************************************************
|
|
*
|
|
*
|
|
*
|
|
**********************************************************************/
|
|
((typeof define)[0]=='u'?function(f){module.exports=f(require)}:define)
|
|
(function(require){ var module={} // make module AMD/node compatible...
|
|
/*********************************************************************/
|
|
|
|
var test = require('ig-test')
|
|
|
|
var eJSON = require('./serialize')
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
// Test data format:
|
|
// [
|
|
// <data>,
|
|
// // tags (optionsal)
|
|
// json, - if the data is JSON-compatible, value true|false (default: undefined)
|
|
// ...
|
|
// ]
|
|
//
|
|
|
|
var json = true
|
|
var ejson = false
|
|
|
|
var pre_cycle = true
|
|
|
|
// XXX test whitespace handling...
|
|
var setups = test.Setups({
|
|
'true': function(assert){
|
|
return ['true', json] },
|
|
'false': function(assert){
|
|
return ['false', json] },
|
|
'null': function(assert){
|
|
return ['null', json] },
|
|
'undefined': function(assert){
|
|
return ['undefined'] },
|
|
'NaN': function(assert){
|
|
return ['NaN'] },
|
|
|
|
number: function(assert){
|
|
return ['123', json] },
|
|
'number-neg': function(assert){
|
|
return ['-123', json] },
|
|
//'number-pos': function(assert){
|
|
// return ['+123', json] },
|
|
'number-exp': function(assert){
|
|
return ['1e+100', json] },
|
|
'number-exp-neg': function(assert){
|
|
return ['1e-100', json] },
|
|
'number-zero': function(assert){
|
|
return ['0', json] },
|
|
'float-a': function(assert){
|
|
return ['0.123', json] },
|
|
'float-b': function(assert){
|
|
return ['1.23', json] },
|
|
'bigint': function(assert){
|
|
return ['999999999999999999999n'] },
|
|
// XXX need a way to test this...
|
|
//'float-a': function(assert){
|
|
// return ['.123'] },
|
|
//'float-c': function(assert){
|
|
// return ['123.'] },
|
|
// XXX also test:
|
|
// hex/bin/orc/...
|
|
Infinity: function(assert){
|
|
return ['Infinity'] },
|
|
nInfinity: function(assert){
|
|
return ['-Infinity'] },
|
|
|
|
// XXX also test diffrerent quotations...
|
|
string: function(assert){
|
|
return ['"string"', json] },
|
|
'string-empty': function(assert){
|
|
return ['""', json] },
|
|
'string-multiline': function(assert){
|
|
return ['"string\\nstring\\nstring"', json] },
|
|
|
|
'array-empty': function(assert){
|
|
return ['[]', json] },
|
|
'array-sparse-a': function(assert){
|
|
return ['[<empty>]'] },
|
|
'array-sparse-b': function(assert){
|
|
return ['["a",<empty>]'] },
|
|
'array-sparse-c': function(assert){
|
|
return ['[<empty>,"a"]'] },
|
|
'array-sparse-d': function(assert){
|
|
return ['[<empty>,1,<empty>,<empty>,2,<empty>]'] },
|
|
|
|
'object-empty': function(assert){
|
|
return ['{}', json] },
|
|
|
|
'set-empty': function(assert){
|
|
return ['Set([])'] },
|
|
|
|
'map-empty': function(assert){
|
|
return ['Map([])'] },
|
|
|
|
'function': function(assert){
|
|
return ['<FUNCTION[14,(function(){})]>'] },
|
|
|
|
// recursive...
|
|
'array-recursive': function(assert){
|
|
return ['[<RECURSIVE[]>]'] },
|
|
'object-recursive': function(assert){
|
|
return ['{"r":<RECURSIVE[]>}'] },
|
|
'set-recursive': function(assert){
|
|
return ['Set([<RECURSIVE[]>])'] },
|
|
'map-recursive-key': function(assert){
|
|
return ['Map([[<RECURSIVE[]>,"value"]])'] },
|
|
'map-recursive-value': function(assert){
|
|
return ['Map([["key",<RECURSIVE[]>]])'] },
|
|
})
|
|
|
|
test.Modifiers({
|
|
// NOTE: we are not simply editing strings as we'll need to also
|
|
// update all the recursion paths which is not trivial...
|
|
'array-stuffed': function(assert, [setup, json]){
|
|
return [
|
|
eJSON.serialize(
|
|
[ eJSON.deserialize(setup, true) ] ),
|
|
json,
|
|
] },
|
|
'object-stuffed': function(assert, [setup, json]){
|
|
return [
|
|
eJSON.serialize(
|
|
{ key: eJSON.deserialize(setup, true) } ),
|
|
json,
|
|
] },
|
|
// NOTE: these explicitly remove JSON compatibility regardless of input...
|
|
'set-stuffed': function(assert, [setup]){
|
|
return [
|
|
eJSON.serialize(
|
|
new Set([ eJSON.deserialize(setup, true) ]) ),
|
|
ejson,
|
|
] },
|
|
'map-key-stuffed': function(assert, [setup]){
|
|
return [
|
|
eJSON.serialize(
|
|
new Map([[eJSON.deserialize(setup, true), "value"]]) ),
|
|
ejson,
|
|
] },
|
|
'map-value-stuffed': function(assert, [setup]){
|
|
return [
|
|
eJSON.serialize(
|
|
new Map([["key", eJSON.deserialize(setup, true)]]) ),
|
|
ejson,
|
|
] },
|
|
})
|
|
|
|
test.Tests({
|
|
'self-apply': function(assert, [setup]){
|
|
var res
|
|
assert(
|
|
setup == (res = eJSON.serialize( eJSON.deserialize(setup, true) ) ),
|
|
'serialize(deserialize( setup )) == setup: expected:', setup, 'got:', res) },
|
|
|
|
'json-caopatiility': function(assert, [setup, json], skipTest){
|
|
if(!json){
|
|
skipTest()
|
|
return }
|
|
var obj = eJSON.deserialize(setup, true)
|
|
assert(
|
|
JSON.stringify(obj) == eJSON.serialize(obj) ) },
|
|
|
|
'deep-copy': function(assert, [setup]){
|
|
var obj = eJSON.deserialize(setup, true)
|
|
var copy = eJSON.deepCopy(obj, true)
|
|
|
|
assert(eJSON.serialize(obj) == eJSON.serialize(copy))
|
|
|
|
// XXX check if all non-atoms are distinct...
|
|
// XXX
|
|
},
|
|
|
|
'partial-deep-copy': function(assert, [setup]){
|
|
var obj = eJSON.deserialize(setup, true)
|
|
var funcs = []
|
|
var copy = eJSON.partialDeepCopy(obj, funcs)
|
|
|
|
assert(eJSON.serialize(obj) == eJSON.serialize(copy))
|
|
|
|
// XXX check if all non-atoms are distinct and functions are the same...
|
|
// XXX
|
|
},
|
|
//*/
|
|
})
|
|
|
|
test.Cases({
|
|
//
|
|
// Format:
|
|
// [
|
|
// [ "<extended-syntax>", "<JSON-syntax>" ],
|
|
// ...
|
|
// ]
|
|
//
|
|
// NOTE: these syntax variants are not output by .serialize(..) this it
|
|
// is less critical to test them in the main loop.
|
|
// XXX though it would be nice to do so...
|
|
tests: [
|
|
// numbers/floats...
|
|
['.123', '0.123'],
|
|
['123.', '123'],
|
|
['+123', '123'],
|
|
['123e100', '123e+100'],
|
|
['123E100', '123e+100'],
|
|
['0xff', '255'],
|
|
['0Xff', '255'],
|
|
['0o77', '63'],
|
|
['0O77', '63'],
|
|
['0b11', '3'],
|
|
['0B11', '3'],
|
|
|
|
// string quotes...
|
|
// XXX test new lines...
|
|
["'abc'", '"abc"'],
|
|
['`abc`', '"abc"'],
|
|
|
|
// arrays...
|
|
['[1,2,]', '[1,2]'],
|
|
|
|
// sparse arrays...
|
|
['[<empty>]', '[,]'],
|
|
['[1,2,<empty>]', '[1,2,,]'],
|
|
['[1,2,<empty>]', '[1,2,<empty>,]'],
|
|
],
|
|
'syntax-simplifications': function(assert){
|
|
var aa, bb
|
|
for(var [a, b] of this.tests){
|
|
assert(eJSON.serialize(aa = eJSON.deserialize(a)) == eJSON.serialize(bb = eJSON.deserialize(b)),
|
|
`"${ a }" and "${ b }" should deserialize to the samve value.`,
|
|
'got:', aa, 'and', bb, 'resp.') } },
|
|
|
|
_make_object_with_methods: function(){
|
|
var in_closure = 123
|
|
return {
|
|
stateful: function(){
|
|
return typeof(in_closure) != 'undefined' ?
|
|
'state_retained'
|
|
: 'state_lost' },
|
|
stateless: function(){
|
|
return 'stateless' },
|
|
} },
|
|
'deep-copy-function': function(assert){
|
|
var obj = this._make_object_with_methods()
|
|
var obj_copy = eJSON.deepCopy(obj, true)
|
|
|
|
// sanity checks...
|
|
assert(obj.stateless() == 'stateless')
|
|
assert(obj.stateful() == 'state_retained')
|
|
assert(obj_copy.stateless() == 'stateless')
|
|
|
|
// context should be lost...
|
|
assert(
|
|
obj_copy.stateful() == 'state_lost',
|
|
'Function closure not lost.')
|
|
assert(obj.stateful !== obj_copy.stateful,
|
|
'Function objects retained.') },
|
|
'partial-deep-copy-function': function(assert){
|
|
var obj = this._make_object_with_methods()
|
|
var obj_copy = eJSON.partialDeepCopy(obj)
|
|
|
|
// sanity checks...
|
|
assert(obj.stateless() == 'stateless')
|
|
assert(obj.stateful() == 'state_retained')
|
|
assert(obj_copy.stateless() == 'stateless')
|
|
|
|
// context should be retained...
|
|
assert(
|
|
obj_copy.stateful() == 'state_retained',
|
|
'Function closure lost.')
|
|
assert(obj.stateful === obj_copy.stateful,
|
|
'Function objects not retained.') },
|
|
})
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
|
|
typeof(__filename) != 'undefined'
|
|
&& __filename == (require.main || {}).filename
|
|
&& test.run()
|
|
|
|
|
|
|
|
|
|
/**********************************************************************
|
|
* vim:set ts=4 sw=4 nowrap : */ return module })
|