w-trade-solve 1.0.1

package/test/unit-calcFitness.test.mjs

@@ -0,0 +1,121 @@
+import assert from 'assert'
+import calcFitness from '../src/calcFitness.mjs'
+
+
+//規格來源: src/calcFitness.mjs
+//  calcFitness(settings, summary): 回傳適應值, 越小越佳
+//    ratioWin = clamp(p2r(summary.rWin), 0, 1), 貢獻 2*(1-ratioWin)
+//    rEqYear = clamp(p2r(summary.rEquivalentCumuProfitOrLossFinalNormYear), 0, 0.5)/0.5, 貢獻 1*(1-rEqYear)
+//    故無懲罰時fitness落於[0,3]
+//    summary.numTrade(經cint)為0時加1000000
+//    summary.uEquityFinal - settings.uIni <= 0 時加1000000
+
+
+let approx = (a, b, tol = 1e-9) => Math.abs(a - b) < tol
+
+
+//buildSummary: 預設為有交易且有獲利, 故不觸發任何懲罰
+let buildSummary = (opt = {}) => {
+    return {
+        numTrade: opt.numTrade !== undefined ? opt.numTrade : 30,
+        uEquityFinal: opt.uEquityFinal !== undefined ? opt.uEquityFinal : 1200,
+        rWin: opt.rWin !== undefined ? opt.rWin : '60%',
+        rEquivalentCumuProfitOrLossFinalNormYear: opt.rEq !== undefined ? opt.rEq : '25%',
+    }
+}
+
+
+let settings = { uIni: 1000 }
+
+
+describe('calcFitness', function() {
+
+    it('勝率與等效年化盈虧兩項加權求和: 2*(1-0.6) + 1*(1-0.25/0.5) = 1.3', function() {
+        let fitness = calcFitness(settings, buildSummary())
+        assert.ok(approx(fitness, 1.3), `實得 ${fitness}`)
+    })
+
+    it('勝率100%且等效年化盈虧達50%時fitness為下界0', function() {
+        let fitness = calcFitness(settings, buildSummary({ rWin: '100%', rEq: '50%' }))
+        assert.ok(approx(fitness, 0), `實得 ${fitness}`)
+    })
+
+    it('勝率0%且等效年化盈虧0%但仍有獲利時fitness為無懲罰之上界3', function() {
+        //uEquityFinal > uIni 故不觸發懲罰
+        let fitness = calcFitness(settings, buildSummary({ rWin: '0%', rEq: '0%' }))
+        assert.ok(approx(fitness, 3), `實得 ${fitness}`)
+    })
+
+    it('等效年化盈虧超過50%時限縮至50%, 與50%同值', function() {
+        let a = calcFitness(settings, buildSummary({ rEq: '80%' }))
+        let b = calcFitness(settings, buildSummary({ rEq: '50%' }))
+        assert.ok(approx(a, b), `${a} vs ${b}`)
+    })
+
+    it('等效年化盈虧為負時限縮至0, 與0%同值', function() {
+        let a = calcFitness(settings, buildSummary({ rEq: '-30%' }))
+        let b = calcFitness(settings, buildSummary({ rEq: '0%' }))
+        assert.ok(approx(a, b), `${a} vs ${b}`)
+    })
+
+    it('勝率超過100%時限縮至100%, 為負時限縮至0%', function() {
+        let hi = calcFitness(settings, buildSummary({ rWin: '150%' }))
+        let hiRef = calcFitness(settings, buildSummary({ rWin: '100%' }))
+        assert.ok(approx(hi, hiRef), `${hi} vs ${hiRef}`)
+
+        let lo = calcFitness(settings, buildSummary({ rWin: '-20%' }))
+        let loRef = calcFitness(settings, buildSummary({ rWin: '0%' }))
+        assert.ok(approx(lo, loRef), `${lo} vs ${loRef}`)
+    })
+
+    it('勝率越高fitness越小, 等效年化盈虧越高fitness越小', function() {
+        let a = calcFitness(settings, buildSummary({ rWin: '40%' }))
+        let b = calcFitness(settings, buildSummary({ rWin: '80%' }))
+        assert.ok(b < a, `勝率高者應較小: ${b} < ${a}`)
+
+        let c = calcFitness(settings, buildSummary({ rEq: '10%' }))
+        let e = calcFitness(settings, buildSummary({ rEq: '40%' }))
+        assert.ok(e < c, `年化高者應較小: ${e} < ${c}`)
+    })
+
+    it('勝率之權重為等效年化盈虧之2倍', function() {
+        //勝率自0%升至100%減少2, 年化自0%升至50%減少1
+        let base = calcFitness(settings, buildSummary({ rWin: '0%', rEq: '0%' }))
+        let byWin = calcFitness(settings, buildSummary({ rWin: '100%', rEq: '0%' }))
+        let byEq = calcFitness(settings, buildSummary({ rWin: '0%', rEq: '50%' }))
+        assert.ok(approx(base - byWin, 2), `勝率貢獻 ${base - byWin}`)
+        assert.ok(approx(base - byEq, 1), `年化貢獻 ${base - byEq}`)
+    })
+
+    it('交易次數為0時加懲罰值1000000', function() {
+        let withTrade = calcFitness(settings, buildSummary({ numTrade: 1 }))
+        let noTrade = calcFitness(settings, buildSummary({ numTrade: 0 }))
+        assert.ok(approx(noTrade - withTrade, 1000000), `差值 ${noTrade - withTrade}`)
+    })
+
+    it('最終累計盈虧小於等於0時加懲罰值1000000, 邊界(相等)亦觸發', function() {
+        let profit = calcFitness(settings, buildSummary({ uEquityFinal: 1000.01 }))
+        let flat = calcFitness(settings, buildSummary({ uEquityFinal: 1000 }))
+        let loss = calcFitness(settings, buildSummary({ uEquityFinal: 900 }))
+        assert.ok(approx(flat - profit, 1000000), `相等時差值 ${flat - profit}`)
+        assert.ok(approx(loss - profit, 1000000), `虧損時差值 ${loss - profit}`)
+    })
+
+    it('無交易且無獲利時兩懲罰值皆觸發', function() {
+        //rWin與rEq皆為空字串(w-trade-backtest於無交易時之值), p2r回0, 故基底為2*1+1*1=3
+        let fitness = calcFitness(settings, {
+            numTrade: 0,
+            uEquityFinal: 1000,
+            rWin: '',
+            rEquivalentCumuProfitOrLossFinalNormYear: '',
+        })
+        assert.ok(approx(fitness, 2000003), `實得 ${fitness}`)
+    })
+
+    it('交易次數為可解析之數字字串時亦正確判斷懲罰', function() {
+        let a = calcFitness(settings, buildSummary({ numTrade: '0' }))
+        let b = calcFitness(settings, buildSummary({ numTrade: '5' }))
+        assert.ok(approx(a - b, 1000000), `差值 ${a - b}`)
+    })
+
+})

