wsemi 1.9.21 → 1.9.23

package/test/domGetFileAccept.test.mjs

@@ -1,11 +1,79 @@
-import assert from 'assert'
-//import domGetFileAccept from '../src/domGetFileAccept.mjs'
-
-
-describe(`domGetFileAccept`, function() {
-
-    it(`need test in browser`, function() {
-        assert.strict.deepStrictEqual(1, 1)
-    })
-
-})
+import assert from 'assert'
+import domGetFileAccept from '../src/domGetFileAccept.mjs'
+import base, { applyChanges } from './tools/getFileTypeBase.mjs'
+
+
+describe(`domGetFileAccept`, function() {
+
+    it(`need test in browser`, function() {
+        assert.strict.deepStrictEqual(1, 1)
+    })
+
+})
+
+
+//R-FILETYPE-01: 以修前基準表(獨立於 src)推得修前之 accept 片段, 驗證表擴充後(集合)只增不減
+describe(`domGetFileAccept 隨 getFileType 表擴充只增不減(R-FILETYPE-01)`, function() {
+
+    //oldRaw: 修前原樣; oldOf: 套用規則 5(heic 之 acp 為 image/heic)後之既有項目片段, 新增片段附於其後
+    let uniq = (arr) => [...new Set(arr)]
+    let rowsNow = applyChanges(base)
+    let oldRaw = (group) => uniq(base.filter((v) => v.group === group).map((v) => v.acp))
+    let oldOf = (group) => uniq(rowsNow.filter((v) => v.group === group).map((v) => v.acp))
+    let toks = (s) => (s === '' ? [] : s.split(','))
+
+    //image/heif 原由 heic 帶入, heic 改 image/heic 後改由新增之 heif 列帶入(位於新增片段中)
+    let addImage = ['image/svg+xml', 'image/heif', 'image/vnd.dxf']
+    let addData = [
+        'text/markdown',
+        'application/yaml',
+        'text/tab-separated-values',
+        'application/vnd.google-earth.kml+xml',
+        'application/gpx+xml',
+    ]
+
+    it(`'*' 與非字串/非陣列維持 '*'`, function() {
+        assert.strict.deepStrictEqual(domGetFileAccept('*'), '*')
+        assert.strict.deepStrictEqual(domGetFileAccept(), '*')
+        assert.strict.deepStrictEqual(domGetFileAccept(123), '*')
+    })
+
+    it(`'docums' 與 'compress' 與修前完全相同`, function() {
+        assert.strict.deepStrictEqual(domGetFileAccept('docums'), oldOf('docums').join(','))
+        assert.strict.deepStrictEqual(domGetFileAccept('compress'), oldOf('compress').join(','))
+    })
+
+    it(`'image': 既有片段與順序不變(heic 為 image/heic), 其後附加 ${addImage.join(',')}; 集合為修前之超集`, function() {
+        let r = toks(domGetFileAccept('image'))
+        assert.strict.deepStrictEqual(r, [...oldOf('image'), ...addImage])
+        assert.strict.deepStrictEqual(oldRaw('image').every((v) => r.includes(v)), true)
+        assert.strict.deepStrictEqual(r.includes('image/heic'), true)
+        assert.strict.deepStrictEqual(r.indexOf('image/heic') < r.indexOf('image/svg+xml'), true)
+    })
+
+    it(`'data': 修前片段與順序不變, 其後附加 ${addData.length} 項`, function() {
+        let r = toks(domGetFileAccept('data'))
+        assert.strict.deepStrictEqual(r, [...oldOf('data'), ...addData])
+    })
+
+    it(`'common': 修前片段與相對順序不變, 新增片段恰為 image 與 data 之附加項`, function() {
+        let old = [...oldOf('docums'), ...oldOf('compress'), ...oldOf('image'), ...oldOf('data')]
+        let oldR = [...oldRaw('docums'), ...oldRaw('compress'), ...oldRaw('image'), ...oldRaw('data')]
+        let r = toks(domGetFileAccept('common'))
+        assert.strict.deepStrictEqual(r.filter((v) => old.includes(v)), old)
+        assert.strict.deepStrictEqual(r.filter((v) => !old.includes(v)), [...addImage, ...addData])
+        assert.strict.deepStrictEqual(oldR.every((v) => r.includes(v)), true)
+    })
+
+    it(`以副檔名為 kind: 新增副檔名由 '' 改為對應 acp, 既有副檔名不變`, function() {
+        assert.strict.deepStrictEqual(domGetFileAccept(['jpg']), 'image/jpeg')
+        assert.strict.deepStrictEqual(domGetFileAccept(['jpeg']), 'image/jpeg')
+        assert.strict.deepStrictEqual(domGetFileAccept(['svg']), 'image/svg+xml')
+        assert.strict.deepStrictEqual(domGetFileAccept(['jpg', 'svg']), 'image/jpeg,image/svg+xml')
+        assert.strict.deepStrictEqual(domGetFileAccept(['md']), 'text/markdown')
+        assert.strict.deepStrictEqual(domGetFileAccept(['heic']), 'image/heic')
+        assert.strict.deepStrictEqual(domGetFileAccept(['heif']), 'image/heif')
+        assert.strict.deepStrictEqual(domGetFileAccept(['Z']), 'application/x-compress')
+    })
+
+})

