sqlmath 2022.4.28 → 2022.5.20

package/sqlmath.mjs

@@ -1,15 +1,35 @@
+// MIT License
+//
+// Copyright (c) 2021 Kai Zhu
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+
 /*jslint beta, bitwise, name, node*/
 "use strict";
 import {createRequire} from "module";
 import jslint from "./jslint.mjs";
 
 let {
-    assertErrorThrownAsync,
-    assertJsonEqual,
     assertOrThrow,
     debugInline,
-    noop,
-    objectDeepCopyWithKeysSorted
+    noop
 } = jslint;
 let local = Object.assign({}, jslint);
 
@@ -62,7 +82,6 @@ file sqlmath.js
     let consoleError = console.error;
     let dbDict = new WeakMap(); // private map of sqlite-database-connections
     let requireCjs = createRequire(import.meta.url);
-    let testList;
 
     function cCall(func, argList) {
 // this function will serialize <argList> to a c <baton>,
@@ -251,6 +270,9 @@ file sqlmath.js
                     + " remaining retry"
                 );
                 retry -= 1;
+                await new Promise(function (resolve) {
+                    setTimeout(resolve, 50);
+                });
             }
         }
     }
@@ -305,7 +327,9 @@ file sqlmath.js
 //   const char *zVfs        /* Name of VFS module to use */
 // );
         let connPool;
-        let db = {};
+        let db = {
+            filename
+        };
         assertOrThrow(
             typeof filename === "string",
             "invalid filename " + filename
@@ -330,6 +354,7 @@ file sqlmath.js
         dbDict.set(db, {
             busy: 0,
             connPool,
+            filename,
             ii: 0,
             ptr: 0n
         });
@@ -837,900 +862,6 @@ Definition of the CSV Format
         return rowList;
     }
 