package/test/unit-calcLevelNumTrade.test.mjs

@@ -0,0 +1,80 @@
+import assert from 'assert'
+import calcLevelNumTrade from '../src/calcLevelNumTrade.mjs'
+
+
+//規格來源: src/calcLevelNumTrade.mjs
+//  calcLevelNumTrade(numTrade): 交易次數轉為級距代碼
+//    numTrade非wsemi isnum判定之數值時throw, 通過後先經wsemi cint轉整數(四捨五入)
+//    級距: <=0→0, 1-5→1, 6-9→2, 10-24→11, 25-49→12, 50-74→13, 75-99→14,
+//          100-249→101, 250-499→102, 500-749→103, 750-999→104,
+//          1000-1999→1001, 2000-2999→1002, 3000-3999→1003, 4000-4999→1004, >=5000→100
+
+
+describe('calcLevelNumTrade', function() {
+
+    it('各級距之下界與上界皆對應規格代碼', function() {
+        let kp = [
+            [0, 0],
+            [1, 1], [5, 1],
+            [6, 2], [9, 2],
+            [10, 11], [24, 11],
+            [25, 12], [49, 12],
+            [50, 13], [74, 13],
+            [75, 14], [99, 14],
+            [100, 101], [249, 101],
+            [250, 102], [499, 102],
+            [500, 103], [749, 103],
+            [750, 104], [999, 104],
+            [1000, 1001], [1999, 1001],
+            [2000, 1002], [2999, 1002],
+            [3000, 1003], [3999, 1003],
+            [4000, 1004], [4999, 1004],
+            [5000, 100],
+        ]
+        kp.forEach(([numTrade, level]) => {
+            assert.strictEqual(calcLevelNumTrade(numTrade), level, `numTrade[${numTrade}]`)
+        })
+    })
+
+    it('負數交易次數視同0, 級距為0', function() {
+        assert.strictEqual(calcLevelNumTrade(-1), 0)
+        assert.strictEqual(calcLevelNumTrade(-100), 0)
+    })
+
+    it('超過5000之交易次數皆為級距100', function() {
+        assert.strictEqual(calcLevelNumTrade(8000), 100)
+        assert.strictEqual(calcLevelNumTrade(1000000), 100)
+    })
+
+    it('非整數先經cint四捨五入後再判級距', function() {
+        //cint(5.6)=6 落於6-9區間, cint(5.4)=5 落於1-5區間
+        assert.strictEqual(calcLevelNumTrade(5.6), 2)
+        assert.strictEqual(calcLevelNumTrade(5.4), 1)
+    })
+
+    it('可解析之數字字串亦為isnum認可之數值', function() {
+        assert.strictEqual(calcLevelNumTrade('30'), 12)
+    })
+
+    it('非數值時throw', function() {
+        assert.throws(() => {
+            calcLevelNumTrade('abc')
+        }, /is not a number/)
+        assert.throws(() => {
+            calcLevelNumTrade(null)
+        }, /is not a number/)
+        assert.throws(() => {
+            calcLevelNumTrade(undefined)
+        }, /is not a number/)
+        assert.throws(() => {
+            calcLevelNumTrade(NaN)
+        }, /is not a number/)
+    })
+
+    it('級距代碼非單調遞增, 但同級距內恆為同一代碼', function() {
+        //10-24與25-49皆對應11與12, 代碼僅為分群標記
+        assert.strictEqual(calcLevelNumTrade(10), calcLevelNumTrade(24))
+        assert.notStrictEqual(calcLevelNumTrade(24), calcLevelNumTrade(25))
+    })
+
+})

