@hmos-library-adapter/fast 0.0.17-beta.0 → 0.0.17-beta.1

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/scanner/test/runtime-identity.test.mjs

@@ -0,0 +1,53 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import os from 'node:os';
+import { mkdtemp, mkdir, cp, readFile, realpath, rm } from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { runtimeIdentity } from '../core/runtime-identity.mjs';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../..');
+
+test('a complete skill copy runs CLI and validation from another cwd with local resources and a stable fingerprint', async t => {
+  const workspace = await mkdtemp(path.join(os.tmpdir(), '复制 skill 中文 space-'));
+  t.after(() => rm(workspace, { recursive: true, force: true }));
+  const target = path.join(workspace, 'harmonyos-api-upgrade-adapter');
+  const cwd = path.join(workspace, 'business');
+  await mkdir(cwd);
+  const excluded = new Set(['.git', 'node_modules', '.cache', '.superpowers', '.api-change-output', 'evals']);
+  await cp(root, target, { recursive: true, filter: file => !excluded.has(path.basename(file)) });
+  const { runtimeIdentity: identify } = await import(pathToFileURL(path.join(target, 'scripts', 'scanner', 'core', 'runtime-identity.mjs')));
+  const identity = await identify(target, { mode: 'deprecated' });
+  assert.equal(identity.skillRoot, target);
+  assert.equal(identity.implementationFingerprint, (await runtimeIdentity(root, { mode: 'deprecated' })).implementationFingerprint);
+  await assert.rejects(identify(target, { mode: 'full' }), { code: 'SCAN_MODE_INVALID' });
+  const run = args => {
+    const env = { ...process.env };
+    delete env.NODE_TEST_CONTEXT;
+    const result = spawnSync(process.execPath, args, { cwd, env, encoding: 'utf8', timeout: 30_000 });
+    assert.ifError(result.error);
+    return result;
+  };
+  const entry = path.join(target, 'scripts', 'scanner', 'bin', 'harmony-api-scan.mjs');
+  const help = run([entry, 'help']);
+  assert.equal(help.status, 0, help.stderr);
+  assert.equal(JSON.parse(help.stdout).ok, true);
+  const scan = run([entry, 'scan', '--mode', 'upgrade', '--project', cwd, '--sdk', path.join(workspace, 'missing-sdk'),
+    '--from', '13', '--to', '26', '--output-dir', path.join(workspace, 'output')]);
+  assert.equal(scan.status, 1);
+  const error = JSON.parse(scan.stderr).error;
+  assert.equal(error.stage, 'DISCOVER_TOOLCHAIN');
+  const diagnostics = JSON.parse(await readFile(error.artifactPaths[0], 'utf8'));
+  assert.equal(await realpath(diagnostics.runtime.skillRoot), await realpath(target));
+  assert.equal(await realpath(diagnostics.options.referenceRoot), await realpath(path.join(target, 'references', 'changelogs')));
+  const validation = run([path.join(target, 'scripts', 'maintenance', 'validation', 'validate-skill.mjs')]);
+  assert.equal(validation.status, 0, validation.stderr);
+  assert.equal(JSON.parse(validation.stdout).valid, true);
+  assert.equal(JSON.parse(validation.stdout).evaluations.status, 'SKIPPED');
+  const adapterTests = run([path.join(target, 'scripts', 'test-suite.mjs'), 'adapter']);
+  assert.equal(adapterTests.status, 0, adapterTests.stderr || adapterTests.stdout);
+  const backendTests = run(['--test', '--test-name-pattern=runs the index backend|batch output keeps an empty scan table',
+    path.join(target, 'scripts', 'scanner', 'test', 'scan-runner.test.mjs')]);
+  assert.equal(backendTests.status, 0, backendTests.stderr || backendTests.stdout);
+});

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/scanner/test/scan-mode.test.mjs

