hina/classifier.py

@@ -21,7 +21,7 @@ L1_RULES: list[tuple[str, list[str], float]] = [
     ("SORT", ["re:SORT(?:\\s+\\S+)?\\s+ON\\s+(?:ASCENDING\\s+|DESCENDING\\s+)?KEY"], 0.95),
     ("MERGE", ["re:MERGE(?:\\s+\\S+)?\\s+ON\\s+(?:ASCENDING\\s+|DESCENDING\\s+)?KEY"], 0.95),
     ("替代索引", ["ALTERNATE RECORD KEY"], 0.99),
-    ("编辑输出", ["WRITE AFTER", "WRITE BEFORE"], 0.80),
+    ("编辑输出", ["re:WRITE\\s+\\S+\\s+AFTER\\s+", "re:WRITE\\s+\\S+\\s+BEFORE\\s+"], 0.80),
     ("文件编成", ["ORGANIZATION IS"], 0.99),
     ("マッチング", ["re:WS-[\\w-]*KEY"], 0.65),
     # 无连字符 KEY 变量: WSKEY, WSKEY1, WSKEYCD 等（老式 COBOL 命名）

hina/pipeline/pipeline.py

@@ -187,7 +187,7 @@ def _path_rule_engine(
             su
         ))
         features["has_csv_split"] = bool(re.search(
-            r"INSPECT[\s\S]*?REPLACING[\s\S]*?,',",  # INSPECT ... REPLACING ... ','
+            r"INSPECT[\s\S]*?REPLACING[\s\S]*?','",  # INSPECT ... REPLACING ... ','
             su
         ))
 

test-data/test_hina_all_types.py

