nadesiko3 3.7.21 → 3.7.22

package/core/test/nako_parser_test.mjs

@@ -0,0 +1,160 @@
+/* eslint-disable no-undef */
+/**
+ * 構文解析器(NakoParser)の回帰テスト (#2364)
+ *
+ * `core/src/nako_parser3.mts` は 2,900 行を超える大きなファイルで、
+ * これまでパーサを直接検証するテストが無く、回帰は実行結果(runAsync)経由でしか
+ * 検出できなかった。パーサの内部構造に手を入れる際の安全網として、
+ * 構文解析の結果である AST そのものを検証する。
+ *
+ * 2 段構えで検証している。
+ *
+ *  1. 構造アサーション … パーサの仕様を人間が読める形で固定する
+ *  2. ゴールデン比較   … AST の全キー・全値・キーの並び順まで含めて完全一致を確認する
+ *
+ * コーパスとゴールデンファイルの更新方法は `fixtures/README.md` を参照。
+ */
+import { describe, it } from 'node:test'
+import assert from 'assert'
+import fs from 'node:fs'
+import { PARSER_CORPUS, parseToPlainAst } from './fixtures/parser_corpus.mjs'
+
+/** ブロック直下のノード種別を並べる(構造アサーション用) */
+function blockTypes (ast) {
+  return ast.blocks.filter((n) => n.type !== 'eol').map((n) => n.type)
+}
+
+/** 最初の(eol 以外の)文を取り出す */
+function firstSentence (ast) {
+  return ast.blocks.find((n) => n.type !== 'eol')
+}
+
+describe('nako_parser_test', () => {
+  // -------------------------------------------------------------------------
+  // 1. 構造アサーション … パーサの仕様を人間が読める形で固定する
+  // -------------------------------------------------------------------------
+  describe('構造アサーション', () => {
+    it('文の並びが block になる', () => {
+      const ast = parseToPlainAst('A=1\nB=2\n')
+      assert.strictEqual(ast.type, 'block')
+      assert.deepStrictEqual(blockTypes(ast), ['let', 'let'])
+    })
+
+    it('代入は let になり変数名にモジュール名が付く', () => {
+      const let1 = firstSentence(parseToPlainAst('A=1\n'))
+      assert.strictEqual(let1.type, 'let')
+      assert.strictEqual(let1.name, 'main__A')
+      assert.strictEqual(let1.blocks[0].type, 'number')
+      assert.strictEqual(let1.blocks[0].value, 1)
+    })
+
+    it('関数呼び出しは func になり助詞で引数が結び付く', () => {
+      const func = firstSentence(parseToPlainAst('「あ」を表示\n'))
+      assert.strictEqual(func.type, 'func')
+      assert.strictEqual(func.name, '表示')
+      assert.strictEqual(func.blocks.length, 1)
+      assert.strictEqual(func.blocks[0].value, 'あ')
+      assert.strictEqual(func.blocks[0].josi, 'を')
+    })
+
+    it('演算子の優先順位が AST の入れ子に反映される', () => {
+      // 1+2*3 は 1+(2*3) になる
+      const func = firstSentence(parseToPlainAst('1+2*3を表示\n'))
+      const op = func.blocks[0]
+      assert.strictEqual(op.type, 'op')
+      assert.strictEqual(op.operator, '+')
+      assert.strictEqual(op.blocks[0].value, 1)
+      assert.strictEqual(op.blocks[1].operator, '*')
+      assert.strictEqual(op.blocks[1].blocks[0].value, 2)
+      assert.strictEqual(op.blocks[1].blocks[1].value, 3)
+    })
+
+    it('カッコが優先順位を上書きする', () => {
+      // (1+2)*3 は (1+2) が先
+      const func = firstSentence(parseToPlainAst('(1+2)*3を表示\n'))
+      const op = func.blocks[0]
+      assert.strictEqual(op.operator, '*')
+      assert.strictEqual(op.blocks[0].operator, '+')
+      assert.strictEqual(op.blocks[1].value, 3)
+    })
+
+    it('もし文は if になり blocks が [条件, 真, 偽] の順になる', () => {
+      const ifAst = firstSentence(parseToPlainAst('もしA=1ならば\nB=1\n違えば\nB=2\nここまで\n'))
+      assert.strictEqual(ifAst.type, 'if')
+      assert.strictEqual(ifAst.blocks.length, 3)
+      assert.strictEqual(ifAst.blocks[0].type, 'op')
+      assert.strictEqual(ifAst.blocks[0].operator, 'eq')
+    })
+
+    it('関数定義は def_func になり引数リストを持つ', () => {
+      // 『足す』は送り仮名が落ちて『足』になる
+      const def = firstSentence(parseToPlainAst('●(AとBを)足すとは\nA+Bで戻る\nここまで\n'))
+      assert.strictEqual(def.type, 'def_func')
+      assert.strictEqual(def.name, 'main__足')
+      assert.deepStrictEqual(def.meta.varnames, ['A', 'B'])
+      assert.deepStrictEqual(def.meta.josi, [['と'], ['を']])
+    })
+
+    it('配列リテラルは json_array になる', () => {
+      const let1 = firstSentence(parseToPlainAst('A=[1,2,3]\n'))
+      assert.strictEqual(let1.blocks[0].type, 'json_array')
+      assert.deepStrictEqual(let1.blocks[0].blocks.map((n) => n.value), [1, 2, 3])
+    })
+
+    it('辞書リテラルは json_obj になりキーと値が交互に並ぶ', () => {
+      const let1 = firstSentence(parseToPlainAst('A={"a":1,"b":2}\n'))
+      const obj = let1.blocks[0]
+      assert.strictEqual(obj.type, 'json_obj')
+      assert.deepStrictEqual(obj.blocks.map((n) => n.value), ['a', 1, 'b', 2])
+    })
+
+    it('配列要素への代入は let_array になる', () => {
+      const ast = parseToPlainAst('A=[0]\nA[0]=1\n')
+      assert.deepStrictEqual(blockTypes(ast), ['let', 'let_array'])
+    })
+
+    it('繰り返し文は for になる', () => {
+      const forAst = firstSentence(parseToPlainAst('Nを1から10まで繰り返す\nNを表示\nここまで\n'))
+      assert.strictEqual(forAst.type, 'for')
+      assert.strictEqual(forAst.blocks[0].value, 1)
+      assert.strictEqual(forAst.blocks[1].value, 10)
+    })
+
+    it('連文は block として接続される', () => {
+      const renbun = firstSentence(parseToPlainAst('1に2を足して3を掛けて表示\n'))
+      assert.strictEqual(renbun.type, 'block')
+    })
+
+    it('非同期関数を呼ぶ関数には asyncFn が伝播する', () => {
+      const ast = parseToPlainAst('●Fとは\n1秒待つ\nここまで\nF\n')
+      const def = ast.blocks.find((n) => n.type === 'def_func')
+      assert.ok(def, 'def_func が見つかりません')
+      assert.strictEqual(def.asyncFn, true, '『待つ』を呼ぶ関数Fは非同期になる')
+    })
+
+    it('エラー監視は try_except になる', () => {
+      const tryAst = firstSentence(parseToPlainAst('エラー監視\nA=1\nエラーならば\nB=2\nここまで\n'))
+      assert.strictEqual(tryAst.type, 'try_except')
+      assert.strictEqual(tryAst.blocks.length, 2)
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // 2. ゴールデン比較 … AST が 1 バイトも変わらないことを確認する
+  // -------------------------------------------------------------------------
+  describe('ゴールデン比較', () => {
+    const goldenPath = new URL('./fixtures/parser_ast_golden.json', import.meta.url)
+    const golden = JSON.parse(fs.readFileSync(goldenPath, 'utf8'))
+
+    it('ゴールデンとコーパスの項目が一致する', () => {
+      assert.deepStrictEqual(Object.keys(golden), Object.keys(PARSER_CORPUS),
+        'コーパスを変更したらゴールデンを再生成すること (fixtures/README.md 参照)')
+    })
+
+    for (const [name, code] of Object.entries(PARSER_CORPUS)) {
+      it(name, () => {
+        assert.deepStrictEqual(parseToPlainAst(code), golden[name])
+      })
+    }
+  })
+})

package/core/test/nako_plugin_manager_test.mjs

@@ -0,0 +1,185 @@
+/* eslint-disable no-undef */
+import { describe, it } from 'node:test'
+import assert from 'assert'
+
+import { NakoCompiler } from '../src/nako3.mjs'
+import { NakoPluginManager, PLUGIN_MIN_VERSION_INT } from '../src/nako_plugin_manager.mjs'
+import { NakoLogger } from '../src/nako_logger.mjs'
+
+/**
+ * プラグイン管理を NakoCompiler から分離したモジュールのテスト (#2360)
+ */
+describe('nako_plugin_manager_test', () => {
+  /** テスト用にホストを差し替えた NakoPluginManager を作る */
+  const createManager = () => {
+    const funclist = new Map()
+    const sysVars = new Map()
+    const logger = new NakoLogger()
+    const manager = new NakoPluginManager({
+      getFuncList: () => funclist,
+      getSysVars: () => sysVars,
+      getLogger: () => logger
+    })
+    return { manager, funclist, sysVars, logger }
+  }
+
+  /** 現在のバージョン要求を満たすメタ情報を作る */
+  const newMeta = (pluginName, nakoVersion = '3.6.0') => {
+    return { type: 'const', value: { pluginName, nakoVersion } }
+  }
+
+  it('プラグイン名が重複した場合は登録されない', () => {
+    const nako = new NakoCompiler()
+    nako.addPlugin({
+      meta: newMeta('DuplicatedPlugin'),
+      重複テスト値: { type: 'const', value: 1 }
+    })
+    nako.addPlugin({
+      meta: newMeta('DuplicatedPlugin'),
+      重複テスト値: { type: 'const', value: 2 }
+    })
+    // 2回目の登録は無視されるので、最初に登録した値のままになる
+    assert.strictEqual(nako.getFunc('重複テスト値').value, 1)
+  })
+
+  it('metaが無い場合はプラグイン名をキー名から自動生成する', () => {
+    const { manager, sysVars } = createManager()
+    manager.addPlugin({ hoge: { type: 'const', value: 1 } })
+    const pluginInfo = sysVars.get('__pluginInfo')
+    assert.ok(pluginInfo.hoge !== undefined, 'キー名からプラグイン名が作られること')
+    assert.ok(manager.pluginfiles.hoge !== undefined)
+  })
+
+  it('古い形式のプラグインは nakoVersionResult が false になる', () => {
+    const { manager, sysVars } = createManager()
+    // PLUGIN_MIN_VERSION_INT(600) より小さいバージョンを指定する
+    manager.addPlugin({
+      meta: newMeta('OldPlugin', '3.5.99'),
+      古い値: { type: 'const', value: 1 }
+    })
+    const pluginInfo = sysVars.get('__pluginInfo')
+    assert.strictEqual(pluginInfo.OldPlugin.nakoVersionResult, false)
+    assert.strictEqual(PLUGIN_MIN_VERSION_INT, 600)
+  })
+
+  it('新しい形式のプラグインは nakoVersionResult が true のまま', () => {
+    const { manager, sysVars } = createManager()
+    manager.addPlugin({
+      meta: newMeta('NewPlugin', '3.6.0'),
+      新しい値: { type: 'const', value: 1 }
+    })
+    const pluginInfo = sysVars.get('__pluginInfo')
+    assert.notStrictEqual(pluginInfo.NewPlugin.nakoVersionResult, false)
+  })
+
+  it('「初期化」は「!プラグイン名:初期化」へ変換される', () => {
+    const { manager } = createManager()
+    const po = {
+      meta: newMeta('InitPlugin'),
+      初期化: { type: 'func', josi: [], fn: () => {} }
+    }
+    manager.addPlugin(po)
+    assert.strictEqual(po['初期化'], undefined)
+    assert.strictEqual(typeof po['!InitPlugin:初期化'], 'object')
+  })
+
+  it('ファイル名に使えない文字はアンダースコアに置換される', () => {
+    assert.strictEqual(NakoPluginManager.removeInvalidFilenameChars('my plugin/name'), 'my_plugin_name')
+    // 日本語(ひらがな・カタカナ・漢字)はそのまま残る
+    assert.strictEqual(NakoPluginManager.removeInvalidFilenameChars('プラグイン漢字かな'), 'プラグイン漢字かな')
+  })
+
+  it('プラグイン名の不正文字を置換した名前で登録される', () => {
+    const { manager, sysVars } = createManager()
+    manager.addPlugin({
+      meta: newMeta('my plugin/name'),
+      置換テスト値: { type: 'const', value: 1 }
+    })
+    const pluginInfo = sysVars.get('__pluginInfo')
+    assert.ok(pluginInfo.my_plugin_name !== undefined)
+    assert.ok(manager.modules.my_plugin_name !== undefined)
+  })
+
+  it('「初期化」と「!」で始まるキーはコマンド一覧に登録されない', () => {
+    const { manager } = createManager()
+    manager.addPlugin({
+      meta: newMeta('CommandListPlugin'),
+      普通の値: { type: 'const', value: 1 },
+      '!クリア': { type: 'func', josi: [], fn: () => {} },
+      初期化: { type: 'func', josi: [], fn: () => {} }
+    })
+    assert.strictEqual(manager.hasCommand('普通の値'), true)
+    assert.strictEqual(manager.hasCommand('!クリア'), false)
+    assert.strictEqual(manager.hasCommand('初期化'), false)
+    assert.strictEqual(manager.hasCommand('!CommandListPlugin:初期化'), false)
+  })
+
+  it('addFuncで登録した関数をgetFuncで参照できる', () => {
+    const { manager, sysVars } = createManager()
+    const fn = (a) => a
+    manager.addFunc('テスト関数', [['を']], fn, false)
+    const f = manager.getFunc('テスト関数')
+    assert.strictEqual(f.type, 'func')
+    assert.strictEqual(f.return_none, false)
+    assert.strictEqual(sysVars.get('テスト関数'), fn)
+  })
+
+  it('createFuncListFromPluginsはプラグイン由来の関数だけを返す', () => {
+    const { manager, sysVars } = createManager()
+    manager.addPlugin({
+      meta: newMeta('ResetPlugin'),
+      プラグイン値: { type: 'const', value: 1 }
+    })
+    // ユーザー定義関数を模したものはシステム領域には登録されない
+    const funclist = manager.createFuncListFromPlugins(sysVars)
+    assert.strictEqual(funclist.has('プラグイン値'), true)
+    assert.strictEqual(funclist.has('ユーザー関数'), false)
+  })
+
+  it('reset()するとユーザー定義関数は消えプラグイン関数は残る', async () => {
+    const nako = new NakoCompiler()
+    await nako.runAsync('●(Aを)ユーザー関数とは\nAを戻す\nここまで', 'main.nako3')
+    // ユーザー定義関数は名前空間付きで登録される
+    assert.ok(nako.getFunc('main__ユーザー関数') !== undefined)
+    nako.reset()
+    assert.strictEqual(nako.getFunc('main__ユーザー関数'), undefined)
+    assert.ok(nako.getFunc('表示') !== undefined, 'プラグインの命令は残ること')
+  })
+
+  it('NakoCompiler.__module と NakoPluginManager.modules は同じ内容を指す', () => {
+    const nako = new NakoCompiler()
+    nako.addPlugin({
+      meta: newMeta('ModuleSharePlugin'),
+      共有テスト値: { type: 'const', value: 1 }
+    })
+    assert.ok(nako.__module.ModuleSharePlugin !== undefined)
+    assert.ok(nako.getPluginfiles().ModuleSharePlugin !== undefined)
+  })
+
+  it('addPluginObjectはmetaが無いプラグインに名前を付ける', () => {
+    const { manager, sysVars } = createManager()
+    manager.addPluginObject('ObjectPlugin', { オブジェクト値: { type: 'const', value: 1 } })
+    const pluginInfo = sysVars.get('__pluginInfo')
+    assert.ok(pluginInfo.ObjectPlugin !== undefined)
+  })
+
+  it('addPluginFromFileはメタ情報にファイルパスを記録する', () => {
+    const { manager, sysVars } = createManager()
+    manager.addPluginFromFile('/path/to/plugin.mjs', {
+      meta: newMeta('FilePlugin'),
+      ファイル値: { type: 'const', value: 1 }
+    })
+    const pluginInfo = sysVars.get('__pluginInfo')
+    assert.strictEqual(pluginInfo.FilePlugin.path, '/path/to/plugin.mjs')
+  })
+
+  it('未知のtypeを持つプラグインはエラーになる', () => {
+    const { manager } = createManager()
+    assert.throws(() => {
+      manager.addPlugin({
+        meta: newMeta('BrokenPlugin'),
+        壊れた値: { type: 'unknown', value: 1 }
+      })
+    }, /プラグインの追加でエラー/)
+  })
+})

package/core/test/nako_require_test.mjs

@@ -0,0 +1,153 @@
+/* eslint-disable no-undef */
+import { describe, it } from 'node:test'
+import assert from 'assert'
+
+import { NakoCompiler } from '../src/nako3.mjs'
+import { listRequireStatements, NakoRequireLoader } from '../src/nako_require.mjs'
+import { NakoImportError } from '../src/nako_errors.mjs'
+
+/**
+ * 取り込み文(require)の処理を NakoCompiler から分離したモジュールのテスト (#2360)
+ */
+describe('nako_require_test', () => {
+  /** テスト用のローダーを作る。addPluginFromFile の呼び出し履歴も返す */
+  const createLoader = () => {
+    const nako = new NakoCompiler()
+    const addedPlugins = []
+    const loader = new NakoRequireLoader({
+      rawtokenize: (code, line, filename, preCode) => nako.rawtokenize(code, line, filename, preCode),
+      addPluginFromFile: (fpath, po) => { addedPlugins.push({ fpath, po }) },
+      getLogger: () => nako.getLogger(),
+      createScanner: () => new NakoCompiler(),
+      countFailure: () => {}
+    })
+    return { nako, loader, addedPlugins }
+  }
+
+  /** 依存ファイルの情報を作る */
+  const newDependency = (nako, filePath, code) => {
+    return {
+      tokens: nako.rawtokenize(code, 0, filePath),
+      alias: new Set([filePath]),
+      addPluginFile: () => {},
+      funclist: new Map(),
+      moduleExport: new Map()
+    }
+  }
+
+  it('export関数とNakoCompilerのstaticメソッドは同じ結果を返す', () => {
+    const nako = new NakoCompiler()
+    const tokens = nako.rawtokenize('!「hoge.nako3」を取り込む\n「テスト」を表示\n', 0, 'main.nako3')
+    const a = listRequireStatements(tokens).map((t) => t.value)
+    const b = NakoCompiler.listRequireStatements(tokens).map((t) => t.value)
+    assert.deepStrictEqual(a, ['hoge.nako3'])
+    assert.deepStrictEqual(a, b)
+  })
+
+  it('複数の取り込み文をstartの昇順で列挙する', () => {
+    const nako = new NakoCompiler()
+    const code = '!「a.nako3」を取り込む\n!「b.nako3」を取り込む\n!「c.nako3」を取り込む\n'
+    const tokens = nako.rawtokenize(code, 0, 'main.nako3')
+    const list = listRequireStatements(tokens)
+    assert.deepStrictEqual(list.map((t) => t.value), ['a.nako3', 'b.nako3', 'c.nako3'])
+    for (let i = 0; i < list.length; i++) {
+      assert.strictEqual(list[i].end, list[i].start + 3, '取り込み文は3トークンで構成される')
+      if (i > 0) {
+        assert.ok(list[i - 1].start < list[i].start, 'startの昇順に並んでいること')
+      }
+    }
+  })
+
+  it('相互に取り込み合うファイルでも無限ループしない', () => {
+    const { nako, loader } = createLoader()
+    // a.nako3 は b.nako3 を、b.nako3 は a.nako3 を取り込む
+    loader.dependencies = {
+      'a.nako3': newDependency(nako, 'a.nako3', '!「b.nako3」を取り込む\n「A」を表示\n'),
+      'b.nako3': newDependency(nako, 'b.nako3', '!「a.nako3」を取り込む\n「B」を表示\n')
+    }
+    const tokens = nako.rawtokenize('!「a.nako3」を取り込む\n「M」を表示\n', 0, 'main.nako3')
+    const deleted = loader.replaceRequireStatements(tokens)
+    assert.ok(deleted.length > 0, '取り込み文が削除されること')
+    assert.strictEqual(listRequireStatements(tokens).length, 0, '取り込み文がすべて置換されること')
+  })
+
+  it('removeRequireStatementsは取り込み文を削除する', () => {
+    const { nako, loader } = createLoader()
+    let called = 0
+    loader.dependencies = {
+      'a.nako3': { ...newDependency(nako, 'a.nako3', '「A」を表示\n'), addPluginFile: () => { called++ } }
+    }
+    const tokens = nako.rawtokenize('!「a.nako3」を取り込む\n「M」を表示\n', 0, 'main.nako3')
+    const deleted = loader.removeRequireStatements(tokens)
+    assert.strictEqual(deleted.length, 3)
+    assert.strictEqual(listRequireStatements(tokens).length, 0)
+    assert.strictEqual(called, 1, 'シンタックスハイライトのためにaddPluginFileが呼ばれること')
+  })
+
+  it('読み込まれていないファイルを取り込むとエラーになる', () => {
+    const { nako, loader } = createLoader()
+    const tokens = nako.rawtokenize('!「notfound.nako3」を取り込む\n', 0, 'main.nako3')
+    assert.throws(() => loader.replaceRequireStatements(tokens), /読み込まれていません/)
+  })
+
+  it('未対応の拡張子ではNakoImportErrorになる', () => {
+    const { loader } = createLoader()
+    const tools = {
+      resolvePath: (name) => ({ filePath: name, type: 'txt' }),
+      readNako3: () => ({ task: Promise.resolve('') }),
+      readJs: () => ({ task: Promise.resolve(() => ({})) })
+    }
+    assert.throws(
+      () => loader.load('!「foo.txt」を取り込む\n', 'main.nako3', '', tools),
+      (err) => {
+        assert.ok(err instanceof NakoImportError)
+        assert.ok(/読み込めません/.test(err.msg))
+        return true
+      }
+    )
+  })
+
+  it('なでしこファイルを読み込んでdependenciesに保存する', async () => {
+    const { loader } = createLoader()
+    const tools = {
+      resolvePath: (name) => ({ filePath: name, type: 'nako3' }),
+      readNako3: () => ({ task: Promise.resolve('●(Aを)ライブラリ関数とは\nAを戻す\nここまで\n') }),
+      readJs: () => ({ task: Promise.resolve(() => ({})) })
+    }
+    await loader.load('!「lib.nako3」を取り込む\n', 'main.nako3', '', tools)
+    const dep = loader.dependencies['lib.nako3']
+    assert.ok(dep !== undefined, 'dependenciesに登録されること')
+    assert.ok(dep.tokens.length > 0, 'トークン列が保存されること')
+    const names = [...dep.funclist.keys()].filter((k) => String(k).includes('ライブラリ関数'))
+    assert.ok(names.length > 0, '関数名の一覧が事前に取り出されること')
+  })
+
+  it('JSプラグインを読み込んでaddPluginFromFileを呼ぶ', async () => {
+    const { loader, addedPlugins } = createLoader()
+    const pluginObject = {
+      meta: { type: 'const', value: { pluginName: 'RequireTestPlugin', nakoVersion: '3.6.0' } },
+      取込テスト値: { type: 'const', value: 123 }
+    }
+    const tools = {
+      resolvePath: (name) => ({ filePath: name, type: 'mjs' }),
+      readNako3: () => ({ task: Promise.resolve('') }),
+      readJs: () => ({ task: Promise.resolve(() => pluginObject) })
+    }
+    await loader.load('!「plugin.mjs」を取り込む\n', 'main.nako3', '', tools)
+    assert.strictEqual(addedPlugins.length, 1)
+    assert.strictEqual(addedPlugins[0].fpath, 'plugin.mjs')
+    assert.strictEqual(loader.dependencies['plugin.mjs'].funclist, pluginObject)
+  })
+
+  it('同じファイルを2回取り込んでもエイリアスにまとめられる', async () => {
+    const { loader } = createLoader()
+    const tools = {
+      resolvePath: (name) => ({ filePath: 'lib.nako3', type: 'nako3' }),
+      readNako3: () => ({ task: Promise.resolve('「LIB」を表示\n') }),
+      readJs: () => ({ task: Promise.resolve(() => ({})) })
+    }
+    await loader.load('!「lib.nako3」を取り込む\n!「./lib.nako3」を取り込む\n', 'main.nako3', '', tools)
+    assert.strictEqual(Object.keys(loader.dependencies).length, 1)
+    assert.deepStrictEqual([...loader.dependencies['lib.nako3'].alias].sort(), ['./lib.nako3', 'lib.nako3'])
+  })
+})

package/core/test/nako_runner_test.mjs

@@ -0,0 +1,114 @@
+/* eslint-disable no-undef */
+import { describe, it } from 'node:test'
+import assert from 'assert'
+
+import { NakoCompiler, newCompilerOptions } from '../src/nako3.mjs'
+import { newCompilerOptions as newCompilerOptionsFromRunner } from '../src/nako_runner.mjs'
+
+/**
+ * 実行部を NakoCompiler から分離したモジュールのテスト (#2360)
+ */
+describe('nako_runner_test', () => {
+  it('newCompilerOptionsは既定値を埋める', () => {
+    const opt = newCompilerOptions()
+    assert.strictEqual(opt.testOnly, false)
+    assert.strictEqual(opt.resetEnv, false)
+    assert.strictEqual(opt.resetAll, false)
+    assert.strictEqual(opt.preCode, '')
+    assert.strictEqual(opt.nakoGlobal, null)
+  })
+
+  it('newCompilerOptionsは指定した値を残す', () => {
+    const opt = newCompilerOptions({ testOnly: true, preCode: 'A=1;' })
+    assert.strictEqual(opt.testOnly, true)
+    assert.strictEqual(opt.preCode, 'A=1;')
+    assert.strictEqual(opt.resetEnv, false)
+  })
+
+  it('nako3.mjsとnako_runner.mjsのnewCompilerOptionsは同じ関数', () => {
+    assert.strictEqual(newCompilerOptions, newCompilerOptionsFromRunner)
+  })
+
+  it('runAsyncが実行環境を返し__globalObjに記録される', async () => {
+    const nako = new NakoCompiler()
+    const g = await nako.runAsync('「テスト」を表示', 'main.nako3')
+    assert.strictEqual(g.log, 'テスト')
+    assert.strictEqual(nako.__globalObj, g, '現在の実行環境が記録されること')
+    assert.strictEqual(nako.__globals.length, 1)
+    assert.strictEqual(nako.__globals[0], g)
+  })
+
+  it('__globalObjは代入もできる(後方互換)', () => {
+    const nako = new NakoCompiler()
+    assert.strictEqual(nako.__globalObj, null)
+    const dummy = { dummy: true }
+    nako.__globalObj = dummy
+    assert.strictEqual(nako.__globalObj, dummy)
+  })
+
+  it('__globalsは代入もできる(後方互換)', () => {
+    const nako = new NakoCompiler()
+    nako.__globals = []
+    assert.deepStrictEqual(nako.__globals, [])
+  })
+
+  it('連続して実行すると同じ実行環境を再利用する', async () => {
+    const nako = new NakoCompiler()
+    const g1 = await nako.runAsync('A=10', 'main.nako3')
+    const g2 = await nako.runAsync('Aを表示', 'main.nako3')
+    assert.strictEqual(g1, g2, '実行環境が共有されること')
+    assert.strictEqual(g2.log, '10')
+    assert.strictEqual(nako.__globals.length, 1)
+  })
+
+  it('clearPluginsで実行環境の一覧が空になる', async () => {
+    const nako = new NakoCompiler()
+    await nako.runAsync('「テスト」を表示', 'main.nako3')
+    assert.strictEqual(nako.__globals.length, 1)
+    nako.clearPlugins()
+    assert.strictEqual(nako.__globals.length, 0)
+  })
+
+  it('resetAllを指定すると新しい実行環境が作られる', async () => {
+    const nako = new NakoCompiler()
+    const g1 = await nako.runAsync('A=10', 'main.nako3')
+    const g2 = await nako.runAsync('「テスト」を表示', 'main.nako3', newCompilerOptions({ resetAll: true, resetEnv: true }))
+    assert.notStrictEqual(g1, g2, '実行環境が作り直されること')
+  })
+
+  it('nakoGlobalを指定すると、その実行環境を使う', async () => {
+    const nako = new NakoCompiler()
+    const g1 = await nako.runAsync('A=10', 'main.nako3')
+    const g2 = await nako.runAsync('Aを表示', 'main.nako3', newCompilerOptions({ nakoGlobal: g1 }))
+    assert.strictEqual(g1, g2)
+    assert.strictEqual(g2.log, '10')
+  })
+
+  it('runSyncも同じように動作する', () => {
+    const nako = new NakoCompiler()
+    const g = nako.runSync('「同期」を表示', 'main.nako3')
+    assert.strictEqual(g.log, '同期')
+  })
+
+  it('testメソッドはpreCodeを反映する', () => {
+    const nako = new NakoCompiler()
+    // preCode は code の先頭に含めて渡す仕様
+    const g = nako.test('A=5;Aを表示', 'main.nako3', 'A=5;')
+    assert.strictEqual(g.log, '5')
+  })
+
+  it('runReset は他の実行インスタンスもリセットする', async () => {
+    const nako = new NakoCompiler()
+    await nako.runAsync('A=10', 'main.nako3')
+    const g = await nako.runReset('「リセット」を表示', 'main.nako3')
+    assert.strictEqual(g.log, 'リセット')
+    assert.strictEqual(nako.__globals.length, 1, '古い実行環境が破棄されること')
+  })
+
+  it('実行時エラーはログに記録された上で例外になる', async () => {
+    const nako = new NakoCompiler()
+    await assert.rejects(async () => {
+      await nako.runAsync('『存在しない関数』のエラー発生', 'main.nako3')
+    })
+  })
+})