chore: remove obsolete test documentation

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 <noreply@anthropic.com>

docs/Test_PP_06_FullIntegration_流程详解.md

@@ -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[处理第一个括号<br/>azxs=A0 OR azxs=AT]
-    ProcessFirstBracket --> ApplyPreprocess1[应用预处理]
-    ApplyPreprocess1 --> ReplaceAzxs[值替换: azxs映射]
-    ReplaceAzxs --> MergeOR1[合并重复OR]
-    MergeOR1 --> CheckParens1{需要括号?}
-    CheckParens1 -->|否| NoParens1[去掉括号<br/>azxs=径向]
-    CheckParens1 -->|是| KeepParens1[保留括号]
-    NoParens1 --> ProcessSecondBracket[处理第二个括号<br/>lcfw=M01 OR lcfw=M15]
-    KeepParens1 --> ProcessSecondBracket
-    ProcessSecondBracket --> ApplyPreprocess2[应用预处理]
-    ApplyPreprocess2 --> ReplaceLcfw[值替换: lcfw映射]
-    ReplaceLcfw --> MergeOR2[合并重复OR检查]
-    MergeOR2 --> CheckParens2{需要括号?}
-    CheckParens2 -->|否| NoParens2[去掉括号]
-    CheckParens2 -->|是| KeepParens2[保留括号<br/>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列<br/>行3到最后]
-    Read --> Process[逐行处理]
-    Process --> Check{有数据?}
-    Check -->|是| Extract[提取key和value<br/>例: D3=A0, E3=径向]
-    Check -->|否| Next[下一行]
-    Extract --> Add[添加到Dictionary<br/>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<br/>gclj=M16 AND]
-    P0 --> P1[字符 13: 遇到左括号]
-    P1 --> B1[bracketLevel = 1<br/>进入括号模式]
-    B1 --> Collect[收集字符 14-28<br/>azxs=A0 OR azxs=AT]
-    Collect --> B2[字符 29: 遇到右括号]
-    B2 --> Recurse[递归处理括号内容]
-    Recurse --> Recurse1[ProcessAndSimplifyNested<br/>无嵌套括号]
-    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[返回单段<br/>azxs=径向]
-    Check -->|否| Both[保留OR]
-    Single --> Need{需要括号?}
-    Both --> Need
-    Need --> HasOp[HasTopLevelOperator]
-    HasOp --> NoOp[无顶层操作符]
-    NoOp --> NoParens[needsParens = False]
-    NoParens --> Append[添加到结果<br/>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[递归处理<br/>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[最终结果<br/>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[合并结果<br/>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集合<br/>包含2个字典元素]
-
-    Result1 --> Cartesian[笛卡尔积计算]
-    Result2 --> Cartesian
-    Cartesian --> Final[最终结果<br/>2行数据]
-```
-
-#### 6.2 笛卡尔积计算
-
-**输入**:
-- 左段: 1行 → `[{gclj: "M16", azxs: "径向"}]`
-- 右段: 2行 → `[{lcfw: "低压"}, {lcfw: "高压"}]`
-
-**笛卡尔积过程**:
-
-```mermaid
-flowchart LR
-    Left[左段: 1行<br/>gclj=M16, azxs=径向] --> Combine
-    Right[右段: 2行<br/>lcfw=低压, lcfw=高压] --> Combine
-    Combine[笛卡尔积 1×2] --> Row1[行1:<br/>gclj=M16<br/>azxs=径向<br/>lcfw=低压]
-    Combine --> Row2[行2:<br/>gclj=M16<br/>azxs=径向<br/>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个元素<br/>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. ✓ **结果正确**: 最终生成正确的行数和数据
-
-该测试确保了预处理模块在实际使用中的正确性和可靠性。