From 026fd47b77616edf7804696de7de389c4cda8637 Mon Sep 17 00:00:00 2001 From: Misaka_Company Date: Tue, 10 Feb 2026 14:00:53 +0800 Subject: [PATCH] chore: remove obsolete test documentation MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Remove Test_PP_06_FullIntegration_流程详解.md as preprocessing workflow is now documented in code comments and CLAUDE.md. Co-Authored-By: Claude Sonnet 4.5 --- docs/Test_PP_06_FullIntegration_流程详解.md | 708 -------------------- 1 file changed, 708 deletions(-) delete mode 100644 docs/Test_PP_06_FullIntegration_流程详解.md diff --git a/docs/Test_PP_06_FullIntegration_流程详解.md b/docs/Test_PP_06_FullIntegration_流程详解.md deleted file mode 100644 index fef038e..0000000 --- a/docs/Test_PP_06_FullIntegration_流程详解.md +++ /dev/null @@ -1,708 +0,0 @@ -# Test_PP_06_FullIntegration 流程详解 - -## 目录 - -1. [测试概述](#测试概述) -2. [测试场景](#测试场景) -3. [完整执行流程](#完整执行流程) -4. [详细步骤分析](#详细步骤分析) -5. [关键数据结构](#关键数据结构) -6. [映射表说明](#映射表说明) - ---- - -## 测试概述 - -**测试名称**: `Test_PP_06_FullIntegration` (完整集成测试) - -**测试目的**: 验证预处理模块与逻辑解析模块的完整集成，确保： -1. 值映射功能正确（azxs 和 lcfw） -2. 嵌套 OR 条件正确简化 -3. 复杂表达式的括号正确处理 -4. 预处理后的结果能被 M03_Logic 正确解析 - -**涉及模块**: -- M05_PreProcessor (预处理模块) -- M03_Logic (逻辑解析模块) -- clsErrorLogger (错误日志) - ---- - -## 测试场景 - -### 输入条件 -``` -gclj=M16 AND (azxs=A0 OR azxs=AT) AND (lcfw=M01 OR lcfw=M15) -``` - -### 预期预处理结果 -``` -gclj=M16 AND azxs=径向 AND (lcfw=低压 OR lcfw=高压) -``` - -### 预期解析结果 -生成 **2 行**数据： -- **行 1**: gclj=M16, azxs=径向, lcfw=低压 -- **行 2**: gclj=M16, azxs=径向, lcfw=高压 - -### 关键验证点 -1. ✓ `azxs=A0 OR azxs=AT` → `azxs=径向` (两个值映射相同，去重) -2. ✓ `(lcfw=M01 OR lcfw=M15)` → `(lcfw=低压 OR lcfw=高压)` (值映射，保留括号) -3. ✓ 最终生成 2 行数据 - ---- - -## 完整执行流程 - -### 流程总览 - -```mermaid -flowchart TD - Start[开始测试] --> Setup[初始化测试环境] - Setup --> LoadMapping[加载映射表] - LoadMapping --> CallPreprocessor[调用 PreprocessCondition] - CallPreprocessor --> CheckCategory{类别 = 接头?} - CheckCategory -->|否| ReturnOriginal[返回原条件] - CheckCategory -->|是| ProcessNested[递归处理嵌套表达式] - ProcessNested --> ProcessFirstBracket[处理第一个括号
azxs=A0 OR azxs=AT] - ProcessFirstBracket --> ApplyPreprocess1[应用预处理] - ApplyPreprocess1 --> ReplaceAzxs[值替换: azxs映射] - ReplaceAzxs --> MergeOR1[合并重复OR] - MergeOR1 --> CheckParens1{需要括号?} - CheckParens1 -->|否| NoParens1[去掉括号
azxs=径向] - CheckParens1 -->|是| KeepParens1[保留括号] - NoParens1 --> ProcessSecondBracket[处理第二个括号
lcfw=M01 OR lcfw=M15] - KeepParens1 --> ProcessSecondBracket - ProcessSecondBracket --> ApplyPreprocess2[应用预处理] - ApplyPreprocess2 --> ReplaceLcfw[值替换: lcfw映射] - ReplaceLcfw --> MergeOR2[合并重复OR检查] - MergeOR2 --> CheckParens2{需要括号?} - CheckParens2 -->|否| NoParens2[去掉括号] - CheckParens2 -->|是| KeepParens2[保留括号
lcfw=低压 OR lcfw=高压] - NoParens2 --> FinalProcess[最终AND分段处理] - KeepParens2 --> FinalProcess - FinalProcess --> ReturnPreprocessed[返回预处理结果] - ReturnPreprocessed --> ParseRule[M03_Logic.ParseRule解析] - ParseRule --> SplitTopLevelOR{顶层OR分割} - SplitTopLevelOR --> SplitOR[分割: 2个OR分段] - SplitOR --> ParseEachOR[解析每个OR分段] - ParseEachOR --> VerifyResults{验证结果} - VerifyResults -->|count=2| Success[测试通过] - VerifyResults -->|count≠2| Failure[测试失败] -``` - -### 函数调用时序图 - -```mermaid -sequenceDiagram - participant Test as Test_PP_06 - participant PP as M05_PreProcessor - participant Logic as M03_Logic - participant Mapping as 映射表 - - Test->>PP: InitPreProcessor(logger, wsMapping) - PP->>Mapping: LoadLcfwMapping() - Mapping-->>PP: lcfw映射表加载 - PP->>Mapping: LoadAzxsMapping() - Mapping-->>PP: azxs映射表加载 - - Test->>PP: PreprocessCondition(inputCond, "接头", 1) - - Note over PP: 步骤1: 类别检查 - alt 类别 != "接头" - PP-->>Test: 返回原条件 - else 类别 == "接头" - PP->>PP: ApplyPreprocessing() - - Note over PP: 步骤2: 递归处理嵌套括号 - PP->>PP: ProcessAndSimplifyNested() - - Note over PP: 处理 (azxs=A0 OR azxs=AT) - PP->>PP: 提取括号内容 - PP->>PP: ApplyPreprocessing(azxs=A0 OR azxs=AT) - PP->>PP: 分割OR: [azxs=A0, azxs=AT] - PP->>PP: ProcessAndSegment(azxs=A0) - PP->>Mapping: 查询 azxs="A0" - Mapping-->>PP: 返回 "径向" - PP->>PP: ProcessAndSegment(azxs=AT) - PP->>Mapping: 查询 azxs="AT" - Mapping-->>PP: 返回 "径向" - PP->>PP: MergeDuplicateORs() - Note over PP: 两段相同 → 返回一段 - PP->>PP: SimplifyIfAllSame() - Note over PP: 检查: 无顶层OR → 去掉括号 - PP-->>PP: azxs=径向 - - Note over PP: 处理 (lcfw=M01 OR lcfw=M15) - PP->>PP: 提取括号内容 - PP->>PP: ApplyPreprocessing(lcfw=M01 OR lcfw=M15) - PP->>PP: 分割OR: [lcfw=M01, lcfw=M15] - PP->>PP: ProcessAndSegment(lcfw=M01) - PP->>Mapping: 查询 lcfw="M01" - Mapping-->>PP: 返回 "低压" - PP->>PP: ProcessAndSegment(lcfw=M15) - PP->>Mapping: 查询 lcfw="M15" - Mapping-->>PP: 返回 "高压" - PP->>PP: MergeDuplicateORs() - Note over PP: 两段不同 → 保留两段 - PP->>PP: SimplifyIfAllSame() - Note over PP: 检查: 有顶层OR → 保留括号 - PP-->>PP: (lcfw=低压 OR lcfw=高压) - - Note over PP: 步骤3: 最终AND处理 - PP->>PP: ProcessAndSegment(完整表达式) - PP-->>Test: gclj=M16 AND azxs=径向 AND (lcfw=低压 OR lcfw=高压) - end - - Test->>Logic: ParseRule(preprocessed, 1) - - Note over Logic: 步骤4: 逻辑解析 - Logic->>Logic: RecursiveParse() - - Note over Logic: 查找顶层OR - Logic->>Logic: FindSplitIndex(OR) - Note over Logic: 找到: (lcfw=低压 OR lcfw=高压) 之前 - - Logic->>Logic: 递归解析左段 - Note over Logic: gclj=M16 AND azxs=径向 - Logic->>Logic: 解析AND → 笛卡尔积 - Logic-->>Logic: Row1: {gclj:M16, azxs:径向} - - Logic->>Logic: 递归解析右段 - Note over Logic: lcfw=低压 OR lcfw=高压 - Logic->>Logic: 解析OR → 并集 - Logic-->>Logic: Row2: {lcfw:低压}, Row3: {lcfw:高压} - - Logic->>Logic: CartesianProduct(Row1, Row2) - Note over Logic: 笛卡尔积: 1 × 2 = 2行 - Logic-->>Logic: RowA: {gclj:M16, azxs:径向, lcfw:低压} - Logic-->>Logic: RowB: {gclj:M16, azxs:径向, lcfw:高压} - - Logic-->>Test: Collection(2行) - - Note over Test: 步骤5: 验证结果 - Test->>Test: col.count == 2 ? - Test->>Test: row("gclj") == "M16" ? - Test->>Test: row("azxs") == "径向" ? - Test->>Test: row("lcfw") == "低压" ? - - Test-->>Test: ✓ 测试通过 -``` - ---- - -## 详细步骤分析 - -### 步骤 1: 初始化测试环境 - -```vba -Private Sub Test_PP_06_FullIntegration() - SetupPreProcessorTest -``` - -**执行动作**: -1. 查找 `[对照表]` 工作表 -2. 创建 `clsErrorLogger` 实例 -3. 初始化 `M03_Logic` 模块 -4. 初始化 `M05_PreProcessor` 模块 - -**数据结构初始化**: -```vba -Set g_LcfwMapping = CreateObject("Scripting.Dictionary") -Set g_AzxsMapping = CreateObject("Scripting.Dictionary") -``` - -### 步骤 2: 加载映射表 - -**LoadAzxsMapping() 执行流程**: - -```mermaid -flowchart LR - Start[开始加载azxs映射] --> Read[读取 D列:E列
行3到最后] - Read --> Process[逐行处理] - Process --> Check{有数据?} - Check -->|是| Extract[提取key和value
例: D3=A0, E3=径向] - Check -->|否| Next[下一行] - Extract --> Add[添加到Dictionary
g_AzxsMapping.Add A0, 径向] - Add --> Next - Next --> More{还有行?} - More -->|是| Process - More -->|否| End[结束] -``` - -**加载的 azxs 映射数据**: -```javascript -g_AzxsMapping = { - "A0": "径向", - "AT": "径向", - "AH": "径向", - "B0": "下轴向", - "BT": "下轴向", - "BZ": "下轴向", - "BH": "下轴向", - "Z0": "中轴向", - "ZT": "中轴向", - "ZZ": "中轴向", - "ZH": "中轴向" -} -``` - -**LoadLcfwMapping() 执行流程**: -```javascript -g_LcfwMapping = { - "M01": "低压", - "M02": "低压", - "M03": "低压", - "M04": "低压", - "M05": "低压", - "M06": "低压", - "M07": "低压", - "M08": "低压", - "M09": "低压", - "M10": "低压", - "M11": "低压", - "M12": "高压", // 假设M12映射到高压 - "M13": "高压", // 假设M13映射到高压 - "M14": "高压", - "M15": "高压", - "M16": "高压" -} -``` - -### 步骤 3: 预处理入口 - -```vba -inputCond = "gclj=M16 AND (azxs=A0 OR azxs=AT) AND (lcfw=M01 OR lcfw=M15)" -preprocessed = M05_PreProcessor.PreprocessCondition(inputCond, "接头", 1) -``` - -**PreprocessCondition() 执行流程**: - -```mermaid -flowchart TD - Start[PreprocessCondition] --> CheckInit{初始化?} - CheckInit -->|否| Return1[返回原条件] - CheckInit -->|是| CheckCat{类别=接头?} - CheckCat -->|否| Return2[返回原条件] - CheckCat -->|是| Apply[ApplyPreprocessing] - Apply --> Return3[返回预处理结果] -``` - -**检查结果**: -- ✓ 已初始化: `g_IsInitialized = True` -- ✓ 类别匹配: `strCategory = "接头"` -- → 继续执行 `ApplyPreprocessing()` - -### 步骤 4: 递归处理嵌套表达式 - -#### 4.1 ProcessAndSimplifyNested() 处理第一个括号 - -**输入字符串**: `gclj=M16 AND (azxs=A0 OR azxs=AT) AND (lcfw=M01 OR lcfw=M15)` - -**逐字符处理流程**: - -```mermaid -flowchart TD - Start[开始处理] --> P0[处理字符 1-12
gclj=M16 AND] - P0 --> P1[字符 13: 遇到左括号] - P1 --> B1[bracketLevel = 1
进入括号模式] - B1 --> Collect[收集字符 14-28
azxs=A0 OR azxs=AT] - Collect --> B2[字符 29: 遇到右括号] - B2 --> Recurse[递归处理括号内容] - Recurse --> Recurse1[ProcessAndSimplifyNested
无嵌套括号] - Recurse1 --> Apply1[ApplyPreprocessing] - Apply1 --> Split1[SplitTopLevel OR] - Split1 --> Seg1[分段: azxs=A0] - Split1 --> Seg2[分段: azxs=AT] - Seg1 --> Proc1[ProcessAndSegment] - Seg2 --> Proc2[ProcessAndSegment] - Proc1 --> Atom1[ProcessAtom: azxs=A0] - Proc2 --> Atom2[ProcessAtom: azxs=AT] - Atom1 --> Map1[查询: A0→径向] - Atom2 --> Map2[查询: AT→径向] - Map1 --> Res1[azxs=径向] - Map2 --> Res2[azxs=径向] - Res1 --> Merge[MergeDuplicateORs] - Res2 --> Merge - Merge --> Simplify[SimplifyIfAllSame] - Simplify --> Check{两段相同?} - Check -->|是| Single[返回单段
azxs=径向] - Check -->|否| Both[保留OR] - Single --> Need{需要括号?} - Both --> Need - Need --> HasOp[HasTopLevelOperator] - HasOp --> NoOp[无顶层操作符] - NoOp --> NoParens[needsParens = False] - NoParens --> Append[添加到结果
azxs=径向] - Append --> Continue[继续处理后续字符] -``` - -**第一个括号处理结果**: -``` -(azxs=A0 OR azxs=AT) → azxs=径向 -``` - -**为什么去掉括号?** -- 处理后内容: `azxs=径向` -- 检查顶层操作符: 无 OR, 无 AND -- 结论: 单个原子，不需要括号 - -#### 4.2 ProcessAndSimplifyNested() 处理第二个括号 - -**输入字符串**: `(lcfw=M01 OR lcfw=M15)` - -**处理流程**: - -```mermaid -flowchart TD - Start[处理 lcfw括号] --> Extract[提取内容] - Extract --> Content[内容: lcfw=M01 OR lcfw=M15] - Content --> Recursive[递归处理
ProcessAndSimplifyNested] - Recursive --> Apply[ApplyPreprocessing] - Apply --> Split[SplitTopLevel OR] - Split --> Segments[分段: 2个元素] - Segments --> Seg1[分段1: lcfw=M01] - Segments --> Seg2[分段2: lcfw=M15] - Seg1 --> Process1[ProcessAndSegment M01] - Seg2 --> Process2[ProcessAndSegment M15] - Process1 --> Map1[查询映射: M01→低压] - Process2 --> Map2[查询映射: M15→高压] - Map1 --> Merge1[MergeDuplicateORs] - Map2 --> Merge1 - Merge1 --> CheckSame{两段相同?} - CheckSame -->|否| KeepBoth[保留两段] - KeepBoth --> Simplify[SimplifyIfAllSame] - Simplify --> CheckParens{需要括号?} - CheckParens --> HasOR[HasTopLevelOperator检查] - HasOR --> HasResult[返回 True: 有顶层OR] - HasResult --> AddParens[添加括号] - AddParens --> Final[最终结果
lcfw=低压 OR lcfw=高压] -``` - -**第二个括号处理结果**: -``` -(lcfw=M01 OR lcfw=M15) → (lcfw=低压 OR lcfw=高压) -``` - -**为什么保留括号?** -- 处理后内容: `lcfw=低压 OR lcfw=高压` -- 检查顶层操作符: 有 OR -- 结论: 有顶层操作符，需要括号以保持正确逻辑结构 - -### 步骤 5: 最终表达式组装 - -**当前状态**: -- 原始: `gclj=M16 AND (azxs=A0 OR azxs=AT) AND (lcfw=M01 OR lcfw=M15)` -- 第一个括号处理后: `gclj=M16 AND azxs=径向 AND (lcfw=M01 OR lcfw=M15)` -- 第二个括号处理后: `gclj=M16 AND azxs=径向 AND (lcfw=低压 OR lcfw=高压)` - -**最终预处理结果**: -``` -gclj=M16 AND azxs=径向 AND (lcfw=低压 OR lcfw=高压) -``` - -### 步骤 6: M03_Logic.ParseRule 解析 - -#### 6.1 递归解析流程 - -```mermaid -flowchart TD - Start[ParseRule] --> Clean[CleanString] - Clean --> Recursive[RecursiveParse] - Recursive --> FindOR[FindSplitIndex OR] - FindOR --> FoundOR{找到OR} - FoundOR -->|是| SplitOR[分割位置] - FoundOR -->|否| FindAND[FindSplitIndex AND] - - SplitOR --> Left[左段解析] - SplitOR --> Right[右段解析] - - Left --> ParseLeft[RecursiveParse左段] - ParseLeft --> FindAND1[FindSplitIndex AND] - FindAND1 --> FoundAND1{找到AND} - FoundAND1 -->|是| SplitAND[分割AND] - SplitAND --> LeftLeft[元素1 gclj=M16] - SplitAND --> LeftRight[元素2 azxs=径向] - LeftLeft --> Atom1[ParseAtom字典1] - LeftRight --> Atom2[ParseAtom字典2] - Atom1 --> Merge1[MergeDictionaries] - Atom2 --> Merge1 - Merge1 --> Result1[合并结果
gclj为M16和azxs为径向] - - Right --> ParseRight[RecursiveParse右段] - ParseRight --> FindOR2[FindSplitIndex OR] - FindOR2 --> FoundOR2{找到OR} - FoundOR2 -->|是| SplitOR2[分割OR] - SplitOR2 --> RightLeft[元素1 lcfw=低压] - SplitOR2 --> RightRight[元素2 lcfw=高压] - RightLeft --> Atom3[ParseAtom字典3] - RightRight --> Atom4[ParseAtom字典4] - Atom3 --> Union1[UnionCollections] - Atom4 --> Union1 - Union1 --> Result2[Collection集合
包含2个字典元素] - - Result1 --> Cartesian[笛卡尔积计算] - Result2 --> Cartesian - Cartesian --> Final[最终结果
2行数据] -``` - -#### 6.2 笛卡尔积计算 - -**输入**: -- 左段: 1行 → `[{gclj: "M16", azxs: "径向"}]` -- 右段: 2行 → `[{lcfw: "低压"}, {lcfw: "高压"}]` - -**笛卡尔积过程**: - -```mermaid -flowchart LR - Left[左段: 1行
gclj=M16, azxs=径向] --> Combine - Right[右段: 2行
lcfw=低压, lcfw=高压] --> Combine - Combine[笛卡尔积 1×2] --> Row1[行1:
gclj=M16
azxs=径向
lcfw=低压] - Combine --> Row2[行2:
gclj=M16
azxs=径向
lcfw=高压] -``` - -**最终结果**: -```javascript -Collection { - [1] Dictionary {gclj: "M16", azxs: "径向", lcfw: "低压"}, - [2] Dictionary {gclj: "M16", azxs: "径向", lcfw: "高压"} -} -``` - -### 步骤 7: 结果验证 - -```vba -Assert_Equal col.count, 2, "PP06_Count_After_Preprocessing" ' ✓ 通过 -Assert_Equal row("gclj"), "M16", "PP06_gclj_Value" ' ✓ 通过 -Assert_Equal row("azxs"), "径向", "PP06_azxs_Mapped_Value" ' ✓ 通过 -Assert_Equal row("lcfw"), "低压", "PP06_lcfw_Mapped_Value" ' ✓ 通过 -``` - ---- - -## 关键数据结构 - -### 1. 映射表 Dictionary - -```vba -' azxs 映射表 -g_AzxsMapping: Scripting.Dictionary - Key: "A0" → Value: "径向" - Key: "AT" → Value: "径向" - Key: "AH" → Value: "径向" - Key: "B0" → Value: "下轴向" - ... - -' lcfw 映射表 -g_LcfwMapping: Scripting.Dictionary - Key: "M01" → Value: "低压" - Key: "M15" → Value: "高压" - ... -``` - -### 2. 原子解析结果 - -```vba -' ParseAtom 返回的 Dictionary -ParseAtom("azxs=A0") → Dictionary { - "key": "azxs", - "value": "A0", - "operator": "=" -} - -' ProcessAtom 处理后 -ProcessAtom("azxs=A0") → "azxs=径向" -``` - -### 3. Collection 数据流 - -```mermaid -graph LR - A[SplitTopLevel OR] --> B[Collection: 2个元素] - B --> C["Element 1: azxs=A0"] - B --> D["Element 2: azxs=AT"] - C --> E[ProcessAndSegment] - D --> F[ProcessAndSegment] - E --> G["azxs=径向"] - F --> H["azxs=径向"] - G --> I[MergeDuplicateORs] - H --> I - I --> J[Collection: 1个元素
azxs=径向] -``` - -### 4. 最终解析结果 - -```vba -' M03_Logic.ParseRule 返回的 Collection -Collection { - [1] Dictionary { - "gclj": "M16", - "azxs": "径向", - "lcfw": "低压" - }, - [2] Dictionary { - "gclj": "M16", - "azxs": "径向", - "lcfw": "高压" - } -} -``` - ---- - -## 映射表说明 - -### azxs (安装形式) 映射规则 - -| 原始值 | 对应值 | 说明 | -|--------|--------|------| -| A0, AT, AH | 径向 | 径向安装 | -| B0, BT, BZ, BH | 下轴向 | 下轴向安装 | -| Z0, ZT, ZZ, ZH | 中轴向 | 中轴向安装 | - -**测试用例**: `azxs=A0 OR azxs=AT` -- A0 → 径向 -- AT → 径向 -- 两个映射结果相同 → OR 去重 → `azxs=径向` - -### lcfw (量程范围) 映射规则 - -| 原始值 | 对应值 | 说明 | -|--------|--------|------| -| M01-M11 | 低压 | 低压量程 | -| M12-M16 | 高压 | 高压量程 | - -**测试用例**: `lcfw=M01 OR lcfw=M15` -- M01 → 低压 -- M15 → 高压 -- 两个映射结果不同 → OR 保留 → `lcfw=低压 OR lcfw=高压` - ---- - -## 关键函数说明 - -### 1. SplitTopLevel() - -**功能**: 顶层分割，尊重括号嵌套 - -**示例**: -``` -输入: "A AND (B OR C) AND D" -分割符: " AND " -输出: ["A", "(B OR C)", "D"] -``` - -**算法**: -- 遍历字符串，跟踪 `bracketLevel` -- 只在 `bracketLevel = 0` 时匹配分隔符 - -### 2. ProcessAtom() - -**功能**: 处理单个原子，应用值映射 - -**流程**: -```mermaid -flowchart TD - Input[输入: azxs=A0] --> Parse[ParseAtom] - Parse --> Dict[Dictionary: key=azxs, value=A0, operator==] - Dict --> CheckKey{检查key} - CheckKey -->|azxs| QueryAz[g_AzxsMapping.Exists] - CheckKey -->|lcfw| QueryLc[g_LcfwMapping.Exists] - CheckKey -->|其他| Keep[保持原值] - QueryAz --> FoundAz{找到?} - FoundAz -->|是| ReplaceAz[替换为映射值] - FoundAz -->|否| Keep - QueryLc --> FoundLc{找到?} - FoundLc -->|是| ReplaceLc[替换为映射值] - FoundLc -->|否| Keep - ReplaceAz --> Rebuild[重建: key+operator+value] - ReplaceLc --> Rebuild - Keep --> Rebuild - Rebuild --> Output[输出: azxs=径向] -``` - -### 3. SimplifyIfAllSame() - -**功能**: 检查所有 OR 分段是否相同，相同则去重 - -**示例**: -``` -输入: "azxs=径向 OR azxs=径向" -分段: ["azxs=径向", "azxs=径向"] -检查: 两段相同 -输出: "azxs=径向" -``` - -### 4. HasTopLevelOperator() - -**功能**: 检查字符串是否有顶层操作符 - -**示例**: -``` -输入: "lcfw=低压 OR lcfw=高压" -检查: " OR " 在 bracketLevel=0 时出现 -输出: True (需要括号) -``` - ---- - -## 测试覆盖的场景 - -| 场景 | 输入 | 预期输出 | 测试点 | -|------|------|----------|--------| -| 值映射 | azxs=A0 | azxs=径向 | ✓ azxs映射正确 | -| OR去重 | azxs=A0 OR azxs=AT | azxs=径向 | ✓ 相同映射值去重 | -| 括号保留 | (lcfw=M01 OR lcfw=M15) | (lcfw=低压 OR lcfw=高压) | ✓ 不同映射值保留括号 | -| 复杂表达式 | gclj=M16 AND (azxs=A0 OR azxs=AT) AND (...) | 完整表达式 | ✓ 多个嵌套括号处理 | -| 解析集成 | 预处理结果 | 2行数据 | ✓ 与M03_Logic集成 | - ---- - -## 常见问题 - -### Q1: 为什么第一个括号去掉了，第二个括号保留了？ - -**A**: -- 第一个括号 `(azxs=A0 OR azxs=AT)` → `azxs=径向` - - 处理后是单个原子，无顶层操作符 → 不需要括号 - -- 第二个括号 `(lcfw=M01 OR lcfw=M15)` → `lcfw=低压 OR lcfw=高压` - - 处理后仍有顶层 OR → 需要括号保持逻辑结构 - -### Q2: 为什么最终生成2行而不是4行？ - -**A**: -``` -原始: (azxs=A0 OR azxs=AT) AND (lcfw=M01 OR lcfw=M15) -理论上: 2 × 2 = 4行 - -预处理后: azxs=径向 AND (lcfw=低压 OR lcfw=高压) -实际: 1 × 2 = 2行 - -原因: 第一个OR的两个值映射相同，去重后变为1个值 -``` - -### Q3: 如果映射值不同会怎样？ - -**A**: -``` -输入: (azxs=A0 OR azxs=B0) -映射: A0→径向, B0→下轴向 -输出: (azxs=径向 OR azxs=下轴向) -结果: 保留括号，生成2行 -``` - ---- - -## 总结 - -Test_PP_06_FullIntegration 测试验证了预处理模块的完整功能： - -1. ✓ **值映射**: azxs 和 lcfw 的值正确映射 -2. ✓ **OR去重**: 相同映射值的OR条件正确合并 -3. ✓ **括号处理**: 根据处理后内容的复杂度智能决定是否保留括号 -4. ✓ **逻辑集成**: 预处理结果能被M03_Logic正确解析 -5. ✓ **结果正确**: 最终生成正确的行数和数据 - -该测试确保了预处理模块在实际使用中的正确性和可靠性。