-    function testAll() {
-// this function will run all tests
-        testList.forEach(function (testFunc) {
-            testFunc();
-        });
-    }
-
-    function testAssertXxx() {
-// this function will test assertXxx's handling-behavior
-        // test assertNumericalEqual's handling-behavior
-        assertNumericalEqual(1, 1);
-        assertErrorThrownAsync(function () {
-            assertNumericalEqual(0, 0);
-        }, "value cannot be 0 or falsy");
-        assertErrorThrownAsync(function () {
-            assertNumericalEqual(1, 2);
-        }, "1 != 2");
-        assertErrorThrownAsync(function () {
-            assertNumericalEqual(1, 2, "aa");
-        }, "aa");
-    }
-
-    function testCcall() {
-// this function will test cCall's handling-behavior
-        [
-            [-0, "0"],
-            [-Infinity, "0"],
-            [0, "0"],
-            [1 / 0, "0"],
-            [Infinity, "0"],
-            [false, "0"],
-            [null, "0"],
-            [true, "1"],
-            [undefined, "0"],
-            [{}, "0"]
-        ].forEach(async function ([
-            aa, bb
-        ]) {
-            let cc;
-            cc = String(
-                await cCall("noopAsync", [
-                    aa
-                ])
-            )[0][0];
-            assertOrThrow(bb === cc, [aa, bb, cc]);
-            cc = String(cCall("noopSync", [
-                aa
-            ]))[0][0];
-            assertOrThrow(bb === cc, [aa, bb, cc]);
-        });
-    }
-
-    async function testDbBind() {
-// this function will test db's bind handling-behavior
-        let db = await dbOpenAsync({
-            filename: ":memory:"
-        });
-        async function testDbGetLastBlobAsync(val) {
-            return await dbGetLastBlobAsync({
-                bindList: [
-                    val
-                ],
-                db,
-                sql: "SELECT 1, 2, 3; SELECT 1, 2, ?"
-            });
-        }
-        // test bigint-error handling-behavior
-        noop([
-            -(2n ** 63n),
-            2n ** 63n
-        ]).forEach(function (val) {
-            assertErrorThrownAsync(testDbGetLastBlobAsync.bind(undefined, val));
-        });
-        // test datatype handling-behavior
-        [
-            // -1. SharedArrayBuffer
-            // new SharedArrayBuffer(0), null,
-            // 1. bigint
-            -0n, -0,
-            -0x7fffffffffffffffn, "-9223372036854775807",
-            -1n, -1,
-            -2n, -2,
-            0n, 0,
-            0x7fffffffffffffffn, "9223372036854775807",
-            1n, 1,
-            2n, 2,
-            // 2. boolean
-            false, 0,
-            true, 1,
-            // 3. function
-            noop, null,
-            // 4. number
-            -0, 0,
-            -1 / 0, null,
-            -1e-999, 0,
-            -1e999, null,
-            -2, -2,
-            -Infinity, null,
-            -NaN, 0,
-            0, 0,
-            1 / 0, null,
-            1e-999, 0,
-            1e999, null,
-            2, 2,
-            Infinity, null,
-            NaN, 0,
-            // 5. object
-            new Uint8Array(0), null,
-            new TextEncoder().encode(""), null,
-            new TextEncoder().encode("\u0000"), null,
-            new TextEncoder().encode("\u0000\u{1f600}\u0000"), null,
-            [], "[]",
-            new Date(0), "1970-01-01T00:00:00.000Z",
-            new RegExp(), "{}",
-            null, null,
-            {}, "{}",
-            // 6. string
-            "", "",
-            "0", "0",
-            "1", "1",
-            "2", "2",
-            "\u0000", "\u0000",
-            "\u0000\u{1f600}\u0000", "\u0000\u{1f600}\u0000",
-            "a".repeat(9999), "a".repeat(9999),
-            // 7. symbol
-            Symbol(), null,
-            // 8. undefined
-            undefined, null
-        ].forEach(function (aa, ii, list) {
-            let bb = list[ii + 1];
-            if (ii % 2 === 1) {
-                return;
-            }
-            ii *= 0.5;
-            // test dbGetLastBlobAsync's bind handling-behavior
-            [
-                aa
-            ].forEach(async function (aa) {
-                let cc = String(bb);
-                let dd = new TextDecoder().decode(
-                    await testDbGetLastBlobAsync(aa)
-                );
-                switch (typeof(aa)) {
-                case "bigint":
-                    aa = Number(aa);
-                    break;
-                case "function":
-                case "symbol":
-                case "undefined":
-                    cc = "";
-                    break;
-                case "number":
-                    switch (aa) {
-                    case -2:
-                        cc = "-2.0";
-                        break;
-                    case -Infinity:
-                        cc = "-Inf";
-                        break;
-                    case 2:
-                        cc = "2.0";
-                        break;
-                    case Infinity:
-                        cc = "Inf";
-                        break;
-                    }
-                    break;
-                case "object":
-                    if (ArrayBuffer.isView(aa)) {
-                        cc = new TextDecoder().decode(aa);
-                        break;
-                    }
-                    if (aa === null) {
-                        cc = "";
-                    }
-                    break;
-                }
-                // debugInline(ii, aa, bb, cc, dd);
-                assertJsonEqual(cc, dd, {
-                    ii,
-                    aa, //jslint-quiet
-                    bb,
-                    cc,
-                    dd
-                });
-            });
-            // test dbExecAsync's responseType handling-behavior
-            [
-                "arraybuffer",
-                "list",
-                undefined
-            ].forEach(async function (responseType) {
-                let cc = noop(
-                    await dbExecAsync({
-                        bindList: [
-                            aa
-                        ],
-                        db,
-                        responseType,
-                        sql: "SELECT ? AS val"
-                    })
-                );
-                // debugInline(ii, responseType, aa, bb, cc);
-                switch (responseType) {
-                case "arraybuffer":
-                    cc = JSON.parse(new TextDecoder().decode(cc))[0][1][0];
-                    break;
-                case "list":
-                    cc = cc[0][1][0];
-                    break;
-                default:
-                    cc = cc[0][0].val;
-                }
-                assertJsonEqual(bb, cc, {
-                    aa,
-                    bb,
-                    cc
-                });
-            });
-            // test dbExecAsync's bind handling-behavior
-            [
-                [
-                    [
-                        bb, bb, 0
-                    ],
-                    (
-                        "SELECT 0;"
-                        + " SELECT ? AS c1, ? AS c2, ? AS c3, ? AS c4"
-                        + " UNION ALL SELECT ?1, ?2, ?3, ?4"
-                        + " UNION ALL SELECT ?1, ?2, ?3, ?4"
-                    )
-                ], [
-                    {
-                        k1: bb,
-                        k2: bb,
-                        k3: 0
-                    },
-                    (
-                        "SELECT 0;"
-                        + " SELECT $k1 AS c1, $k2 AS c2, $k3 AS c3, $k4 AS c4"
-                        + " UNION ALL SELECT :k1, :k2, :k3, :k4"
-                        + " UNION ALL SELECT @k1, @k2, @k3, @k4"
-                    )
-                ]
-            ].forEach(async function ([
-                bindList, sql
-            ]) {
-                let cc = noop(
-                    await dbExecAsync({
-                        bindList,
-                        db,
-                        responseType: "list",
-                        sql
-                    })
-                );
-                // debugInline(ii, aa, bb, cc);
-                assertJsonEqual(
-                    [
-                        [
-                            [
-                                "0"
-                            ], [
-                                0
-                            ]
-                        ], [
-                            [
-                                "c1", "c2", "c3", "c4"
-                            ], [
-                                bb, bb, 0, undefined
-                            ], [
-                                bb, bb, 0, undefined
-                            ], [
-                                bb, bb, 0, undefined
-                            ]
-                        ]
-                    ],
-                    cc
-                );
-            });
-            // test dbTableInsertAsync's bind handling-behavior
-            [
-                {
-                    // test list-of-list handling-behavior
-                    rowList: [
-                        [
-                            "c1", "c2", "c3"
-                        ],
-                        [
-                            aa, aa
-                        ]
-                    ]
-                }, {
-                    // test list-of-dict handling-behavior
-                    rowList: [
-                        {
-                            "c1": aa,
-                            "c2": aa,
-                            "c3": undefined
-                        }
-                    ]
-                }, {
-                    // test colList and list-of-list handling-behavior
-                    colList: [
-                        "c1", "c2", "c3"
-                    ],
-                    rowList: [
-                        [
-                            aa, aa
-                        ]
-                    ]
-                }, {
-                    // test colList and list-of-dict handling-behavior
-                    colList: [
-                        "c1", "c2", "c3"
-                    ],
-                    rowList: [
-                        {
-                            "c1": aa,
-                            "c2": aa,
-                            "c3": undefined
-                        }
-                    ]
-                }, {
-                    // test colList and list-of-list handling-behavior
-                    colList: [
-                        "c1", "c3", "c2"
-                    ],
-                    colListPriority: [
-                        "c1", "c2"
-                    ],
-                    rowList: [
-                        [
-                            aa, undefined, aa
-                        ]
-                    ]
-                }
-            ].forEach(async function ({
-                colList,
-                colListPriority,
-                rowList
-            }, jj) {
-                let cc = noop(
-                    await dbExecAsync({
-                        db,
-                        responseType: "list",
-                        sql: `SELECT * FROM datatype_${ii}_${jj}`,
-                        tmpColList: colList,
-                        tmpColListPriority: colListPriority,
-                        tmpRowList: rowList,
-                        tmpTableName: "datatype_" + ii + "_" + jj
-                    })
-                )[0];
-                // debugInline(ii, jj, aa, bb, cc);
-                assertJsonEqual([
-                    [
-                        "c1", "c2", "c3"
-                    ], [
-                        bb, bb, undefined
-                    ]
-                ], cc);
-            });
-        });
-    }
-
-    async function testDbCloseAsync() {
-// this function will test dbCloseAsync's handling-behavior
-        let db = await dbOpenAsync({
-            filename: ":memory:"
-        });
-        // test null-case handling-behavior
-        assertErrorThrownAsync(function () {
-            return dbCloseAsync({});
-        }, "invalid or closed db");
-        // test close handling-behavior
-        await dbCloseAsync({
-            db
-        });
-    }
-
-    async function testDbExecAsync() {
-// this function will test dbExecAsync's handling-behavior
-        let db = await dbOpenAsync({
-            filename: ":memory:"
-        });
-        // test null-case handling-behavior
-        assertErrorThrownAsync(function () {
-            return dbExecAsync({
-                db,
-                sql: undefined
-            });
-        }, "near \"undefined\": syntax error");
-        // test race-condition handling-behavior
-        Array.from(new Array(4)).forEach(async function () {
-            let result;
-            try {
-                result = JSON.stringify(
-                    await dbExecAsync({
-                        bindList: [
-                            new TextEncoder().encode("foob"),
-                            new TextEncoder().encode("fooba"),
-                            new TextEncoder().encode("foobar")
-                        ],
-                        db,
-                        responseType: "list",
-                        sql: (`
-CREATE TABLE testDbExecAsync1 AS
-SELECT 101 AS c101, 102 AS c102
---
-UNION ALL
-VALUES
-    (201, 202),
-    (301, NULL);
-CREATE TABLE testDbExecAsync2 AS
-SELECT 401 AS c401, 402 AS c402, 403 AS c403
---
-UNION ALL
-VALUES
-    (501, 502.0123, 5030123456789),
-    (601, '602', '603_\"\x01\x08\x09\x0a\x0b\x0c\x0d\x0e'),
-    (?1, ?2, ?3),
-    (tostring(?1), tostring(?2), tostring(?3)),
-    (tobase64(?1), tobase64(?2), tobase64(?3)),
-    (
-        tobase64(uncompress(compress(?1))),
-        tobase64(uncompress(compress(?2))),
-        tobase64(uncompress(compress(?3)))
-    );
-SELECT * FROM testDbExecAsync1;
-SELECT * FROM testDbExecAsync2;
-                        `)
-                    })
-                );
-                assertJsonEqual(result, JSON.stringify([
-                    [
-                        ["c101", "c102"],
-                        [101, 102],
-                        [201, 202],
-                        [301, null]
-                    ],
-                    [
-                        ["c401", "c402", "c403"],
-                        [401, 402, 403],
-                        [501, 502.0123, 5030123456789],
-                        [601, "602", "603_\"\u0001\b\t\n\u000b\f\r\u000e"],
-                        [
-                            null, null, null
-                        ],
-                        [
-                            "foob", "fooba", "foobar"
-                        ],
-                        [
-                            "Zm9vYg==", "Zm9vYmE=", "Zm9vYmFy"
-                        ],
-                        [
-                            "Zm9vYg==", "Zm9vYmE=", "Zm9vYmFy"
-                        ]
-                    ]
-                ]));
-            } catch (err) {
-                assertOrThrow(
-                    err.message.indexOf(
-                        "table testDbExecAsync1 already exists"
-                    ) >= 0,
-                    err
-                );
-            }
-        });
-        // test close-while-busy handling-behavior
-        assertErrorThrownAsync(function () {
-            return dbCloseAsync({
-                db
-            });
-        }, (
-            /db cannot close with \d+? actions pending/
-        ));
-        // test sqlmath-defined-func handling-behavior
-        [
-            "COT(NULL)", null,
-            "COT('-1')", -0.642092615934331,
-            "COT('0')", null,
-            "COT('1')", 0.642092615934331,
-            "COT(-1)", -0.642092615934331,
-            "COT(0)", null,
-            "COT(1)", 0.642092615934331,
-            "COTH(NULL)", null,
-            "COTH('-1')", -1.31303528549933,
-            "COTH('0')", null,
-            "COTH('1')", 1.31303528549933,
-            "COTH(-1)", -1.31303528549933,
-            "COTH(0)", null,
-            "COTH(1)", 1.31303528549933,
-            "ROUNDORZERO(NULL, NULL)", 0,
-            "ROUNDORZERO(NULL, 0)", 0,
-            "ROUNDORZERO(NULL, 0.5)", 0,
-            "ROUNDORZERO(0.5, NULL)", 1,
-            "ROUNDORZERO(0.5, 0.5)", 1,
-            "ROUNDORZERO(0.5, 1)", 0.5,
-            "SIGN(NULL)", null,
-            "SIGN('-1')", -1,
-            "SIGN('0')", 0,
-            "SIGN('1')", 1,
-            "SIGN(-0x7fffffffffffffff)", -1,
-            "SIGN(-1)", -1,
-            "SIGN(-1e999)", -1,
-            "SIGN(0)", 0,
-            "SIGN(0x7fffffffffffffff)", 1,
-            "SIGN(0x8000000000000000)", -1,
-            "SIGN(0xffffffffffffffff)", -1,
-            "SIGN(1)", 1,
-            "SIGN(1e999)", 1,
-            // sentinel
-            "NULL", null
-        ].forEach(async function (sql, ii, list) {
-            let bb = list[ii + 1];
-            let cc;
-            if (ii % 2 === 1) {
-                return;
-            }
-            ii *= 0.5;
-            cc = noop(
-                await dbExecAsync({
-                    db,
-                    responseType: "dict",
-                    sql: `SELECT ${sql} AS val`
-                })
-            )[0][0].val;
-            assertJsonEqual(bb, cc, {
-                bb,
-                cc,
-                ii,
-                sql
-            });
-        });
-    }
-
-    function testDbExecWithRetryAsync() {
-// this function will test dbExecWithRetryAsync's handling-behavior
-        // test null-case handling-behavior
-        assertErrorThrownAsync(function () {
-            return dbExecWithRetryAsync({});
-        }, "invalid or closed db");
-    }
-
-    async function testDbMemoryXxx() {
-// this function will test dbMemoryXxx's handling-behavior
-        let data;
-        let db = await dbOpenAsync({
-            filename: ":memory:"
-        });
-        // test null-case handling-behavior
-        assertErrorThrownAsync(function () {
-            return dbMemoryLoadAsync({
-                db
-            });
-        }, "invalid filename undefined");
-        assertErrorThrownAsync(function () {
-            return dbMemorySaveAsync({
-                db
-            });
-        }, "invalid filename undefined");
-        await dbExecAsync({
-            db,
-            sql: "CREATE TABLE t01 AS SELECT 1 AS c01"
-        });
-        await dbMemorySaveAsync({
-            db,
-            filename: ".testDbMemoryXxx.sqlite"
-        });
-        db = await dbOpenAsync({
-            filename: ":memory:"
-        });
-        await dbMemoryLoadAsync({
-            db,
-            filename: ".testDbMemoryXxx.sqlite"
-        });
-        data = await dbExecAsync({
-            db,
-            sql: "SELECT * FROM t01"
-        });
-        assertJsonEqual(data, [
-            [
-                {
-                    c01: 1
-                }
-            ]
-        ]);
-    }
-
-    function testDbOpenAsync() {
-// this function will test dbOpenAsync's handling-behavior
-        // test null-case handling-behavior
-        assertErrorThrownAsync(function () {
-            return dbOpenAsync({});
-        }, "invalid filename undefined");
-    }
-
-    async function testDbTableInsertAsync() {
-// this function will test dbTableInsertAsync's handling-behavior
-        let db = await dbOpenAsync({
-            filename: ":memory:"
-        });
-        // test error handling-behavior
-        [
-            [
-                undefined,
-                (
-                    /invalid rowList undefined/
-                )
-            ], [
-                [
-                    []
-                ],
-                (
-                    /invalid colList \[\]/
-                )
-            ], [
-                [
-                    {}
-                ],
-                (
-                    /invalid colList \[\]/
-                )
-            ]
-        ].forEach(function ([
-            rowList, rgx
-        ]) {
-            assertErrorThrownAsync(
-                dbTableInsertAsync.bind(
-                    undefined,
-                    {
-                        rowList
-                    }
-                ),
-                rgx
-            );
-        });
-        // test csv handling-behavior
-        [
-            [
-                "0", undefined
-            ],
-            [
-                "0,0,0\n1,1,1",
-                [
-                    [
-                        "c_0", "c_0_2", "c_0_3"
-                    ], [
-                        "1", "1", "1"
-                    ]
-                ]
-            ],
-            [
-                (
-                    "c1,c1,c2\n"
-                    + "1, 2 \n"
-                    + `"1","""2""","3\r\n"\n`
-                    + "\n"
-                    + "1,2,3\n"
-                ),
-                [
-                    [
-                        "c1", "c1_2", "c2"
-                    ], [
-                        "1", " 2 ", null
-                    ], [
-                        "1", "\"2\"", "3\n"
-                    ], [
-                        "", null, null
-                    ], [
-                        "1", "2", "3"
-                    ]
-                ]
-            ]
-        ].forEach(async function ([
-            aa, bb
-        ], ii) {
-            let cc = noop(
-                await dbExecAsync({
-                    db,
-                    responseType: "list",
-                    sql: `SELECT * FROM temp.csv_${ii}`,
-                    tmpCsv: aa,
-                    tmpTableName: "csv_" + ii
-                })
-            )[0];
-            assertOrThrow(
-                JSON.stringify(bb) === JSON.stringify(cc),
-                JSON.stringify([
-                    ii, aa, bb, cc
-                ], undefined, 4)
-            );
-        });
-    }
-
-    async function testSqlError() {
-// this function will test sql-error's handling-behavior
-        let db = await dbOpenAsync({
-            filename: ":memory:"
-        });
-        [
-            1, "SQL logic error",
-            2, "unknown error",
-            3, "access permission denied",
-            4, "query aborted",
-            5, "database is locked",
-            6, "database table is locked",
-            7, "out of memory",
-            8, "attempt to write a readonly database",
-            9, "interrupted",
-            10, "disk I/O error",
-            11, "database disk image is malformed",
-            12, "unknown operation",
-            13, "database or disk is full",
-            14, "unable to open database file",
-            15, "locking protocol",
-            16, "unknown error",
-            17, "database schema has changed",
-            18, "string or blob too big",
-            19, "constraint failed",
-            20, "datatype mismatch",
-            21, "bad parameter or other API misuse",
-            22, "unknown error",
-            23, "authorization denied",
-            24, "unknown error",
-            25, "column index out of range",
-            26, "file is not a database",
-            27, "notification message",
-            28, "warning message",
-            100, "unknown error",
-            101, "unknown error"
-        ].forEach(function (sql, ii, list) {
-            let bb = list[ii + 1];
-            if (ii % 2 === 1) {
-                return;
-            }
-            ii *= 0.5;
-            sql = `SELECT throwerror(${sql})`;
-            assertErrorThrownAsync(function () {
-                return dbExecAsync({
-                    db,
-                    sql
-                });
-            }, bb);
-        });
-    }
-
-    async function testSqlExt() {
-// this function will test sql-ext's handling-behavior
-        let db = await dbOpenAsync({
-            filename: ":memory:"
-        });
-        [
-            {
-                aa: [
-                    [
-                        {
-                            "c01": ""
-                        }
-                    ]
-                ],
-                sql: "SELECT tobase64(NULL) AS c01"
-            },
-            {
-                aa: [
-                    [
-                        {
-                            "c01": ""
-                        }
-                    ]
-                ],
-                sql: "SELECT tobase64(?) AS c01"
-            },
-            {
-                aa: [
-                    [
-                        {
-                            "c01": "AAAAAAAAAAA="
-                        }
-                    ]
-                ],
-                bindList: [
-                    new Uint8Array(8)
-                ],
-                sql: "SELECT tobase64(uncompress(compress(?))) AS c01"
-            }
-        ].forEach(async function ({
-            aa,
-            bindList,
-            sql
-        }) {
-            let bb = await dbExecAsync({
-                bindList,
-                db,
-                sql
-            });
-            assertJsonEqual(aa, bb);
-        });
-    }
-
-    async function testSqlKthpercentile() {
-// this function will test sql-kthpercentile's handling-behavior
-        let db = await dbOpenAsync({
-            filename: ":memory:"
-        });
-        [
-            [
-                [], -99, 1
-            ], [
-                [], 0, 1
-            ], [
-                [], 0.125, 1
-            ], [
-                [], 0.25, 2
-            ], [
-                [], 0.375, 3
-            ], [
-                [], 0.5, 4
-            ], [
-                [], 0.625, 5
-            ], [
-                [], 0.75, 6
-            ], [
-                [], 0.875, 7
-            ], [
-                [], 1, 8
-            ], [
-                [], 99, 8
-            ], [
-                [
-                    0.5
-                ], 0, 0.5
-            ], [
-                [
-                    0.5
-                ], 0.125, 0.5
-            ], [
-                [
-                    1.5
-                ], 0.25, 1.5
-            ], [
-                [
-                    2.5
-                ], 0.375, 2.5
-            ], [
-                [
-                    3.5
-                ], 0.5, 3.5
-            ], [
-                [
-                    4.5
-                ], 0.625, 4.5
-            ], [
-                [
-                    5.5
-                ], 0.75, 5.5
-            ], [
-                [
-                    6.5
-                ], 0.875, 6.5
-            ], [
-                [
-                    7.5
-                ], 1, 8
-            ]
-        ].forEach(async function ([
-            data, kk, expected
-        ], ii) {
-            let actual;
-            data = data.concat([
-                undefined, undefined, 8, 7, 6, 5, 4, 3, 2, 1, undefined
-            ]);
-            actual = noop(
-                await dbExecAsync({
-                    db,
-                    sql: (`
-SELECT kthpercentile(val, ${kk}) AS val FROM __tmp${ii};
--- test null-case handling-behavior
-SELECT kthpercentile(val, ${kk}) AS val FROM __tmp${ii} WHERE 0;
-                    `),
-                    tmpRowList: data.map(function (val) {
-                        return {
-                            val
-                        };
-                    }),
-                    tmpTableName: `__tmp${ii}`
-                })
-            )[0][0].val;
-            assertJsonEqual(actual, expected, {
-                data,
-                kk
-            });
-        });
-    }
-
     addon = requireCjs(
         "./_binary_sqlmath"
         + "_napi8"
@@ -1738,21 +869,7 @@ SELECT kthpercentile(val, ${kk}) AS val FROM __tmp${ii} WHERE 0;
         + "_" + process.arch
         + ".node"
     );