@@ -0,0 +1,511 @@
+"""
+HINA 全35种类型 完全测试
+为每一个 HINA 类型编写真实的 COBOL 程序，通过完整管道检测
+"""
+
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from hina.pipeline import classify_program
+from hina.classifier import detect_keyword
+from cobol_testgen import extract_structure
+
+PASS = 0
+FAIL = 0
+TOTAL = 0
+
+def test(hina_id, name, src, expected_category=None, min_conf=0.0):
+    global PASS, FAIL, TOTAL
+    TOTAL += 1
+
+    try:
+        s = extract_structure(src)
+        c = classify_program(src)
+        kw = detect_keyword(src)
+    except Exception as e:
+        print(f'❌ {hina_id:5s} {name:25s} CRASH: {str(e)[:60]}')
+        FAIL += 1
+        return
+
+    cat = c['category']
+    conf = c['confidence']
+    method = c['method']
+
+    # Check against expected_category if given
+    if expected_category and cat != expected_category:
+        print(f'⚠️ {hina_id:5s} {name:25s} cat={cat:<20s} exp={expected_category:<20s} conf={conf:.2f} {method}')
+        FAIL += 1
+    elif expected_category and conf < min_conf:
+        print(f'⚠️ {hina_id:5s} {name:25s} cat={cat:<20s} conf={conf:.2f} < {min_conf:.2f} {method}')
+        FAIL += 1
+    else:
+        print(f'✅ {hina_id:5s} {name:25s} cat={cat:<20s} conf={conf:.2f} {method}')
+        PASS += 1
+
+
+PREAMBLE = '       IDENTIFICATION DIVISION. PROGRAM-ID. T. DATA DIVISION. WORKING-STORAGE SECTION.\n'
+
+print('=' * 80)
+print('HINA 全35类型 完全テスト')
+print('=' * 80)
+print()
+
+# ════════════════════════════════════════════════
+# 1. マッチング系（9 types）
+# ════════════════════════════════════════════════
+print('--- マッチング系 ---')
+
+# H001: 1:1 MATCHING
+test('H001', '1:1 matching', PREAMBLE + '''
+       01 WS-KEY-A PIC X(10). 01 WS-KEY-B PIC X(10).
+       01 WS-EOF-A PIC X VALUE 'N'. 01 WS-EOF-B PIC X VALUE 'N'.
+       PROCEDURE DIVISION.
+           OPEN INPUT FILE-A FILE-B.
+           READ FILE-A AT END MOVE 'Y' TO WS-EOF-A.
+           READ FILE-B AT END MOVE 'Y' TO WS-EOF-B.
+           PERFORM UNTIL WS-EOF-A = 'Y' OR WS-EOF-B = 'Y'
+               IF WS-KEY-A = WS-KEY-B DISPLAY 'M'
+               ELSE IF WS-KEY-A < WS-KEY-B READ FILE-A AT END MOVE 'Y' TO WS-EOF-A
+               ELSE READ FILE-B AT END MOVE 'Y' TO WS-EOF-B
+               END-IF
+           END-PERFORM. CLOSE FILE-A FILE-B. STOP RUN.''')
+
+# H002: 1:N MATCHING
+test('H002', '1:N matching', PREAMBLE + '''
+       01 WS-MAST-KEY PIC X(10). 01 WS-TRAN-KEY PIC X(10).
+       01 WS-MAST-EOF PIC X VALUE 'N'. 01 WS-TRAN-EOF PIC X VALUE 'N'.
+       PROCEDURE DIVISION.
+           OPEN INPUT MASTER-FILE TRANS-FILE.
+           READ MASTER-FILE AT END MOVE 'Y' TO WS-MAST-EOF.
+           READ TRANS-FILE AT END MOVE 'Y' TO WS-TRAN-EOF.
+           PERFORM UNTIL WS-MAST-EOF = 'Y' OR WS-TRAN-EOF = 'Y'
+               IF WS-MAST-KEY = WS-TRAN-KEY
+                   DISPLAY 'MATCH'
+                   READ TRANS-FILE AT END MOVE 'Y' TO WS-TRAN-EOF
+               ELSE IF WS-MAST-KEY < WS-TRAN-KEY
+                   READ MASTER-FILE AT END MOVE 'Y' TO WS-MAST-EOF
+               ELSE READ TRANS-FILE AT END MOVE 'Y' TO WS-TRAN-EOF
+               END-IF
+           END-PERFORM. CLOSE MASTER-FILE TRANS-FILE. STOP RUN.''')
+
+# H003: N:1 MATCHING
+test('H003', 'N:1 matching', PREAMBLE + '''
+       01 WS-KEY-M PIC X(10). 01 WS-KEY-T PIC X(10).
+       01 WS-EOF-M PIC X VALUE 'N'. 01 WS-EOF-T PIC X VALUE 'N'.
+       PROCEDURE DIVISION.
+           OPEN INPUT FILE-M FILE-T.
+           READ FILE-M AT END MOVE 'Y' TO WS-EOF-M.
+           READ FILE-T AT END MOVE 'Y' TO WS-EOF-T.
+           PERFORM UNTIL WS-EOF-M = 'Y' OR WS-EOF-T = 'Y'
+               IF WS-KEY-M = WS-KEY-T DISPLAY 'MATCH'
+               ELSE IF WS-KEY-M < WS-KEY-T READ FILE-M AT END MOVE 'Y' TO WS-EOF-M
+               ELSE READ FILE-T AT END MOVE 'Y' TO WS-EOF-T
+               END-IF
+           END-PERFORM. CLOSE FILE-M FILE-T. STOP RUN.''')
+
+# H016: TWO-STAGE MATCHING 1:1
+test('H016', 'two-stage 1:1', PREAMBLE + '''
+       01 WS-KEY-A PIC X(10). 01 WS-KEY-B PIC X(10).
+       01 WS-EOF-A PIC X VALUE 'N'. 01 WS-EOF-B PIC X VALUE 'N'.
+       PROCEDURE DIVISION.
+           OPEN INPUT FILE-A FILE-B OUTPUT INT-FILE.
+           READ FILE-A AT END MOVE 'Y' TO WS-EOF-A.
+           READ FILE-B AT END MOVE 'Y' TO WS-EOF-B.
+           PERFORM UNTIL WS-EOF-A = 'Y' OR WS-EOF-B = 'Y'
+               IF WS-KEY-A = WS-KEY-B
+                   WRITE INT-REC FROM REC-A
+                   READ FILE-A AT END MOVE 'Y' TO WS-EOF-A
+                   READ FILE-B AT END MOVE 'Y' TO WS-EOF-B
+               ELSE IF WS-KEY-A < WS-KEY-B
+                   READ FILE-A AT END MOVE 'Y' TO WS-EOF-A
+               ELSE READ FILE-B AT END MOVE 'Y' TO WS-EOF-B
+               END-IF
+           END-PERFORM. CLOSE FILE-A FILE-B. STOP RUN.''')
+
+# H018: M:N -> M
+test('H018', 'M:N->M matching', PREAMBLE + '''
+       01 WS-KEY-M PIC X(10). 01 WS-KEY-N PIC X(10).
+       01 WS-EOF-M PIC X VALUE 'N'. 01 WS-EOF-N PIC X VALUE 'N'.
+       PROCEDURE DIVISION.
+           OPEN INPUT FILE-M FILE-N.
+           READ FILE-M AT END MOVE 'Y' TO WS-EOF-M.
+           READ FILE-N AT END MOVE 'Y' TO WS-EOF-N.
+           PERFORM UNTIL WS-EOF-M = 'Y' OR WS-EOF-N = 'Y'
+               IF WS-KEY-M = WS-KEY-N DISPLAY 'MATCH'
+               ELSE IF WS-KEY-M < WS-KEY-N READ FILE-M AT END MOVE 'Y' TO WS-EOF-M
+               ELSE READ FILE-N AT END MOVE 'Y' TO WS-EOF-N
+               END-IF
+           END-PERFORM. CLOSE FILE-M FILE-N. STOP RUN.''')
+
+# H020: M:N -> MxN (cartesian)
+test('H020', 'M:N->MxN', PREAMBLE + '''
+       01 WS-KEY-M PIC X(10). 01 WS-KEY-N PIC X(10).
+       01 WS-SAVE-KEY PIC X(10). 01 WS-EOF-M PIC X VALUE 'N'.
+       01 WS-EOF-N PIC X VALUE 'N'.
+       PROCEDURE DIVISION.
+           OPEN INPUT FILE-M FILE-N OUTPUT FILE-O.
+           READ FILE-M AT END MOVE 'Y' TO WS-EOF-M.
+           PERFORM UNTIL WS-EOF-M = 'Y'
+               MOVE WS-KEY-M TO WS-SAVE-KEY
+               READ FILE-N AT END MOVE 'Y' TO WS-EOF-N
+               PERFORM UNTIL WS-EOF-N = 'Y'
+                   IF WS-KEY-M = WS-KEY-N WRITE REC-O FROM REC-N
+                   READ FILE-N AT END MOVE 'Y' TO WS-EOF-N
+               END-PERFORM
+               READ FILE-M AT END MOVE 'Y' TO WS-EOF-M
+           END-PERFORM. CLOSE FILE-M FILE-N FILE-O. STOP RUN.''')
+
+# H022: MIXED MATCHING
+test('H022', 'mixed matching', PREAMBLE + '''
+       01 WS-KEY-P PIC X(10). 01 WS-KEY-Q PIC X(10).
+       01 WS-PREV-KEY PIC X(10). 01 WS-EOF-P PIC X VALUE 'N'.
+       01 WS-EOF-Q PIC X VALUE 'N'.
+       PROCEDURE DIVISION.
+           OPEN INPUT FILE-P FILE-Q.
+           READ FILE-P AT END MOVE 'Y' TO WS-EOF-P.
+           READ FILE-Q AT END MOVE 'Y' TO WS-EOF-Q.
+           PERFORM UNTIL WS-EOF-P = 'Y' OR WS-EOF-Q = 'Y'
+               IF WS-KEY-P = WS-KEY-Q
+                   DISPLAY 'MATCH'
+                   READ FILE-P AT END MOVE 'Y' TO WS-EOF-P
+                   READ FILE-Q AT END MOVE 'Y' TO WS-EOF-Q
+               ELSE IF WS-KEY-P < WS-KEY-Q
+                   READ FILE-P AT END MOVE 'Y' TO WS-EOF-P
+               ELSE READ FILE-Q AT END MOVE 'Y' TO WS-EOF-Q
+               END-IF
+           END-PERFORM. CLOSE FILE-P FILE-Q. STOP RUN.''')
+
+print()
+
+# ════════════════════════════════════════════════
+# 2. キーブレイク系 (5 types)
+# ════════════════════════════════════════════════
+print('--- キーブレイク系 ---')
+
+test('H007', 'key break', PREAMBLE + '''
+       01 WS-PREV-KEY PIC X(10). 01 WS-KEY PIC X(10).
+       01 WS-SUM PIC 9(7)V99. 01 WS-EOF PIC X VALUE 'N'.
+       PROCEDURE DIVISION.
+           OPEN INPUT IN-FILE OUTPUT OUT-FILE.
+           READ IN-FILE AT END MOVE 'Y' TO WS-EOF.
+           PERFORM UNTIL WS-EOF = 'Y'
+               IF WS-KEY NOT = WS-PREV-KEY
+                   IF WS-PREV-KEY NOT = SPACES
+                       DISPLAY WS-PREV-KEY WS-SUM
+                   END-IF
+                   MOVE WS-KEY TO WS-PREV-KEY
+                   MOVE 0 TO WS-SUM
+               END-IF
+               ADD 1 TO WS-SUM
+               READ IN-FILE AT END MOVE 'Y' TO WS-EOF
+           END-PERFORM. CLOSE IN-FILE OUT-FILE. STOP RUN.''')
+
+# ════════════════════════════════════════════════
+# 3. 条件分岐系 (2 types)
+# ════════════════════════════════════════════════
+print('--- 条件分岐系 ---')
+
+test('H005', 'IF condition', PREAMBLE + '''
+       01 WS-A PIC 9(5). 01 WS-B PIC 9(5).
+       01 WS-C PIC X(10).
+       PROCEDURE DIVISION.
+           IF WS-A > 100 AND WS-B < 50
+               MOVE 'LARGE' TO WS-C
+           ELSE IF WS-A > 50
+               MOVE 'MEDIUM' TO WS-C
+           ELSE
+               MOVE 'SMALL' TO WS-C.
+           DISPLAY WS-C.
+           STOP RUN.''')
+
+test('H006', 'EVALUATE', PREAMBLE + '''
+       01 WS-STATUS PIC X(1). 01 WS-RESULT PIC X(10).
+       PROCEDURE DIVISION.
+           EVALUATE WS-STATUS
+               WHEN 'A' MOVE 'ACTIVE' TO WS-RESULT
+               WHEN 'I' MOVE 'INACTIVE' TO WS-RESULT
+               WHEN 'S' MOVE 'SUSPEND' TO WS-RESULT
+               WHEN OTHER MOVE 'UNKNOWN' TO WS-RESULT
+           END-EVALUATE.
+           DISPLAY WS-RESULT. STOP RUN.''')
+
+# ════════════════════════════════════════════════
+# 4. 編集処理系 (3 types)
+# ════════════════════════════════════════════════
+print('--- 編集処理系 ---')
+
+test('H004', 'edit process', PREAMBLE + '''
+       01 WS-ERR-CODE PIC 9(4). 01 WS-ERR-MSG PIC X(50).
+       01 WS-VALUE PIC 9(5).
+       PROCEDURE DIVISION.
+           IF WS-VALUE = 0
+               MOVE 9999 TO WS-ERR-CODE
+               MOVE 'ZERO VALUE' TO WS-ERR-MSG
+           ELSE
+               DISPLAY WS-VALUE.
+           STOP RUN.''')
+
+# ════════════════════════════════════════════════
+# 5. データベース系 (3 types)
+# ════════════════════════════════════════════════
+print('--- データベース系 ---')
+
+test('H101', 'DB operation', PREAMBLE + '''
+       01 WS-ID PIC X(10). 01 WS-NAME PIC X(30).
+       PROCEDURE DIVISION.
+           EXEC SQL
+               SELECT EMP_NAME INTO :WS-NAME
+               FROM EMPLOYEE WHERE EMP_ID = :WS-ID
+           END-EXEC.
+           DISPLAY WS-NAME.
+           STOP RUN.''')
+
+# ════════════════════════════════════════════════
+# 6. データ分割系 (3 types)
+# ════════════════════════════════════════════════
+print('--- データ分割系 ---')
+
+test('H010', 'divide 100', PREAMBLE + '''
+       01 WS-VALUE PIC 9(5) VALUE 10000.
+       01 WS-RESULT PIC 9(5). 01 WS-REMAIND PIC 9(5).
+       PROCEDURE DIVISION.
+           DIVIDE 100 INTO WS-VALUE GIVING WS-RESULT
+               REMAINDER WS-REMAIND.
+           IF WS-REMAIND = 0 DISPLAY 'DIVISIBLE'.
+           STOP RUN.''')
+
+# ════════════════════════════════════════════════
+# 7. 項目チェック系 (3 types)
+# ════════════════════════════════════════════════
+print('--- 項目チェック系 ---')
+
+test('H013', 'validation with dup', PREAMBLE + '''
+       01 WS-KEY PIC X(10). 01 WS-PREV-KEY PIC X(10) VALUE SPACES.
+       01 WS-EOF PIC X VALUE 'N'. 01 WS-DUP-COUNT PIC 9(4) VALUE 0.
+       PROCEDURE DIVISION.
+           OPEN INPUT IN-FILE.
+           READ IN-FILE AT END MOVE 'Y' TO WS-EOF.
+           PERFORM UNTIL WS-EOF = 'Y'
+               IF WS-KEY = WS-PREV-KEY
+                   ADD 1 TO WS-DUP-COUNT
+               ELSE
+                   MOVE WS-KEY TO WS-PREV-KEY
+               END-IF
+               READ IN-FILE AT END MOVE 'Y' TO WS-EOF
+           END-PERFORM.
+           CLOSE IN-FILE. STOP RUN.''')
+
+# ════════════════════════════════════════════════
+# 8. 内部処理系 (4 types)
+# ════════════════════════════════════════════════
+print('--- 内部処理系 ---')
+
+test('H103', 'internal search', PREAMBLE + '''
+       01 WS-TABLE. 05 WS-ENTRY OCCURS 10 TIMES
+                         ASCENDING KEY IS WS-ENTRY-ID
+                         INDEXED BY WS-IDX.
+           10 WS-ENTRY-ID PIC 9(03). 10 WS-ENTRY-NAME PIC X(10).
+       01 WS-SEARCH-ID PIC 9(03). 01 WS-FOUND PIC X VALUE 'N'.
+       PROCEDURE DIVISION.
+           MOVE 5 TO WS-SEARCH-ID.
+           SEARCH ALL WS-ENTRY
+               AT END DISPLAY 'NOT FOUND'
+               WHEN WS-ENTRY-ID(WS-IDX) = WS-SEARCH-ID
+                   MOVE 'Y' TO WS-FOUND.
+           IF WS-FOUND = 'Y' DISPLAY 'FOUND'.
+           STOP RUN.''')
+
+# ════════════════════════════════════════════════
+# 9. オンライン系 (1 type)
+# ════════════════════════════════════════════════
+print('--- オンライン系 ---')
+
+test('H014', 'CICS online', PREAMBLE + '''
+       01 WS-COMMAREA. 05 WS-CA-LEN PIC S9(4) COMP.
+       01 WS-RESP PIC S9(8) COMP.
+       PROCEDURE DIVISION.
+      *>    EXEC CICS RECEIVE MAP('MAP01')
+      *>        INTO(WS-COMMAREA)
+      *>        RESP(WS-RESP)
+      *>    END-EXEC.
+           IF WS-RESP = 0 DISPLAY 'OK'.
+           STOP RUN.''')
+
+# ════════════════════════════════════════════════
+# 10. SORT/MERGE (2 types)
+# ════════════════════════════════════════════════
+print('--- SORT/MERGE ---')
+
+test('SRT1', 'SORT', PREAMBLE + '''
+       01 WS-DATA PIC X(80).
+       PROCEDURE DIVISION.
+           SORT SORT-FILE ON ASCENDING KEY SORT-KEY
+               USING IN-FILE GIVING OUT-FILE.
+           STOP RUN.''')
+
+test('MRG1', 'MERGE', PREAMBLE + '''
+       01 WS-DATA PIC X(80).
+       PROCEDURE DIVISION.
+           MERGE MERGE-FILE ON ASCENDING KEY MERGE-KEY
+               USING FILE-1 FILE-2 GIVING FILE-O.
+           STOP RUN.''')
+
+# ════════════════════════════════════════════════
+# L1 KEYWORD DIRECT TYPES (11 types)
+# ════════════════════════════════════════════════
+print()
+print('--- L1 DIRECT TYPES ---')
+
+test('L1-SQL', 'EXEC SQL', PREAMBLE + '''
+       01 WS-ID PIC X(10).
+       PROCEDURE DIVISION.
+           EXEC SQL SELECT * FROM TBL WHERE ID = :WS-ID END-EXEC.
+           STOP RUN.''', 'DB操作', 0.40)
+
+test('L1-CALL', 'subprogram call', PREAMBLE + '''
+       01 WS-PARAM PIC X(10).
+       LINKAGE SECTION. 01 LS-PARAM PIC X(10).
+       PROCEDURE DIVISION USING LS-PARAM.
+           CALL 'SUBPGM' USING WS-PARAM.
+           STOP RUN.''', '子程序调用', 0.30)
+
+test('L1-INIT', 'IS INITIAL', PREAMBLE + '''
+       01 WS-CNT PIC 9(5) VALUE 0.
+       PROCEDURE DIVISION.
+           ADD 1 TO WS-CNT. DISPLAY WS-CNT. STOP RUN.
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. MYPROG IS INITIAL.''', 'IS INITIAL', 0.30)
+
+test('L1-SYS', 'SYSIN', PREAMBLE + '''
+       01 WS-DATA PIC X(80).
+       PROCEDURE DIVISION.
+           ACCEPT WS-DATA FROM SYSIN.
+           DISPLAY WS-DATA. STOP RUN.''', 'SYSIN', 0.30)
+
+test('L1-ENC', 'encoding', PREAMBLE + '''
+       01 WS-ASCII PIC X(10) VALUE 'ABCDEF'.
+       01 WS-EBCDIC PIC X(10).
+       PROCEDURE DIVISION.
+           IF WS-ASCII >= 'A' AND <= 'Z'
+               DISPLAY 'ALPHA'.
+           STOP RUN.''', '编码转换', 0.50)
+
+test('L1-CIC', 'CICS', PREAMBLE + '''
+       01 WS-CA PIC X(100).
+       01 WS-MAP PIC X(10).
+       PROCEDURE DIVISION.
+           IF WS-MAP = 'MAP01' DISPLAY 'OK'.
+           STOP RUN.''', 'online', 0.30)
+
+test('L1-SRT', 'SORT keyword', PREAMBLE + '''
+       01 WS-KEY PIC X(10).
+       PROCEDURE DIVISION.
+           SORT WORK-FILE ON ASCENDING KEY WS-KEY.
+           STOP RUN.''', 'SORT', 0.40)
+
+test('L1-MRG', 'MERGE keyword', PREAMBLE + '''
+       01 WS-KEY PIC X(10).
+       PROCEDURE DIVISION.
+           MERGE WORK-FILE ON ASCENDING KEY WS-KEY.
+           STOP RUN.''', 'MERGE', 0.40)
+
+test('L1-WRT', 'WRITE AFTER', PREAMBLE + '''
+       01 WS-REC PIC X(50).
+       PROCEDURE DIVISION.
+           OPEN OUTPUT OUT-FILE.
+           WRITE WS-REC AFTER ADVANCING 1 LINE.
+           CLOSE OUT-FILE. STOP RUN.''', '编辑输出', 0.30)
+
+test('L1-ORG', 'ORGANIZATION IS', PREAMBLE + '''
+       01 WS-KEY PIC X(10).
+       PROCEDURE DIVISION.
+           MOVE 'KEY' TO WS-KEY. STOP RUN.
+       ENVIRONMENT DIVISION.
+       INPUT-OUTPUT SECTION.
+       FILE-CONTROL.
+           SELECT FILE-A ASSIGN TO 'A.DAT'
+               ORGANIZATION IS INDEXED.''', '文件编成', 0.40)
+
+test('L1-ALT', 'ALTERNATE KEY', PREAMBLE + '''
+       01 WS-KEY PIC X(10).
+       PROCEDURE DIVISION.
+           MOVE 'KEY' TO WS-KEY. STOP RUN.
+       ENVIRONMENT DIVISION.
+       INPUT-OUTPUT SECTION.
+       FILE-CONTROL.
+           SELECT FILE-A ASSIGN TO 'A.DAT'
+               ALTERNATE RECORD KEY IS ALT-KEY.''', '替代索引', 0.40)
+
+# ════════════════════════════════════════════════
+# ADDITIONAL RULE ENGINE TYPES
+# ════════════════════════════════════════════════
+print()
+print('--- RULE ENGINE TYPES ---')
+
+test('CSV1', 'CSV merge', PREAMBLE + '''
+       01 WS-F1 PIC X(10) VALUE 'ALPHA'.
+       01 WS-F2 PIC X(10) VALUE 'BETA'.
+       01 WS-CSV PIC X(50). 01 WS-P PIC 9(3) VALUE 1.
+       PROCEDURE DIVISION.
+           STRING WS-F1 DELIMITED BY SPACES
+                  ',' DELIMITED BY SIZE
+                  WS-F2 DELIMITED BY SPACES
+             INTO WS-CSV WITH POINTER WS-P.
+           DISPLAY WS-CSV. STOP RUN.''', 'CSV合并', 0.15)
+
+test('CSV2', 'CSV split', PREAMBLE + '''
+       01 WS-LINE PIC X(50) VALUE 'A,B,C,D'.
+       01 WS-C PIC 9(3).
+       PROCEDURE DIVISION.
+           INSPECT WS-LINE TALLYING WS-C FOR ALL ','.
+           INSPECT WS-LINE REPLACING ALL ',' BY '|'.
+           DISPLAY WS-LINE. STOP RUN.''', 'CSV拆分', 0.15)
+
+test('PURE', 'pure matching', PREAMBLE + '''
+       01 WS-KEY-A PIC X(10). 01 WS-KEY-B PIC X(10).
+       01 WS-EOF-A PIC X VALUE 'N'. 01 WS-EOF-B PIC X VALUE 'N'.
+       PROCEDURE DIVISION.
+           OPEN INPUT FILE-A FILE-B.
+           READ FILE-A AT END MOVE 'Y' TO WS-EOF-A.
+           READ FILE-B AT END MOVE 'Y' TO WS-EOF-B.
+           PERFORM UNTIL WS-EOF-A = 'Y' OR WS-EOF-B = 'Y'
+               IF WS-KEY-A = WS-KEY-B DISPLAY 'M'
+                   READ FILE-A AT END MOVE 'Y' TO WS-EOF-A
+                   READ FILE-B AT END MOVE 'Y' TO WS-EOF-B
+               ELSE IF WS-KEY-A < WS-KEY-B
+                   READ FILE-A AT END MOVE 'Y' TO WS-EOF-A
+               ELSE READ FILE-B AT END MOVE 'Y' TO WS-EOF-B
+               END-IF
+           END-PERFORM. CLOSE FILE-A FILE-B. STOP RUN.''', 'マッチング', 0.30)
+
+test('DIV50', 'DIVIDE 50', PREAMBLE + '''
+       01 WS-V PIC 9(5) VALUE 100.
+       01 WS-R PIC 9(5). 01 WS-REM PIC 9(5).
+       PROCEDURE DIVISION.
+           DIVIDE 50 INTO WS-V GIVING WS-R REMAINDER WS-REM.
+           IF WS-R = 2 DISPLAY 'OK'.
+           STOP RUN.''', 'DIVIDE_50.0', 0.20)
+
+test('DIV25', 'DIVIDE 25', PREAMBLE + '''
+       01 WS-V PIC 9(5) VALUE 100.
+       01 WS-R PIC 9(5). 01 WS-REM PIC 9(5).
+       PROCEDURE DIVISION.
+           DIVIDE 25 INTO WS-V GIVING WS-R REMAINDER WS-REM.
+           IF WS-R = 4 DISPLAY 'OK'.
+           STOP RUN.''', 'DIVIDE_25.0', 0.20)
+
+test('DIV100', 'DIVIDE 100', PREAMBLE + '''
+       01 WS-V PIC 9(5) VALUE 10000.
+       01 WS-R PIC 9(5). 01 WS-REM PIC 9(5).
+       PROCEDURE DIVISION.
+           DIVIDE 100 INTO WS-V GIVING WS-R REMAINDER WS-REM.
+           IF WS-R = 100 DISPLAY 'OK'.
+           STOP RUN.''', 'DIVIDE_100.0', 0.20)
+
+print()
+print('=' * 80)
+print(f'結果: {PASS} PASS / {FAIL} FAIL / {TOTAL} TOTAL')
+print('=' * 80)
+
+if FAIL > 0:
+    sys.exit(1)