package/test/unit-estimComps.test.mjs

@@ -0,0 +1,193 @@
+import assert from 'assert'
+import fs from 'fs'
+import estimComps from '../src/estimComps.mjs'
+import readStrategies from '../src/readStrategies.mjs'
+import genTid from '../src/genTid.mjs'
+import ott from '../src/ott.mjs'
+import { buildFdTmp, buildFdData, buildSt, keySettings } from './unit-setup.mjs'
+
+
+//規格來源: src/estimComps.mjs
+//  estimComps(ott, st, fdOhlc, fdParam, timeStart, timeEnd, mode, comps, fdData, opt):
+//    comps以wsemi sep依','切割(自動trim並剔除空段), 須恰為3段否則throw
+//    3段依序為由keysNorm、keysIndex與keysVolumn各隨機挑選之key個數, 為0者不挑
+//    各類以wsemi randomIntsNdpRange不重複取樣後, 交由estimPicks與estimKeys
+//  觀察方式: 未給opt.keySettings時, keys非空則停在estimKeys之opt.keySettings檢核,
+//    keys為空則停在keys檢核, 兩者錯誤訊息不同, 故可驗證各類挑選是否生效
+
+
+let fdTmp = buildFdTmp('estimComps')
+
+
+let st = buildSt()
+
+
+let keyNormA = 'btc_4hr_ma_1day'
+let keyNormB = 'btc_4hr_rsi'
+let keyIndex = 'index_fear_greed'
+let keyVolumn = 'btc_4hr_vbs_ratio'
+let keysParam = [keyNormA, keyNormB, keyIndex, keyVolumn]
+
+
+let d = null
+
+
+//empty: 過濾函數, 將該類清空
+let empty = () => {
+    return []
+}
+
+
+//call: 以合法引數為底, 依ov覆寫指定引數後呼叫
+let call = (ov = {}) => {
+    let a = {
+        fdOhlc: d.fdOhlc,
+        fdParam: d.fdParam,
+        timeStart: d.timeStart,
+        timeEnd: d.timeEnd,
+        mode: 'long',
+        comps: '1,0,0',
+        fdData: d.fdData,
+        opt: {}, //未給keySettings, 使流程停在estimKeys之opt.keySettings檢核
+        ...ov,
+    }
+    return estimComps(ott, st, a.fdOhlc, a.fdParam, a.timeStart, a.timeEnd, a.mode, a.comps, a.fdData, a.opt)
+}
+
+
+describe('estimComps', function() {
+
+    before(function() {
+        d = buildFdData(fdTmp, 'comps', keysParam, { n: 10 })
+    })
+
+    after(function() {
+        fs.rmSync(fdTmp, { recursive: true, force: true })
+    })
+
+    describe('comps格式', function() {
+
+        it('非3段時throw', async function() {
+            await assert.rejects(call({ comps: '1,2' }), /非預期/)
+            await assert.rejects(call({ comps: '1,2,3,4' }), /非預期/)
+            await assert.rejects(call({ comps: '1' }), /非預期/)
+        })
+
+        it('空段被剔除後不足3段時throw', async function() {
+            //wsemi sep會剔除空段, 故'1,,2'僅為2段
+            await assert.rejects(call({ comps: '1,,2' }), /非預期/)
+        })
+
+        it('各段前後空白被trim, 不影響解析', async function() {
+            //' 1 , 0 , 0 '等同'1,0,0', 應挑到1個key而停在keySettings檢核
+            await assert.rejects(call({ comps: ' 1 , 0 , 0 ' }), /invalid opt.keySettings/)
+        })
+
+        it('comps非有效字串時throw', async function() {
+            await assert.rejects(call({ comps: '' }), /invalid comps/)
+            await assert.rejects(call({ comps: null }), /invalid comps/)
+        })
+
+    })
+
+    describe('各類挑選', function() {
+
+        it('三段皆為0時未挑任何key, estimKeys於keys檢核reject', async function() {
+            await assert.rejects(call({ comps: '0,0,0' }), /invalid keys/)
+        })
+
+        it('第1段對應一般類: 僅一般類有key時仍可挑出', async function() {
+            await assert.rejects(call({
+                comps: '1,0,0',
+                opt: { funFilterKeysIndex: empty, funFilterKeysVolumn: empty },
+            }), /invalid opt.keySettings/)
+        })
+
+        it('第2段對應指數類: 僅指數類有key時仍可挑出', async function() {
+            await assert.rejects(call({
+                comps: '0,1,0',
+                opt: { funFilterKeysNorm: empty, funFilterKeysVolumn: empty },
+            }), /invalid opt.keySettings/)
+        })
+
+        it('第3段對應成交量類: 僅成交量類有key時仍可挑出', async function() {
+            await assert.rejects(call({
+                comps: '0,0,1',
+                opt: { funFilterKeysNorm: empty, funFilterKeysIndex: empty },
+            }), /invalid opt.keySettings/)
+        })
+
+        it('向已清空之類別挑選時, 取樣範圍上界為-1而throw', async function() {
+            //pkn以randomIntsNdpRange(0, size(arr)-1, n)取樣, 空陣列時上界為-1
+            await assert.rejects(call({
+                comps: '1,0,0',
+                opt: { funFilterKeysNorm: empty },
+            }), /vstart\[0\] > vend\[-1\]/)
+        })
+
+        it('挑選個數超過該類key數時, 取樣結果以該類key數為上限', async function() {
+            //一般類僅2個key, 要求4個時仍可挑出(非空)而通過keys檢核
+            await assert.rejects(call({
+                comps: '4,0,0',
+                opt: { funFilterKeysIndex: empty, funFilterKeysVolumn: empty },
+            }), /invalid opt.keySettings/)
+        })
+
+    })
+
+    describe('端對端求解', function() {
+
+        it('comps=1,0,0且一般類僅1個key時, 產出策略之tid即該key所組成', async function() {
+            this.timeout(120000)
+
+            let dd = buildFdData(fdTmp, 'e2e', [keyNormA, keyIndex, keyVolumn], { n: 20 })
+
+            await estimComps(ott, st, dd.fdOhlc, dd.fdParam, dd.timeStart, dd.timeEnd, 'long', '1,0,0', dd.fdData, {
+                keySettings,
+                thsTp: [3],
+                thsSl: [2],
+                thNumTrade: 1,
+                thRWin: 0,
+                thREquivalentCumuProfitOrLossFinalNormYear: -1e9,
+            })
+
+            let ss = readStrategies(dd.fdData)
+            assert.ok(ss.length > 0, '門檻放寬時須有策略檔寫出')
+
+            let tid = genTid('btc', '4hr', 'long', [keyNormA])
+            ss.forEach((s) => {
+                assert.strictEqual(s.tid, tid, `檔名 ${s.name}`)
+            })
+        })
+
+    })
+
+    describe('輸入檢核', function() {
+
+        it('fdOhlc非有效字串時reject', async function() {
+            await assert.rejects(call({ fdOhlc: '' }), /invalid fdOhlc/)
+        })
+
+        it('fdParam非有效字串時reject', async function() {
+            await assert.rejects(call({ fdParam: '' }), /invalid fdParam/)
+        })
+
+        it('timeStart非有效字串時reject', async function() {
+            await assert.rejects(call({ timeStart: '' }), /invalid timeStart/)
+        })
+
+        it('timeEnd非有效字串時reject', async function() {
+            await assert.rejects(call({ timeEnd: '' }), /invalid timeEnd/)
+        })
+
+        it('mode非long或short時reject', async function() {
+            await assert.rejects(call({ mode: 'buy' }), /invalid mode/)
+        })
+
+        it('fdData非有效字串時reject', async function() {
+            await assert.rejects(call({ fdData: '' }), /invalid fdData/)
+        })
+
+    })
+
+})