-    testList = [
-        testAssertXxx,
-        testCcall,
-        testDbBind,
-        testDbCloseAsync,
-        testDbExecAsync,
-        testDbExecWithRetryAsync,
-        testDbMemoryXxx,
-        testDbOpenAsync,
-        testDbTableInsertAsync,
-        testSqlError,
-        testSqlExt,
-        testSqlKthpercentile
-    ];
-    Object.assign(local, {
+    Object.assign(local, jslint, {
         SQLITE_MAX_LENGTH2,
         SQLITE_OPEN_AUTOPROXY,
         SQLITE_OPEN_CREATE,
@@ -1775,8 +892,8 @@ SELECT kthpercentile(val, ${kk}) AS val FROM __tmp${ii} WHERE 0;
         SQLITE_OPEN_TRANSIENT_DB,
         SQLITE_OPEN_URI,
         SQLITE_OPEN_WAL,
-        assertErrorThrownAsync,
         assertNumericalEqual,
+        cCall,
         dbCloseAsync,
         dbExecAsync,
         dbExecWithRetryAsync,
@@ -1785,10 +902,7 @@ SELECT kthpercentile(val, ${kk}) AS val FROM __tmp${ii} WHERE 0;
         dbMemorySaveAsync,
         dbOpenAsync,
         dbTableInsertAsync,
-        debugInline,
-        objectDeepCopyWithKeysSorted,
-        testAll,
-        testList
+        debugInline
     });
     if (process.env.npm_config_mode_test) {
         // mock consoleError