@@ -0,0 +1,38 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readdir, readFile, writeFile, rm } from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { execute, selectScanRules } from '../core/cli.mjs';
+import { compileRules, loadDevEcoRules } from '../core/rules.mjs';
+import { runDevEcoScan } from '../core/scan-runner.mjs';
+
+for (const command of ['scan', 'inspect-rules']) test(`${command} rejects missing and retired modes before any input lookup or output`, async t => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'scan-mode-中文 空格-'));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  for (const mode of [undefined, 'full', 'deprecated-only', 'unknown', '', true]) {
+    const modeArgs = mode === undefined ? [] : mode === true ? ['--mode'] : ['--mode', mode];
+    await assert.rejects(execute([command, ...modeArgs, '--project', path.join(root, 'missing-project'),
+      '--sdk', path.join(root, 'missing-sdk'), '--output-dir', path.join(root, 'output')]), { code: 'SCAN_MODE_INVALID' });
+    assert.deepEqual(await readdir(root), []);
+  }
+});
+
+test('internal scan entrypoints require an explicit supported mode', async () => {
+  for (const mode of [undefined, 'full', 'deprecated-only', 'unknown']) {
+    const options = { mode };
+    await assert.rejects(compileRules(options), { code: 'SCAN_MODE_INVALID' });
+    await assert.rejects(loadDevEcoRules(null, null, null, mode), { code: 'SCAN_MODE_INVALID' });
+    await assert.rejects(runDevEcoScan(options), { code: 'SCAN_MODE_INVALID' });
+    assert.throws(() => selectScanRules([], mode), { code: 'SCAN_MODE_INVALID' });
+  }
+});
+
+test('scan execution requires a batch identity and never falls back to root report files', async t => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'scan-batch-required-'));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  for (const mode of ['upgrade', 'deprecated']) for (const batchId of [undefined, 'invalid']) {
+    await assert.rejects(runDevEcoScan({ mode, batchId, outputDirectory: root }), { code: 'SCAN_BATCH_INVALID' });
+    assert.deepEqual(await readdir(root), []);
+  }
+});

package/node_modules/@hmos-library-adapter/executer/shared/skills/harmonyos-api-upgrade-adapter/scripts/scanner/test/scan-runner.test.mjs