package/test/unit-estimFinder.test.mjs

@@ -0,0 +1,184 @@
+import assert from 'assert'
+import fs from 'fs'
+import estimFinder from '../src/estimFinder.mjs'
+import ott from '../src/ott.mjs'
+import { buildFdTmp, buildFdData, buildSt, keySettings } from './unit-setup.mjs'
+
+
+//規格來源: src/estimFinder.mjs
+//  estimFinder(ott, st, fdOhlc, fdParam, fdData, opt):
+//    mode未給時由'long'與'short'隨機取一
+//    timeStart未給時為'2022-07-01T00:00:00'
+//    timeEnd未給時依mode給予: long為'2025-04-08T00:00:00', short為'2025-10-06T00:00:00'
+//    comps未給時由18種預設組成隨機取一, 各組成之第1段皆>=2、第2段0-2、第3段0-1
+//    最後交由estimComps
+//  觀察方式: 測試資料自2022-07-01起算且僅數十根K線, 故預設timeStart恰通過而預設timeEnd必然超出資料範圍,
+//    w-data-tdprovide拋出之訊息內含實際使用之timeStart與timeEnd, 藉此驗證預設值
+
+
+let fdTmp = buildFdTmp('estimFinder')
+
+
+let st = buildSt()
+
+
+//keysParam: norm 4個、index 2個、volumn 1個, 使18種預設comps皆可取樣
+let keysNorm = ['btc_4hr_ma_1day', 'btc_4hr_ma_2day', 'btc_4hr_rsi', 'btc_4hr_kdj']
+let keysIndex = ['index_fear_greed', 'index_dxy']
+let keysVolumn = ['btc_4hr_vbs_ratio']
+let keysParam = [...keysNorm, ...keysIndex, ...keysVolumn]
+
+
+//tBase2022: 測試資料起始時間, 恰為estimFinder之預設timeStart
+let tBase2022 = Date.UTC(2022, 6, 1)
+
+
+let d = null
+
+
+//call: 以合法引數為底, 依ov.opt覆寫opt後呼叫
+let call = (ov = {}) => {
+    let a = {
+        fdOhlc: d.fdOhlc,
+        fdParam: d.fdParam,
+        fdData: d.fdData,
+        opt: { keySettings, comps: '1,0,0' },
+        ...ov,
+    }
+    return estimFinder(ott, st, a.fdOhlc, a.fdParam, a.fdData, a.opt)
+}
+
+
+//catchMsg: 取得reject之錯誤訊息
+let catchMsg = async (pm) => {
+    try {
+        await pm
+    }
+    catch (err) {
+        return err.message
+    }
+    throw new Error('未如預期reject')
+}
+
+
+describe('estimFinder', function() {
+
+    before(function() {
+        d = buildFdData(fdTmp, 'finder', keysParam, { n: 30, base: tBase2022 })
+    })
+
+    after(function() {
+        fs.rmSync(fdTmp, { recursive: true, force: true })
+    })
+
+    describe('timeStart預設與覆寫', function() {
+
+        it('未給opt.timeStart時使用2022-07-01T00:00:00', async function() {
+            //測試資料恰自2022-07-01起算, 故預設timeStart通過而停在timeEnd檢核
+            let msg = await catchMsg(call({ opt: { keySettings, comps: '1,0,0', mode: 'long' } }))
+            assert.match(msg, /timeEnd/, `實得: ${msg}`)
+            assert.doesNotMatch(msg, /timeStartData/, `實得: ${msg}`)
+        })
+
+        it('資料起始晚於預設timeStart時, 錯誤訊息指出預設之timeStart', async function() {
+            let dd = buildFdData(fdTmp, 'ts-late', keysNorm, { n: 10, base: Date.UTC(2023, 0, 1) })
+            let msg = await catchMsg(estimFinder(ott, st, dd.fdOhlc, dd.fdParam, dd.fdData, { keySettings, comps: '1,0,0', mode: 'long' }))
+            assert.match(msg, /timeStart\[2022-07-01T00:00:00\]/, `實得: ${msg}`)
+        })
+
+        it('給予opt.timeStart時以其覆寫預設值', async function() {
+            let msg = await catchMsg(call({ opt: { keySettings, comps: '1,0,0', mode: 'long', timeStart: '1990-01-01T00:00:00' } }))
+            assert.match(msg, /timeStart\[1990-01-01T00:00:00\]/, `實得: ${msg}`)
+        })
+
+    })
+
+    describe('timeEnd預設與覆寫', function() {
+
+        it('mode為long時預設timeEnd為2025-04-08T00:00:00', async function() {
+            let msg = await catchMsg(call({ opt: { keySettings, comps: '1,0,0', mode: 'long' } }))
+            assert.match(msg, /timeEnd\[2025-04-08T00:00:00\]/, `實得: ${msg}`)
+        })
+
+        it('mode為short時預設timeEnd為2025-10-06T00:00:00', async function() {
+            let msg = await catchMsg(call({ opt: { keySettings, comps: '1,0,0', mode: 'short' } }))
+            assert.match(msg, /timeEnd\[2025-10-06T00:00:00\]/, `實得: ${msg}`)
+        })
+
+        it('給予opt.timeEnd時以其覆寫預設值, 不再依mode區分', async function() {
+            let msgLong = await catchMsg(call({ opt: { keySettings, comps: '1,0,0', mode: 'long', timeEnd: '2099-01-01T00:00:00' } }))
+            let msgShort = await catchMsg(call({ opt: { keySettings, comps: '1,0,0', mode: 'short', timeEnd: '2099-01-01T00:00:00' } }))
+            assert.match(msgLong, /timeEnd\[2099-01-01T00:00:00\]/, `實得: ${msgLong}`)
+            assert.match(msgShort, /timeEnd\[2099-01-01T00:00:00\]/, `實得: ${msgShort}`)
+        })
+
+    })
+
+    describe('mode預設', function() {
+
+        it('未給opt.mode時由long與short隨機取一, 兩者於多次呼叫皆出現', async function() {
+            this.timeout(60000)
+
+            //以預設timeEnd反推所用之mode: long對應2025-04-08, short對應2025-10-06
+            let got = new Set()
+            for (let i = 0; i < 40; i++) {
+                let msg = await catchMsg(call({ opt: { keySettings, comps: '1,0,0' } }))
+                if (msg.indexOf('timeEnd[2025-04-08T00:00:00]') >= 0) {
+                    got.add('long')
+                }
+                else if (msg.indexOf('timeEnd[2025-10-06T00:00:00]') >= 0) {
+                    got.add('short')
+                }
+                else {
+                    assert.fail(`非預期之timeEnd: ${msg}`)
+                }
+            }
+            assert.deepStrictEqual([...got].sort(), ['long', 'short'])
+        })
+
+        it('給予opt.mode時不再隨機', async function() {
+            for (let i = 0; i < 10; i++) {
+                let msg = await catchMsg(call({ opt: { keySettings, comps: '1,0,0', mode: 'short' } }))
+                assert.match(msg, /timeEnd\[2025-10-06T00:00:00\]/, `實得: ${msg}`)
+            }
+        })
+
+    })
+
+    describe('comps預設與覆寫', function() {
+
+        it('未給opt.comps時由預設組成隨機取一, 挑出之keys非空', async function() {
+            //opt未給keySettings, keys非空時停在estimKeys之opt.keySettings檢核
+            for (let i = 0; i < 20; i++) {
+                await assert.rejects(call({ opt: {} }), /invalid opt.keySettings/)
+            }
+        })
+
+        it('給予opt.comps時以其覆寫, 三段皆為0則未挑任何key', async function() {
+            await assert.rejects(call({ opt: { keySettings, comps: '0,0,0' } }), /invalid keys/)
+        })
+
+        it('給予非3段之opt.comps時throw', async function() {
+            await assert.rejects(call({ opt: { keySettings, comps: '1,2' } }), /非預期/)
+        })
+
+    })
+
+    describe('輸入檢核', function() {
+
+        it('fdOhlc非有效字串時reject', async function() {
+            await assert.rejects(call({ fdOhlc: '' }), /invalid fdOhlc/)
+            await assert.rejects(call({ fdOhlc: null }), /invalid fdOhlc/)
+        })
+
+        it('fdParam非有效字串時reject', async function() {
+            await assert.rejects(call({ fdParam: '' }), /invalid fdParam/)
+        })
+
+        it('fdData非有效字串時reject', async function() {
+            await assert.rejects(call({ fdData: '' }), /invalid fdData/)
+        })
+
+    })
+
+})