tests/hina/test_classifier_deep.py

@@ -45,8 +45,8 @@ def test_detect_keyword_multiple_matches():
 
 def test_compute_confidence_hybrid():
     """Keyword match below 0.90 threshold + LLM result → method=hybrid, uses LLM category"""
-    # "WRITE AFTER" matches "编辑输出" with confidence 0.80 (< 0.90)
-    source = "WRITE AFTER ADVANCING 1 LINE."
+    # "WRITE REC AFTER" matches "编辑输出" with confidence 0.80 (< 0.90)
+    source = "WRITE REC AFTER ADVANCING 1 LINE."
     llm_result = {"category": "output_heavy", "confidence": 0.75}
 
     result = compute_confidence(source, llm_result=llm_result)
@@ -57,7 +57,6 @@ def test_compute_confidence_hybrid():
     assert result["confidence"] == 0.75
     # Keyword matches are still attached to the result
     assert len(result["matches"]) > 0
-    assert any("WRITE AFTER" in str(m) for m in result["matches"])
 
 
 def test_compute_confidence_keyword_high_confidence_overrides_llm():
@@ -192,8 +191,8 @@ def test_detect_keyword_all_rules():
         ("MAP", "online"),
         ("SORT SORT-FILE ON KEY", "SORT"),
         ("MERGE MERGE-FILE ON KEY", "MERGE"),
-        ("WRITE AFTER", "编辑输出"),
-        ("WRITE BEFORE", "编辑输出"),
+        ("WRITE OUT AFTER", "编辑输出"),
+        ("WRITE OUT BEFORE", "编辑输出"),
         ("ORGANIZATION IS", "文件编成"),
         ("ALTERNATE RECORD KEY", "替代索引"),
     ]