quickjs-tart

test_bjson.js (5215B)

---

 import * as bjson from "./bjson.so";
 
 function assert(actual, expected, message) {
     if (arguments.length == 1)
         expected = true;
 
     if (actual === expected)
         return;
 
     if (actual !== null && expected !== null
     &&  typeof actual == 'object' && typeof expected == 'object'
     &&  actual.toString() === expected.toString())
         return;
 
     throw Error("assertion failed: got |" + actual + "|" +
                 ", expected |" + expected + "|" +
                 (message ? " (" + message + ")" : ""));
 }
 
 function toHex(a)
 {
     var i, s = "", tab, v;
     tab = new Uint8Array(a);
     for(i = 0; i < tab.length; i++) {
         v = tab[i].toString(16);
         if (v.length < 2)
             v = "0" + v;
         if (i !== 0)
             s += " ";
         s += v;
     }
     return s;
 }
 
 function isArrayLike(a)
 {
     return Array.isArray(a) ||
         (a instanceof Uint8ClampedArray) ||
         (a instanceof Uint8Array) ||
         (a instanceof Uint16Array) ||
         (a instanceof Uint32Array) ||
         (a instanceof Int8Array) ||
         (a instanceof Int16Array) ||
         (a instanceof Int32Array) ||
         (a instanceof Float32Array) ||
         (a instanceof Float64Array);
 }
 
 function toStr(a)
 {
     var s, i, props, prop;
 
     switch(typeof(a)) {
     case "object":
         if (a === null)
             return "null";
         if (a instanceof Date) {
             s = "Date(" + toStr(a.valueOf()) + ")";
         } else if (a instanceof Number) {
             s = "Number(" + toStr(a.valueOf()) + ")";
         } else if (a instanceof String) {
             s = "String(" + toStr(a.valueOf()) + ")";
         } else if (a instanceof Boolean) {
             s = "Boolean(" + toStr(a.valueOf()) + ")";
         } else if (isArrayLike(a)) {
             s = "[";
             for(i = 0; i < a.length; i++) {
                 if (i != 0)
                     s += ",";
                 s += toStr(a[i]);
             }
             s += "]";
         } else {
             props = Object.keys(a);
             s = "{";
             for(i = 0; i < props.length; i++) {
                 if (i != 0)
                     s += ",";
                 prop = props[i];
                 s += prop + ":" + toStr(a[prop]);
             }
             s += "}";
         }
         return s;
     case "undefined":
         return "undefined";
     case "string":
         return a.__quote();
     case "number":
     case "bigfloat":
         if (a == 0 && 1 / a < 0)
             return "-0";
         else
             return a.toString();
         break;
     default:
         return a.toString();
     }
 }
 
 function bjson_test(a)
 {
     var buf, r, a_str, r_str;
     a_str = toStr(a);
     buf = bjson.write(a);
     if (0) {
         print(a_str, "->", toHex(buf));
     }
     r = bjson.read(buf, 0, buf.byteLength);
     r_str = toStr(r);
     if (a_str != r_str) {
         print(a_str);
         print(r_str);
         assert(false);
     }
 }
 
 /* test multiple references to an object including circular
    references */
 function bjson_test_reference()
 {
     var array, buf, i, n, array_buffer;
     n = 16;
     array = [];
     for(i = 0; i < n; i++)
         array[i] = {};
     array_buffer = new ArrayBuffer(n);
     for(i = 0; i < n; i++) {
         array[i].next = array[(i + 1) % n];
         array[i].idx = i;
         array[i].typed_array = new Uint8Array(array_buffer, i, 1);
     }
     buf = bjson.write(array, true);
 
     array = bjson.read(buf, 0, buf.byteLength, true);
 
     /* check the result */
     for(i = 0; i < n; i++) {
         assert(array[i].next, array[(i + 1) % n]);
         assert(array[i].idx, i);
         assert(array[i].typed_array.buffer, array_buffer);
         assert(array[i].typed_array.length, 1);
         assert(array[i].typed_array.byteOffset, i);
     }
 }
 
 function bjson_test_all()
 {
     var obj;
 
     bjson_test({x:1, y:2, if:3});
     bjson_test([1, 2, 3]);
     bjson_test([1.0, "aa", true, false, undefined, null, NaN, -Infinity, -0.0]);
     if (typeof BigInt !== "undefined") {
         bjson_test([BigInt("1"), -BigInt("0x123456789"),
                BigInt("0x123456789abcdef123456789abcdef")]);
     }
     if (typeof BigFloat !== "undefined") {
         BigFloatEnv.setPrec(function () {
             bjson_test([BigFloat("0.1"), BigFloat("-1e30"), BigFloat("0"),
                    BigFloat("-0"), BigFloat("Infinity"), BigFloat("-Infinity"),
                    0.0 / BigFloat("0"), BigFloat.MAX_VALUE,
                    BigFloat.MIN_VALUE]);
         }, 113, 15);
     }
     if (typeof BigDecimal !== "undefined") {
         bjson_test([BigDecimal("0"),
                     BigDecimal("0.8"), BigDecimal("123321312321321e100"),
                     BigDecimal("-1233213123213214332333223332e100"),
                     BigDecimal("1.233e-1000")]);
     }
 
     bjson_test([new Date(1234), new String("abc"), new Number(-12.1), new Boolean(true)]);
 
     bjson_test(new Int32Array([123123, 222111, -32222]));
     bjson_test(new Float64Array([123123, 222111.5]));
 
     /* tested with a circular reference */
     obj = {};
     obj.x = obj;
     try {
         bjson.write(obj);
         assert(false);
     } catch(e) {
         assert(e instanceof TypeError);
     }
 
     bjson_test_reference();
 }
 
 bjson_test_all();