@@ -0,0 +1,481 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, readFile, readdir, writeFile, rm, symlink } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { DEPRECATED_HEADERS, parseCsv, SCANNER_HEADERS, UPGRADE_HEADERS } from '../../shared/format/csv.mjs';
+import { sha256 } from '../../shared/io/fs-utils.mjs';
+import { createScanBatch } from '../../shared/platform/artifact-layout.mjs';
+import { runScanInBatch } from './helpers/scan-batch.mjs';
+import {
+  compareFindings,
+  interpretDevEcoOutput,
+  normalizeCodeLocation,
+  normalizeFinding,
+  rulesForProject,
+  runDevEcoScan,
+} from '../core/scan-runner.mjs';
+
+test('independent deprecated references retain multiple columns and do not inherit compatibility filters', async (t) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'sdk-report-'));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const file = path.join(root, 'entry/A.ets');
+  await mkdir(path.dirname(file));
+  await writeFile(file, 'old(); old();');
+  const project = { root, modules: [{ name: 'entry', root: path.dirname(file), relativeRoot: 'entry' }], sourceFiles: [file], sourceSnapshot: 'snapshot', scanDirs: [{ absolute: root }] };
+  const findings = [1, 8].map(Column => ({
+    'Api Definition': 'old(): void', Language: 'ArkTS', 'Changed in SDK': '', 'Deprecated Since': 9,
+    'Code Location': 'entry/A.ets:1', Column, 'Rule ID': 'sdk-old', 'Change Type': 'Deprecated API',
+    'Change Operation': 'API_DEPRECATED', 'API Symbol ID': 'api-old',
+    occurrenceId: `old-${Column}`, includedInCsv: true, disposition: 'REQUIRES_REVIEW', filterReason: null,
+  }));
+  const directory=path.join(root,'20261023123456');await mkdir(directory);
+  const layout=await createScanBatch(root,directory,{mode:'deprecated'});
+  const options={project,toolchain:{},rules:[],range:{},outputDirectory:directory,
+    mode:'deprecated',batchId:layout.batchId,deprecations:{findings,unresolved:[],coverage:{status:'COMPLETE'}}};
+  const deprecated=await runDevEcoScan(options);
+  assert.equal(deprecated.findings.length,2);
+  assert.ok((await readFile(deprecated.validationCsv,'utf8')).includes('Title'));
+  const scan=JSON.parse(await readFile(deprecated.scanJson,'utf8'));
+  assert.equal(scan.schemaVersion,4);assert.deepEqual(scan.findings.map(item=>item.Column),[1,8]);
+  assert.equal(scan.mode,'deprecated');
+  assert.equal(deprecated.outputCsv,layout.rawCsv);assert.equal(deprecated.scanJson,layout.scanJson);
+  assert.equal(deprecated.validationCsv,layout.validationCsv);
+  const csv = parseCsv(await readFile(deprecated.outputCsv,'utf8'));
+  assert.deepEqual(csv.headers,DEPRECATED_HEADERS);
+  assert.equal(csv.rows.length,2);
+  assert.deepEqual(csv.rows[0],csv.rows[1]);
+  for (const finding of scan.findings) {
+    assert.equal(finding['API Symbol ID'],'api-old');
+    assert.equal(finding['Deprecated Since'],9);
+    assert.equal(finding.findingId,`finding-${sha256(SCANNER_HEADERS.map(header=>finding[header]).join('\u0000')).slice(0,20)}`);
+  }
+  assert.equal(JSON.parse(await readFile(layout.scanJson,'utf8')).batchId,layout.batchId);
+  assert.deepEqual((await readdir(directory)).sort(),['.internal','deprecated']);
+  await writeFile(deprecated.outputCsv, 'previous report');
+  await assert.rejects(runDevEcoScan({...options, verifyInputs:async()=>{throw new Error('input changed');}}), /input changed/);
+  assert.equal(await readFile(deprecated.outputCsv,'utf8'),'previous report');
+});
+
+test('an unresponsive C++ backend is bounded and still publishes the ArkTS report', async (t) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'cpp-watchdog-'));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const moduleRoot = path.join(root, 'entry');
+  await mkdir(moduleRoot);
+  const cpp = path.join(moduleRoot, 'main.cpp');
+  await writeFile(cpp, 'int main() {}');
+  const fake = path.join(root, 'hang.mjs');
+  await writeFile(fake, 'setInterval(() => {}, 1000);');
+  const result = await runScanInBatch('upgrade', {
+    toolchain: { apiChangeScan: fake, analyzerRoot: root, sdkRoot: '/sdk', java: process.execPath,
+      cApiScanJar: '/fake/c-apiscan.jar' },
+    project: { root, sourceFiles: [cpp], modules: [{ name: 'entry', root: moduleRoot, relativeRoot: 'entry' }], scanDirs: [{ absolute: root }], sourceSnapshot: 'snapshot' },
+    rules: [{ ruleId: 'cpp', rawEntry: { affectedApis: [{ implementLanguage: 'c', methodDefinition: 'void OH_Run()' }], interfaceChanges: {} } }],
+    range: { start: { platformVersion: '5.0.0', apiLevel: 12, channel: 'release' }, end: { platformVersion: '26.0.0', apiLevel: 26, channel: 'release' } },
+    outputDirectory: root, cppPassTimeoutMs: 50,
+  });
+  assert.equal(result.diagnostics.cppStatus, 'TIMED_OUT');
+  assert.ok(result.diagnostics.warnings.some(warning => warning.includes('C++扫描超时')));
+  assert.equal(result.findings.length, 0);
+  assert.ok(await readFile(result.outputCsv, 'utf8'));
+});
+
+test('native modules use independent semantic passes so one module cannot consume another module budget', async t => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'cpp-modules-中文 '));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const modules = ['first', 'second'].map(name => ({ name, root: path.join(root, name), relativeRoot: name }));
+  for (const module of modules) { await mkdir(module.root); await writeFile(path.join(module.root, 'main.cpp'), 'void run() {}'); }
+  const calls = path.join(root, 'calls.jsonl'), fake = path.join(root, 'backend.mjs');
+  await writeFile(fake, `import {mkdir,writeFile,appendFile} from 'node:fs/promises';
+    import path from 'node:path';
+    const value = name => process.argv[process.argv.indexOf(name)+1];
+    const modules = value('--modulePaths').split(',');
+    await appendFile(${JSON.stringify(calls)}, JSON.stringify(modules)+'\\n');
+    if (modules.length !== 1) process.exit(3);
+    const out=value('--outputPath');await mkdir(out,{recursive:true});
+    await writeFile(path.join(out,'result.csv'),'Api Definition,Language,ChangeId,Code Location\\n');`);
+  const result = await runScanInBatch('upgrade', { project: {root,modules,sourceFiles:modules.map(m=>path.join(m.root,'main.cpp')),
+    scanDirs:[{absolute:root}],sourceSnapshot:'snapshot'},
+    toolchain:{apiChangeScan:fake,analyzerRoot:root,sdkRoot:root,cApiScanJar:fake,java:process.execPath},
+    rules:[{provider:'DEVECO',ruleId:'native',rawEntry:{affectedApis:[{implementLanguage:'c',methodDefinition:'void run()'}],interfaceChanges:{}}}],
+    range:{start:{platformVersion:'6.0.0',apiLevel:20,channel:'release'},end:{platformVersion:'26.0.0',apiLevel:26,channel:'release'}},outputDirectory:root });
+  assert.deepEqual((await readFile(calls,'utf8')).trim().split('\n').map(line=>JSON.parse(line)),modules.map(m=>[m.root]));
+  assert.deepEqual(result.diagnostics.nativePasses.map(p=>p.modules),[['first'],['second']]);
+});
+
+test('normalizes DevEco rows into the scanner CSV contract', () => {
+  const finding = normalizeFinding({
+    'Api Definition': 'run(): void', Language: 'ArkTS', 'Changed in SDK': '6.0.0(20) Beta1',
+    'Affected Versions': 'ALL', Title: 'title', 'Code Location': 'entry\\A.ets:2',
+  }, {
+    ruleId: 'r1', changedInSdk: '6.0.0(20) Beta1', affectedVersions: 'N/A (compile-time)',
+    changeType: 'Deprecated API', changeOperation: 'API_DEPRECATED', sourceReference: 'a.md:2',
+    title: 'API废弃', url: 'https://example.test/deprecated',
+    replacementApi: 'ohos.arkui.UIContext.UIContext#getHostContext',
+    replacementSource: '/sdk/component/common.d.ts:10',
+  }, null, 'deprecated');
+  assert.equal(finding.Fixed, 'Unfixed');
+  assert.equal(finding['Code Location'], 'entry/A.ets:2');
+  assert.equal(finding['Rule ID'], 'r1');
+  assert.equal(finding['Replacement API'], 'ohos.arkui.UIContext.UIContext#getHostContext');
+  assert.equal(finding['Replacement Source'], '/sdk/component/common.d.ts:10');
+  assert.equal(finding.includedInCsv, true);
+  assert.equal(finding.disposition, 'REQUIRES_REVIEW');
+  assert.equal(finding.filterReason, null);
+});
+
+test('marks compatible findings for exclusion from the primary CSV', () => {
+  const finding = normalizeFinding({
+    'Api Definition': 'run(): void', Language: 'ArkTS', 'Code Location': 'entry/A.ets:2',
+  }, {
+    ruleId: 'compatible', changedInSdk: '6.0.0(20) Beta1', affectedVersions: 'N/A (compile-time)',
+    changeType: 'Deprecated API', changeOperation: 'API_DEPRECATED', sourceReference: 'a.md:2',
+    title: '兼容变更', url: '', reportDisposition: 'FILTERED_COMPATIBLE', filterReason: 'DOCUMENTED_NO_ADAPTATION',
+  }, null, 'deprecated');
+  assert.equal(finding.includedInCsv, false);
+  assert.equal(finding.disposition, 'FILTERED_COMPATIBLE');
+  assert.equal(finding.filterReason, 'DOCUMENTED_NO_ADAPTATION');
+});
+
+test('uses a deterministic finding order', () => {
+  const base = { 'Changed in SDK': '6.0.0(20)', 'Rule ID': 'r', Language: 'ArkTS', 'Api Definition': 'a' };
+  const first = { ...base, 'Change Type': 'API Behavior Change', 'Code Location': 'entry/A.ets:2' };
+  const second = { ...base, 'Change Type': 'Deprecated API', 'Code Location': 'entry/A.ets:1' };
+  assert.ok(compareFindings(first, second) < 0);
+});
+
+test('keeps C++ timeout non-blocking but rejects grep fallback', () => {
+  const timeout = interpretDevEcoOutput({
+    code: 0,
+    stdout: 'CSV saved',
+    stderr: 'error[20004] C++ JAR scan timed out, marking as failed\nJava process exited with code 143',
+  });
+  assert.equal(timeout.cppStatus, 'TIMED_OUT');
+  assert.match(timeout.warnings[0], /结果可能不完整/);
+  assert.throws(() => interpretDevEcoOutput({
+    code: 0,
+    stdout: 'Falling back to grep scan',
+    stderr: '',
+  }), /inaccurate fallback/);
+});
+
+test('converts absolute C++ locations inside the project to portable relative paths', () => {
+  assert.equal(
+    normalizeCodeLocation({ root: '/work/app', modules: [] }, '/work/app/entry/src/main/cpp/main.cpp:42'),
+    'entry/src/main/cpp/main.cpp:42',
+  );
+  assert.equal(
+    normalizeCodeLocation({
+      root: '/work/app',
+      modules: [{ name: 'native', root: '/work/app/components/native' }],
+    }, '/work/app/components/native/src/main/cpp/main.cpp:7'),
+    'native/src/main/cpp/main.cpp:7',
+  );
+});
+
+test('does not send C rules to DevEco for a pure ArkTS scan scope', () => {
+  const rules = [{ rawEntry: { affectedApis: [
+    { implementLanguage: 'typeScript', interfaceName: 'run' },
+    { implementLanguage: 'c', interfaceName: 'OH_Run' },
+  ] } }];
+  const selected = rulesForProject(rules, { sourceFiles: ['/work/A.ets'] });
+  assert.equal(selected.hasCpp, false);
+  assert.deepEqual(selected.entries[0].affectedApis.map((item) => item.interfaceName), ['run']);
+});
+
+test('groups duplicate affected APIs under one scan id and preserves all owning rules', () => {
+  const api = {
+    implementLanguage: 'typeScript', completePath: '/sdk/a.d.ts', className: 'A',
+    interfaceType: 'method', interfaceName: 'run', methodDefinition: 'run(): void',
+  };
+  const rules = ['behavior', 'deprecated'].map((id, index) => ({
+    ruleId: id,
+    rawEntry: {
+      affectedApis: [{ ...api, methodDefinition: `${api.methodDefinition}${index ? ';' : ''}` }],
+      interfaceChanges: { id },
+    },
+  }));
+  const selected = rulesForProject(rules, { sourceFiles: ['/work/A.ets'] });
+  assert.equal(selected.arkTsEntries.length, 1);
+  const scanId = selected.arkTsEntries[0].interfaceChanges.id;
+  assert.deepEqual(selected.scanRuleMap.get(scanId).rules.map((rule) => rule.ruleId), ['behavior', 'deprecated']);
+});
+
+for (const prefix of ['scanner-timeout-project-', "scanner-timeout-中文 空格'路径-"]) {
+test(`generates a report when the DevEco C++ backend times out${prefix.includes('中文') ? ' with a Chinese, spaced and quoted path' : ''}`, async (t) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), prefix));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const moduleRoot = path.join(root, 'entry');
+  const output = path.join(root, 'output');
+  await mkdir(moduleRoot, { recursive: true });
+  await mkdir(output, { recursive: true });
+  await writeFile(path.join(moduleRoot, 'A.ets'), 'run();\n');
+  await writeFile(path.join(moduleRoot, 'main.cpp'), 'int main() { return 0; }\n');
+  const fake = path.join(root, 'fake-scan.mjs');
+  await writeFile(fake, `
+    import { mkdir, readFile, writeFile } from 'node:fs/promises';
+    import path from 'node:path';
+    const value = (name) => process.argv[process.argv.indexOf(name) + 1];
+    if (value('--startVersion') !== 'start-from-resource' || value('--endVersion') !== 'end-from-resource') process.exit(2);
+    const out = value('--outputPath');
+    const changes = JSON.parse(await readFile(value('--apiModifiedPath'), 'utf8'));
+    const change = changes[0];
+    const api = change.affectedApis[0];
+    const language = api.implementLanguage === 'c' ? 'C' : 'ArkTS';
+    const location = language === 'C' ? ${JSON.stringify(`${path.join(moduleRoot, 'main.cpp')}:1`)} : 'entry/A.ets:1';
+    await mkdir(out, { recursive: true });
+    await writeFile(path.join(out, 'result.csv'), '\\ufeffApi Definition,Language,ChangeId,Changed in SDK,Affected Versions,Title,Code Location,Change Type\\r\\n' + api.methodDefinition + ',' + language + ',' + change.interfaceChanges.id + ',5.0.1(13) Release,ALL,title,' + location + ',接口行为变更\\r\\n');
+    console.error('error[20004] C++ JAR scan timed out, marking as failed');
+  `);
+  const rule = {
+    ruleId: 'r1', changedInSdk: '5.0.1(13) Release', affectedVersions: 'ALL',
+    changeType: 'API Behavior Change', changeOperation: 'API_BEHAVIOR', sourceReference: 'a.md:1',
+    title: '行为变更', url: 'https://example.test/behavior',
+    rawEntry: { affectedApis: [
+      { implementLanguage: 'typeScript', methodDefinition: 'run(): void' },
+      { implementLanguage: 'c', methodDefinition: 'int OH_Run(void)' },
+    ] },
+  };
+  const result = await runScanInBatch('upgrade', {
+    toolchain: {
+      apiChangeScan: fake, analyzerRoot: root, cApiScanJar: path.join(root, 'fake', 'c.jar'), sdkRoot: path.join(root, 'fake', 'sdk'),
+      contentsRoot: root, java: path.join(root, 'jbr', 'bin', 'java'),
+    },
+    project: {
+      root,
+      modules: [{ name: 'entry', root: moduleRoot, relativeRoot: 'entry' }],
+      selectedModules: [{ name: 'entry', root: moduleRoot, relativeRoot: 'entry' }],
+      scanDirs: [{ absolute: root, relative: '.' }],
+      sourceFiles: [path.join(moduleRoot, 'A.ets'), path.join(moduleRoot, 'main.cpp')],
+      sourceSnapshot: 'snapshot',
+    },
+    range: {
+      start: { platformVersion: '5.0.0', apiLevel: 12, channel: 'release', channelNumber: 0 },
+      end: { platformVersion: '5.0.1', apiLevel: 13, channel: 'release', channelNumber: 0 },
+    },
+    rules: [rule],
+    devecoVersionNames: {
+      '5.0.0(12) Release': 'start-from-resource',
+      '5.0.1(13) Release': 'end-from-resource',
+    },
+    outputDirectory: output,
+  });
+  assert.equal(result.findings.length, 2);
+  const locations = findings => findings.map(finding => [finding.Language, finding['Code Location']]).sort();
+  const expected = [['ArkTS', 'entry/A.ets:1'], ['C', 'entry/main.cpp:1']];
+  assert.deepEqual(locations(result.findings), expected);
+  assert.deepEqual(locations(parseCsv(await readFile(result.outputCsv, 'utf8')).rows), expected);
+  assert.deepEqual(locations(JSON.parse(await readFile(result.scanJson, 'utf8')).findings), expected);
+  assert.equal(result.diagnostics.cppStatus, 'TIMED_OUT');
+  assert.match(result.diagnostics.warnings[0], /需人工复核/);
+});
+}
+
+test('upgrade retains every plugin occurrence without compatibility filtering', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'scanner-filter-project-'));
+  const moduleRoot = path.join(root, 'entry');
+  const output = path.join(root, 'output');
+  await mkdir(moduleRoot, { recursive: true });
+  await mkdir(output, { recursive: true });
+  await writeFile(path.join(moduleRoot, 'A.ets'), 'run();\n');
+  const fake = path.join(root, 'fake-scan.mjs');
+  await writeFile(fake, `
+    import { mkdir, readFile, writeFile } from 'node:fs/promises';
+    import path from 'node:path';
+    const value = (name) => process.argv[process.argv.indexOf(name) + 1];
+    const out = value('--outputPath');
+    const changes = JSON.parse(await readFile(value('--apiModifiedPath'), 'utf8'));
+    await mkdir(out, { recursive: true });
+    const rows = changes.map((change) => {
+      const api = change.affectedApis[0];
+      return [api.methodDefinition, 'ArkTS', change.interfaceChanges.id, '6.0.0(20) Beta1', 'ALL', 'title', 'entry/A.ets:1', '接口定义变更'].join(',');
+    });
+    await writeFile(path.join(out, 'result.csv'), '\\ufeffApi Definition,Language,ChangeId,Changed in SDK,Affected Versions,Title,Code Location,Change Type\\r\\n' + rows.join('\\r\\n') + '\\r\\n');
+  `);
+  const api = {
+    implementLanguage: 'typeScript', completePath: '/sdk/a.d.ts', className: 'A',
+    interfaceType: 'method', interfaceName: 'run', methodDefinition: 'run(): void',
+  };
+  const makeRule = (ruleId, reportDisposition, filterReason, applicabilityProof = null) => ({
+    provider: 'DEVECO', ruleId, changedInSdk: '6.0.0(20) Beta1', affectedVersions: 'ALL',
+    changeType: 'API Behavior Change', changeOperation: 'API_BEHAVIOR', sourceReference: `${ruleId}.md:1`,
+    title: ruleId, url: '', reportDisposition, filterReason, applicabilityProof,
+    rawEntry: { affectedApis: [api], interfaceChanges: { id: ruleId } },
+  });
+  const options = {
+    toolchain: {
+      apiChangeScan: fake, analyzerRoot: root, cApiScanJar: '/fake/c.jar', sdkRoot: '/fake/sdk',
+      contentsRoot: root, java: path.join(root, 'jbr', 'bin', 'java'),
+    },
+    project: {
+      root,
+      modules: [{ name: 'entry', root: moduleRoot, relativeRoot: 'entry' }],
+      selectedModules: [{ name: 'entry', root: moduleRoot, relativeRoot: 'entry' }],
+      scanDirs: [{ absolute: root, relative: '.' }],
+      sourceFiles: [path.join(moduleRoot, 'A.ets')],
+      sourceSnapshot: 'snapshot',
+    },
+    range: {
+      start: { platformVersion: '5.0.0', apiLevel: 12, channel: 'release', channelNumber: 0 },
+      end: { platformVersion: '6.0.0', apiLevel: 20, channel: 'beta', channelNumber: 1 },
+    },
+    rules: [
+      makeRule('review', 'REQUIRES_REVIEW', null),
+      makeRule('compatible', 'FILTERED_COMPATIBLE', 'DOCUMENTED_NO_ADAPTATION', {
+        kind: 'DOCUMENTED_NO_ADAPTATION', sourceReference: 'compatible.md:1',
+        sectionField: '适配指导', statement: '默认行为变更，无需适配。',
+      }),
+    ],
+    outputDirectory: output,
+  };
+  const result = await runScanInBatch('upgrade', options);
+  assert.equal(result.validationCsv,null);
+  const csv = parseCsv(await readFile(result.outputCsv,'utf8'));
+  assert.deepEqual(csv.headers,UPGRADE_HEADERS);
+  assert.equal(csv.rows.length,2);
+  const scan=JSON.parse(await readFile(result.scanJson,'utf8'));
+  assert.equal(scan.findings.length,2);assert.equal(scan.filteredFindingCount,0);
+  assert.ok(scan.findings.every(finding=>finding.includedInCsv && finding.disposition==='REQUIRES_REVIEW'));
+  assert.equal(path.basename(path.dirname(result.scanJson)),'scanner');
+});
+
+test('runs the index backend without placing the project file list on the command line', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'index-backend-project-'));
+  const moduleRoot = path.join(root, 'entry');
+  const output = path.join(root, 'output');
+  const source = path.join(moduleRoot, 'A.ets');
+  await mkdir(moduleRoot, { recursive: true });
+  await mkdir(output);
+  await writeFile(source, 'run();\n');
+  const fake = path.join(root, 'renamed-index.mjs');
+  await writeFile(path.join(root, 'worker.js'), `
+    const { parentPort } = require('node:worker_threads');
+    parentPort.postMessage('ready');
+  `);
+  await writeFile(fake, `
+    import { mkdir, readFile, writeFile } from 'node:fs/promises';
+    import { Worker } from 'node:worker_threads';
+    import { fileURLToPath } from 'node:url';
+    import path from 'node:path';
+    const value = (name) => process.argv[process.argv.indexOf(name) + 1];
+    if (process.argv.includes('--scanFilePaths')) throw new Error('source paths must stay out of the command line');
+    const worker = new Worker(path.join(path.dirname(fileURLToPath(import.meta.url)), 'ApiScan.worker.ts'));
+    await new Promise((resolve, reject) => {
+      worker.once('message', resolve);
+      worker.once('error', reject);
+    });
+    const out = value('--outPath');
+    const config = JSON.parse(await readFile(value('--configPath'), 'utf8'));
+    if (!config.projectPath || !Array.isArray(config.sdks) || config.sdks.length !== 2) throw new Error('invalid scanner config');
+    const changes = JSON.parse(await readFile(value('--apiModifiedPath'), 'utf8'));
+    await mkdir(out, { recursive: true });
+    const header = 'Api Name,Api Type,Api File Path,Api Prefix,Api Params,API Args,Invoke Method,Invoke Location,Api Key,Invoke Instance,ChangeId,MethodDefinition\\r\\n';
+    const row = (location) => 'run,method,a.d.ts,A,,,run,' + location + ',key,,"' + changes[0].interfaceChanges.id + '","run(): void"\\r\\n';
+    await writeFile(path.join(out, 'raw.csv'), header + row('entry/A.ets:1:1') + row('entry/Outside.ets:1:1'));
+  `);
+  const api = {
+    implementLanguage: 'typeScript', completePath: '/sdk/a.d.ts', className: 'A',
+    interfaceType: 'method', interfaceName: 'run', methodDefinition: 'run(): void',
+  };
+  const rule = {
+    provider: 'DEVECO', ruleId: 'index-rule', changedInSdk: '6.0.0(20) Beta1', affectedVersions: 'ALL',
+    changeType: 'API Behavior Change', changeOperation: 'API_BEHAVIOR', sourceReference: 'a.md:1',
+    title: 'index backend rule', url: '', rawEntry: { affectedApis: [api], interfaceChanges: { id: 'source-id' } },
+  };
+  const result = await runScanInBatch('upgrade', {
+    toolchain: {
+      apiChangeBackend: 'index', apiChangeScan: fake, analyzerRoot: root, sdkRoot: '/fake/sdk',
+      sdkFamilies: { openharmony: '/fake/sdk/default/openharmony/ets', hms: '/fake/sdk/default/hms/ets' },
+    },
+    project: {
+      root, modules: [{ name: 'entry', root: moduleRoot, relativeRoot: 'entry' }],
+      selectedModules: [{ name: 'entry', root: moduleRoot, relativeRoot: 'entry' }],
+      scanDirs: [{ absolute: root, relative: '.' }],
+      sourceFiles: [source, ...Array.from({ length: 10_000 }, (_, index) => path.join(
+        moduleRoot, 'generated', 'long-source-directory', `File${index}.ets`,
+      ))],
+      sourceSnapshot: 'snapshot',
+    },
+    range: {
+      start: { platformVersion: '5.0.0', apiLevel: 12, channel: 'release', channelNumber: 0 },
+      end: { platformVersion: '6.0.0', apiLevel: 20, channel: 'beta', channelNumber: 1 },
+    },
+    rules: [rule], outputDirectory: output,
+  });
+  assert.equal(result.findings.length, 1);
+  assert.equal(result.findings[0]['Rule ID'], 'index-rule');
+  assert.equal(result.findings[0]['Code Location'], 'entry/A.ets:1');
+  assert.equal(result.diagnostics.backend, 'index');
+});
+
+test('reports an explicit capability error when the index backend is asked to scan C++', async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'index-cpp-backend-'));
+  const moduleRoot = path.join(root, 'entry');
+  const source = path.join(moduleRoot, 'main.cpp');
+  await mkdir(moduleRoot);
+  await writeFile(source, 'int main() { return 0; }\n');
+  await assert.rejects(runScanInBatch('upgrade', {
+    toolchain: { apiChangeBackend: 'index', apiChangeScan: '/fake/index.js', layoutDiagnostics: { scannerCandidates: [] } },
+    project: {
+      root, modules: [{ name: 'entry', root: moduleRoot, relativeRoot: 'entry' }],
+      selectedModules: [{ name: 'entry', root: moduleRoot, relativeRoot: 'entry' }],
+      scanDirs: [{ absolute: root, relative: '.' }], sourceFiles: [source], sourceSnapshot: 'snapshot',
+    },
+    range: {}, outputDirectory: root,
+    rules: [{ provider: 'DEVECO', ruleId: 'cpp', rawEntry: { affectedApis: [
+      { implementLanguage: 'c', methodDefinition: 'int OH_Run(void)' },
+    ], interfaceChanges: {} } }],
+  }), { code: 'C_CPP_BACKEND_UNAVAILABLE' });
+});
+
+test('batch output keeps an empty scan table and its JSON bound to the same ID',async t=>{
+  const root=await mkdtemp(path.join(os.tmpdir(),'batch-scan-'));
+  t.after(()=>rm(root,{recursive:true,force:true}));
+  const batchId='abcdef012345';
+  const result=await runScanInBatch('upgrade', {project:{root,modules:[],sourceFiles:[],sourceSnapshot:'empty',scanDirs:[]},
+    toolchain:{},rules:[],range:{},outputDirectory:root,batchId,mode:'upgrade'});
+  assert.equal(path.basename(result.outputCsv),`scan-results-${batchId}.csv`);
+  assert.equal(result.outputCsv,path.join(root,'upgrade',`scan-results-${batchId}.csv`));
+  assert.equal(result.validationCsv,null);
+  assert.equal(result.scanJson,path.join(root,'.internal','scanner',`scan-results-${batchId}.scan.json`));
+  await assert.rejects(readFile(path.join(root,`scan-results-${batchId}.validation.csv`)),{code:'ENOENT'});
+  assert.equal(JSON.parse(await readFile(result.scanJson,'utf8')).batchId,batchId);
+  assert.ok((await readFile(result.outputCsv,'utf8')).includes('Api Definition'));
+  assert.deepEqual(parseCsv(await readFile(result.outputCsv,'utf8')), {headers:UPGRADE_HEADERS,rows:[]});
+  assert.deepEqual((await readdir(root)).sort(),['.internal','upgrade']);
+});
+
+test('empty deprecated scans still publish the eight-column table and complete JSON', async t => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'empty-deprecated-'));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const result = await runScanInBatch('deprecated', {
+    project: { root, modules: [], sourceFiles: [], sourceSnapshot: 'empty', scanDirs: [] },
+    toolchain: {}, rules: [], range: {}, outputDirectory: root,
+    deprecations: { findings: [], unresolved: [], coverage: { status: 'COMPLETE' } },
+  });
+  assert.deepEqual(parseCsv(await readFile(result.outputCsv, 'utf8')), { headers: DEPRECATED_HEADERS, rows: [] });
+  const scan = JSON.parse(await readFile(result.scanJson, 'utf8'));
+  assert.equal(scan.schemaVersion, 4);
+  assert.deepEqual(scan.findings, []);
+  assert.deepEqual(scan.actionGroups, []);
+});
+
+for (const mode of ['upgrade', 'deprecated']) test(`${mode} rechecks the feature directory before publishing scan bytes`, async t => {
+  const root = await mkdtemp(path.join(os.tmpdir(), 'scanner-delivery-'));
+  const outside = await mkdtemp(path.join(os.tmpdir(), 'scanner-outside-'));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  t.after(() => rm(outside, { recursive: true, force: true }));
+  const directory = path.join(root, '20261027172821');
+  await mkdir(directory);
+  const layout = await createScanBatch(root, directory, { mode });
+  await assert.rejects(runScanInBatch(mode, {
+    project: { root, modules: [], sourceFiles: [], sourceSnapshot: 'empty', scanDirs: [] },
+    toolchain: {}, rules: [], range: {}, outputDirectory: directory, batchId: layout.batchId,
+    verifyInputs: async () => {
+      await rm(layout.deliveryDirectory, { recursive: true });
+      await symlink(outside, layout.deliveryDirectory, process.platform === 'win32' ? 'junction' : 'dir');
+    },
+  }), { code: 'SCAN_BATCH_INVALID' });
+  assert.deepEqual(await readdir(outside), []);
+  await assert.rejects(readFile(layout.scanJson), { code: 'ENOENT' });
+});