package/test/flattenToConn.test.mjs

@@ -2,6 +2,89 @@ import assert from 'assert'
 import flattenToConn from '../src/flattenToConn.mjs'
 
 
+describe(`flattenToConn 偽稱Array之物件視為物件(R-OBJ-ITER-01 候選10)`, function() {
+
+    //以Symbol.toStringTag偽稱'Array'之物件(isarr為真而非真陣列), 可寫與不可寫兩種標籤
+    let mkFake = (len, writable) => {
+        let o = { a: 'kept', length: len }
+        if (writable) {
+            o[Symbol.toStringTag] = 'Array'
+        }
+        else {
+            Object.defineProperty(o, Symbol.toStringTag, { value: 'Array' })
+        }
+        return o
+    }
+
+    //flattenToConn以force走訪, 含Symbol鍵(treeObj取自有屬性名稱與自有Symbol), 偽標籤本身之Symbol鍵亦成一節點; 此處只比對字串鍵之節點
+    let strNodes = (r) => r.filter((v) => !/Symbol\(/.test(String(v.id)))
+
+    for (let writable of [true, false]) {
+        let tag = writable ? 'writable' : 'non-writable'
+
+        it(`should give the same nodes for a nested object faking Array (${tag} tag, length 2) as for the plain object with the same keys`, function() {
+            let r = strNodes(flattenToConn({ child: mkFake(2, writable) }))
+            let e = flattenToConn({ child: { a: 'kept', length: 2 } })
+            assert.strict.deepStrictEqual(r, e)
+            assert.strict.strictEqual(r[0].type, 'object')
+            assert.strict.strictEqual(r[0].numOfChilren, 2)
+            assert.strict.deepStrictEqual(r.map((v) => v.id), ['child', 'child-a', 'child-length'])
+        })
+
+        it(`should give the same nodes for a nested object faking Array (${tag} tag, length 0) as for the plain object with the same keys`, function() {
+            let r = strNodes(flattenToConn({ child: mkFake(0, writable) }))
+            let e = flattenToConn({ child: { a: 'kept', length: 0 } })
+            assert.strict.deepStrictEqual(r, e)
+            assert.strict.strictEqual(r[0].type, 'object')
+        })
+
+        it(`should give the same nodes for an object faking Array (${tag} tag, length 2) at the root as for the plain object with the same keys`, function() {
+            let r = strNodes(flattenToConn(mkFake(2, writable)))
+            let e = flattenToConn({ a: 'kept', length: 2 })
+            assert.strict.deepStrictEqual(r, e)
+            assert.strict.deepStrictEqual(r.map((v) => v.id), ['a', 'length'])
+        })
+    }
+
+    for (let writable of [true, false]) {
+        for (let len of [0, 2, 1000]) {
+            it(`should count the string keys as the children of an object faking Array (${writable ? 'writable' : 'non-writable'} tag, length ${len}), not the length value`, function() {
+                //R-OBJ-ITER-01: length為一般鍵, numOfChilren為自有鍵數(a與length共2), 與length之值無關
+                let o = { a: 'kept', length: len }
+                if (writable) {
+                    o[Symbol.toStringTag] = 'Array'
+                }
+                else {
+                    Object.defineProperty(o, Symbol.toStringTag, { value: 'Array' })
+                }
+                let r = flattenToConn({ child: o })
+                assert.strict.strictEqual(r[0].id, 'child')
+                assert.strict.strictEqual(r[0].type, 'object')
+                assert.strict.strictEqual(r[0].numOfChilren, 2)
+            })
+        }
+    }
+
+    for (let tag of ['Foo', 'Object', 'Arguments']) {
+        it(`should give array nodes for a real array with another Symbol.toStringTag (${tag}), like an ordinary array`, function() {
+            let a = Object.defineProperty([1, 2], Symbol.toStringTag, { value: tag })
+            let r = flattenToConn({ list: a })
+            let e = flattenToConn({ list: [1, 2] })
+            assert.strict.deepStrictEqual(r, e)
+            assert.strict.strictEqual(r[0].type, 'array')
+            assert.strict.deepStrictEqual(r.map((v) => v.id), ['list', 'list-0', 'list-1'])
+        })
+    }
+
+    it(`should still give array nodes for real arrays`, function() {
+        let r = flattenToConn({ list: [1, [2]] })
+        assert.strict.strictEqual(r[0].type, 'array')
+        assert.strict.strictEqual(r[0].numOfChilren, 2)
+        assert.strict.strictEqual(r.find((v) => v.id === 'list-1').type, 'array')
+    })
+
+})
+
 describe(`flattenToConn`, function() {
 
     let obj = {

package/test/flattenTree.test.mjs

@@ -2,6 +2,55 @@ import assert from 'assert'
 import flattenTree from '../src/flattenTree.mjs'
 
 
+describe(`flattenTree 偽稱Array之根節點視為物件(R-OBJ-ITER-01 候選10)`, function() {
+
+    //以Symbol.toStringTag偽稱'Array'之根節點(isarr為真而非真陣列): 結果須同無標籤之相同鍵物件(標籤不可寫者不展開進節點)
+    let mkFake = (writable, len = 2) => {
+        let o = { id: 1, length: len, children: [{ id: 2, data: 'x' }] }
+        if (writable) {
+            o[Symbol.toStringTag] = 'Array'
+        }
+        else {
+            Object.defineProperty(o, Symbol.toStringTag, { value: 'Array' })
+        }
+        return o
+    }
+
+    for (let writable of [true, false]) {
+        let tag = writable ? 'writable' : 'non-writable'
+        for (let len of [2, 0]) {
+            it(`should flatten a root object faking Array (${tag} tag, length ${len}) like the plain object with the same keys`, function() {
+                //根為物件時回傳根節點本身(含level與nk); length為0時不得被當成空陣列而回傳[]
+                let pick = (n) => ({ id: n.id, length: n.length, level: n.level, nk: n.nk, children: n.children })
+                let r = flattenTree(mkFake(writable, len))
+                let e = flattenTree({ id: 1, length: len, children: [{ id: 2, data: 'x' }] })
+                assert.strict.deepStrictEqual(pick(r), pick(e))
+                assert.strict.deepStrictEqual(pick(e), { id: 1, length: len, level: 0, nk: [0], children: [{ id: 2, data: 'x' }] })
+            })
+        }
+    }
+
+    for (let tag of ['Foo', 'Object']) {
+        it(`should flatten a real array root with another Symbol.toStringTag (${tag}) like an ordinary array`, function() {
+            let a = Object.defineProperty([{ id: 1, children: [{ id: 2 }] }], Symbol.toStringTag, { value: tag })
+            assert.strict.deepStrictEqual(flattenTree(a).map((v) => v.id), [1, 2])
+        })
+    }
+
+    it(`should return [] for an object faking Array without own string keys, like an empty object`, function() {
+        assert.strict.deepStrictEqual(flattenTree({ [Symbol.toStringTag]: 'Array' }), [])
+        assert.strict.deepStrictEqual(flattenTree(Object.defineProperty({}, Symbol.toStringTag, { value: 'Array' })), [])
+        assert.strict.deepStrictEqual(flattenTree({}), [])
+    })
+
+    it(`should still flatten a real array root and return [] for empty array and empty object`, function() {
+        assert.strict.deepStrictEqual(flattenTree([{ id: 1, children: [{ id: 2 }] }]).map((v) => v.id), [1, 2])
+        assert.strict.deepStrictEqual(flattenTree([]), [])
+        assert.strict.deepStrictEqual(flattenTree({}), [])
+    })
+
+})
+
 describe(`flattenTree`, function() {
 
     let obj = {

package/test/fsTask.test.mjs

@@ -3,8 +3,152 @@ import assert from 'assert'
 import fsDeleteFile from '../src/fsDeleteFile.mjs'
 import fsCreateFolder from '../src/fsCreateFolder.mjs'
 import fsDeleteFolder from '../src/fsDeleteFolder.mjs'
+import { fileURLToPath } from 'url'
+import { dirname, join } from 'path'
 import fsTask from '../src/fsTask.mjs'
 
+let __dirname = dirname(fileURLToPath(import.meta.url))
+
+
+describe(`fsTask 檔案來源之紀錄須為一般物件(R-OBJ-ITER-01 候選9)`, function() {
+
+    //fpHash.json、fpResult.json 讀自檔案(可能被竄改或損毀), 須視為一般物件之字典: length 為一般鍵, 非一般物件者視為無紀錄
+    let root = join(__dirname, '_tmp', 'fsTaskRecord')
+    let wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+    let item = (p) => [{ type: 'file', path: p }]
+
+    //測試自建自刪(只刪本案資料夾, 不刪 test/_tmp 根目錄)
+    after(function() {
+        fs.rmSync(root, { recursive: true, force: true })
+        assert.strict.strictEqual(fs.existsSync(root), false)
+    })
+
+    //mk, 建立案例資料夾: watch 為監看夾(可預放檔案), _tkfs 為儲存夾(可預寫紀錄檔原文)
+    let mk = (name, { hash = null, result = null, files = {} } = {}) => {
+        let base = join(root, name)
+        fs.rmSync(base, { recursive: true, force: true })
+        let fd = join(base, 'watch')
+        let st = join(base, '_tkfs')
+        fs.mkdirSync(fd, { recursive: true })
+        fs.mkdirSync(st, { recursive: true })
+        for (let [fn, c] of Object.entries(files)) {
+            fs.writeFileSync(join(fd, fn), c, 'utf8')
+        }
+        if (hash !== null) {
+            fs.writeFileSync(join(st, 'fpHash.json'), hash, 'utf8')
+        }
+        if (result !== null) {
+            fs.writeFileSync(join(st, 'fpResult.json'), result, 'utf8')
+        }
+        return { fd, st }
+    }
+
+    //watch, 以 40 ms 輪詢 ms 毫秒, 收集 change 事件並立即 resolve 其 pm
+    let watch = async (c, ms = 400) => {
+        let events = []
+        let ev = fsTask(c.fd, { fdStorage: c.st, timeInterval: 40 })
+        ev.on('change', (msg) => {
+            events.push({ type: msg.type, fp: msg.fp, fn: msg.fn, hash: msg.hash })
+            msg.pm.resolve()
+        })
+        try {
+            await wait(ms)
+        }
+        finally {
+            ev.clear()
+        }
+        return events
+    }
+
+    let readJson = (c, fn) => JSON.parse(fs.readFileSync(join(c.st, fn), 'utf8'))
+    let sortBy = (arr) => [...arr].sort((a, b) => (a.fp < b.fp ? -1 : 1))
+
+    it(`should treat a length key of fpHash.json as an ordinary path: one del event per recorded key and none repeated`, async function() {
+        //修前: 整個字典依 length 當類陣列迭代, 每個輪詢週期重複派發 { type: 'del', fp: '0', fn: '0', hash: '' }
+        let c = mk('hash-length', { hash: '{"length":1,"a":"h"}' })
+        let events = await watch(c, 500)
+        assert.strict.deepStrictEqual(sortBy(events), [
+            { type: 'del', fp: 'a', fn: 'a', hash: 'h' },
+            { type: 'del', fp: 'length', fn: 'length', hash: 1 },
+        ])
+        assert.strict.deepStrictEqual(readJson(c, 'fpHash.json'), {})
+    })
+
+    it(`should dispatch one del event for a recorded path and update the record (control without length)`, async function() {
+        let c = mk('hash-control', { hash: '{"a":"h"}' })
+        let events = await watch(c, 400)
+        assert.strict.deepStrictEqual(events, [{ type: 'del', fp: 'a', fn: 'a', hash: 'h' }])
+        assert.strict.deepStrictEqual(readJson(c, 'fpHash.json'), {})
+    })
+
+    it(`should dispatch add once for a watched file named length`, async function() {
+        let c = mk('hash-file-length', { files: { length: 'abc' } })
+        let events = await watch(c, 400)
+        assert.strict.deepStrictEqual(events.map((v) => [v.type, v.fn]), [['add', 'length']])
+        assert.strict.deepStrictEqual(Object.keys(readJson(c, 'fpHash.json')), [events[0].fp])
+    })
+
+    let notObjs = ['["a","b"]', '"abc"', '123', 'null', 'true', '{bad', '']
+    for (let content of notObjs) {
+        it(`should treat fpHash.json as no record when it is not a plain object (${JSON.stringify(content)}): no event for an empty folder`, async function() {
+            let c = mk('hash-notobj', { hash: content })
+            let events = await watch(c, 300)
+            assert.strict.deepStrictEqual(events, [])
+        })
+
+        it(`should dispatch add once for a new file and record it when fpHash.json is not a plain object (${JSON.stringify(content)})`, async function() {
+            let c = mk('hash-notobj-file', { hash: content, files: { 'f.txt': 'abc' } })
+            let events = await watch(c, 400)
+            assert.strict.deepStrictEqual(events.map((v) => [v.type, v.fn]), [['add', 'f.txt']])
+            assert.strict.deepStrictEqual(Object.keys(readJson(c, 'fpHash.json')), [events[0].fp])
+        })
+    }
+
+    it(`should keep other results and the length key when fpResult.json has a length key and a result is taken`, function() {
+        //修前: each 依 length 當類陣列迭代, 其他結果全被清空, 檔案寫成 {}
+        let c = mk('result-length', { result: JSON.stringify({ 'length': 0, 'a|h': item('x'), 'b|h': item('y') }) })
+        let ev = fsTask(c.fd, { fdStorage: c.st, timeInterval: 100000 })
+        try {
+            assert.strict.deepStrictEqual(ev.getAndEliminateResult('a', 'h'), item('x'))
+        }
+        finally {
+            ev.clear()
+        }
+        assert.strict.deepStrictEqual(readJson(c, 'fpResult.json'), { 'length': 0, 'b|h': item('y') })
+    })
+
+    it(`should keep other results when a result is taken (control without length)`, function() {
+        let c = mk('result-control', { result: JSON.stringify({ 'a|h': item('x'), 'b|h': item('y') }) })
+        let ev = fsTask(c.fd, { fdStorage: c.st, timeInterval: 100000 })
+        try {
+            assert.strict.deepStrictEqual(ev.getAndEliminateResult('a', 'h'), item('x'))
+        }
+        finally {
+            ev.clear()
+        }
+        assert.strict.deepStrictEqual(readJson(c, 'fpResult.json'), { 'b|h': item('y') })
+    })
+
+    for (let content of notObjs) {
+        it(`should treat fpResult.json as no record when it is not a plain object (${JSON.stringify(content)}): setResult does not throw and results can be taken`, function() {
+            //修前: 字串/數字/null/布林使 setResult 拋 TypeError, 字串被展開寫成 {"0":"a",...}
+            let c = mk('result-notobj', { result: content })
+            let ev = fsTask(c.fd, { fdStorage: c.st, timeInterval: 100000 })
+            try {
+                assert.strict.deepStrictEqual(ev.getAndEliminateResult('x', 'y'), [])
+                assert.strict.deepStrictEqual(readJson(c, 'fpResult.json'), {})
+                ev.setResult('f', 'h', item('p'))
+                assert.strict.deepStrictEqual(readJson(c, 'fpResult.json'), { 'f|h': item('p') })
+                assert.strict.deepStrictEqual(ev.getAndEliminateResult('f', 'h'), item('p'))
+                assert.strict.deepStrictEqual(readJson(c, 'fpResult.json'), {})
+            }
+            finally {
+                ev.clear()
+            }
+        })
+    }
+
+})
 
 describe(`fsTask`, function() {
 

package/test/getFileAccept.test.mjs

@@ -1,5 +1,7 @@
 import assert from 'assert'
 import getFileAccept from '../src/getFileAccept.mjs'
+import getFileType from '../src/getFileType.mjs'
+import base, { applyChanges } from './tools/getFileTypeBase.mjs'
 
 
 describe(`getFileAccept`, function() {
@@ -33,3 +35,84 @@ describe(`getFileAccept`, function() {
     })
 
 })
+
+
+describe(`getFileAccept 隨 getFileType 表擴充(R-FILETYPE-01)`, function() {
+
+    it(`getFileAccept() 與 getFileType() 為同一份全表, 前 ${base.length} 列為修前原樣(唯一差異 heic 之 acp)`, function() {
+        assert.strict.strictEqual(getFileAccept(), getFileType())
+        assert.strict.deepStrictEqual(getFileAccept().slice(0, base.length), applyChanges(base))
+    })
+
+    it(`依 acp 群組化: 既有成員順序不變, 新增成員附於其後`, function() {
+        let r = getFileAccept('acp')
+        assert.strict.deepStrictEqual(r['image/jpeg'].map((v) => v.name), ['jpg', 'jpeg', 'jpe', 'jfif'])
+        assert.strict.deepStrictEqual(r['image/tiff'].map((v) => v.name), ['tif', 'tiff'])
+        assert.strict.deepStrictEqual(r['text/plain'].map((v) => v.name), ['txt', 'log', 'ini'])
+        assert.strict.deepStrictEqual(r['image/heic'].map((v) => v.name), ['heic'])
+        assert.strict.deepStrictEqual(r['image/heif'].map((v) => v.name), ['heif'])
+        assert.strict.deepStrictEqual(r['image/svg+xml'].map((v) => v.name), ['svg'])
+        assert.strict.deepStrictEqual(r['text/markdown'].map((v) => v.name), ['md', 'markdown'])
+        assert.strict.deepStrictEqual(r['application/yaml'].map((v) => v.name), ['yaml', 'yml'])
+    })
+
+    it(`依 name 群組化: 每個鍵恰一列, 表內大寫鍵 Z 維持原樣`, function() {
+        let r = getFileAccept('name')
+        assert.strict.deepStrictEqual(Object.keys(r).length, getFileAccept().length)
+        assert.strict.deepStrictEqual(r['Z'].length, 1)
+    })
+
+})
+
+
+describe(`getFileAccept 分組鍵以自有屬性判斷(R-FILETYPE-01 規則 6)`, function() {
+
+    //Object.prototype 之成員名(不含 __proto__, 其由規則 1 禁止作為表內值)
+    let protoNames = ['constructor', 'toString', 'valueOf', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString']
+
+    //於 getFileType() 回傳之表尾暫時加列(getFileAccept 取同一份表), 結束必還原
+    function withRows(rows, fun) {
+        let tbl = getFileType()
+        let n0 = tbl.length
+        tbl.push(...rows)
+        try {
+            return fun()
+        }
+        finally {
+            tbl.splice(n0)
+        }
+    }
+
+    for (let by of ['name', 'acp', 'group', 'exec']) {
+        it(`${by} 之值為 Object.prototype 成員名: 不拋錯, 各值為自有鍵且成員為該值之列`, function() {
+            let mk = (v, i) => ({ name: `zz${i}`, group: 'g', acp: 'a/b', exec: '', [by]: v })
+            let rows = [...protoNames.map(mk), mk('constructor', 99)]
+            let r = withRows(rows, () => getFileAccept(by))
+            for (let v of protoNames) {
+                assert.strict.deepStrictEqual(Object.prototype.hasOwnProperty.call(r, v), true, v)
+                assert.strict.deepStrictEqual(Array.isArray(r[v]), true, v)
+                let expected = rows.filter((x) => x[by] === v)
+                assert.strict.deepStrictEqual(r[v], expected, v)
+            }
+            assert.strict.deepStrictEqual(r['constructor'].length, 2)
+        })
+    }
+
+    it(`回傳物件之原型仍為 Object.prototype, 分組值皆為陣列`, function() {
+        for (let by of ['name', 'acp', 'group', 'exec']) {
+            let r = getFileAccept(by)
+            assert.strict.strictEqual(Object.getPrototypeOf(r), Object.prototype)
+            for (let k of Object.keys(r)) {
+                assert.strict.deepStrictEqual(Array.isArray(r[k]), true, `${by} ${k}`)
+            }
+        }
+    })
+
+    it(`暫時加列後已還原, 表長度與修前加新增項相同`, function() {
+        let n = getFileType().length
+        withRows([{ name: 'zz', group: 'g', acp: 'a/b', exec: '' }], () => null)
+        assert.strict.deepStrictEqual(getFileType().length, n)
+        assert.strict.deepStrictEqual(n, base.length + 21)
+    })
+
+})