| import hashlib |
| import json |
| import os |
| import subprocess |
| import sys |
| from pathlib import Path |
|
|
| import pytest |
|
|
|
|
| APP = Path("/app") |
| SOURCE_ROOT = APP / "vendor" / "lark" |
| FIXTURES = Path("/tests/fixtures") |
|
|
| sys.path.insert(0, str(SOURCE_ROOT)) |
|
|
| from lark import Lark, Token, Transformer |
|
|
|
|
| def sha256(path): |
| return hashlib.sha256(path.read_bytes()).hexdigest() |
|
|
|
|
| def token_values(tree): |
| return [(value.type, str(value)) for value in tree.scan_values(lambda value: isinstance(value, Token))] |
|
|
|
|
| def advance(interactive, count): |
| stream = interactive.lexer_thread.lex(interactive.parser_state) |
| for _ in range(count): |
| token = next(stream) |
| interactive.feed_token(token) |
|
|
|
|
| def assert_clone_identity(original, clone): |
| assert clone is not original |
| assert clone.parser_state is not original.parser_state |
| assert clone.parser_state.state_stack is not original.parser_state.state_stack |
| assert clone.lexer_thread is not original.lexer_thread |
| assert clone.parser_state.lexer is clone.lexer_thread |
| assert clone.parser_state.lexer is not original.parser_state.lexer |
| if original.lexer_thread.state is None: |
| assert clone.lexer_thread.state is None |
| else: |
| assert clone.lexer_thread.state is not original.lexer_thread.state |
| assert clone.lexer_thread.state.line_ctr is not original.lexer_thread.state.line_ctr |
|
|
|
|
| def test_gate_artifact_schema_and_source_integrity(): |
| report_path = APP / "repair_report.json" |
| assert report_path.is_file() |
| report = json.loads(report_path.read_text()) |
| assert report["output_schema_version"] == "lark-clone-repair-v1" |
| assert report["source_root"] == "vendor/lark" |
| assert report["summary"] == {"all_cases_pass": True, "case_count": 3, "passed_count": 3} |
| assert {case["id"] for case in report["cases"]} == {"clone_first_short", "original_first_multiline", "value_copy_policy"} |
| assert all(case["passed"] is True for case in report["cases"]) |
|
|
| trusted = json.loads((FIXTURES / "trusted_hashes.json").read_text()) |
| for relative, expected in trusted["protected"].items(): |
| path = SOURCE_ROOT / relative |
| assert path.is_file(), relative |
| assert sha256(path) == expected, relative |
| for relative, pristine in trusted["mutable_pristine"].items(): |
| path = SOURCE_ROOT / relative |
| assert path.is_file(), relative |
| assert sha256(path) != pristine, f"{relative} was not repaired" |
|
|
|
|
| def test_gate_build_and_upstream_compatibility(): |
| env = {**os.environ, "PYTHONPATH": str(SOURCE_ROOT), "PYTHONDONTWRITEBYTECODE": "1"} |
| compile_result = subprocess.run( |
| [sys.executable, "-m", "compileall", "-q", "lark"], |
| cwd=SOURCE_ROOT, |
| env=env, |
| capture_output=True, |
| text=True, |
| timeout=30, |
| ) |
| assert compile_result.returncode == 0, compile_result.stderr |
| upstream_result = subprocess.run( |
| [sys.executable, "tests/test_parser.py", "TestLalrBasic.test_parser_interactive_parser", "-q"], |
| cwd=SOURCE_ROOT, |
| env=env, |
| capture_output=True, |
| text=True, |
| timeout=45, |
| ) |
| assert upstream_result.returncode == 0, upstream_result.stdout + upstream_result.stderr |
| assert "OK" in upstream_result.stderr + upstream_result.stdout |
|
|
|
|
| @pytest.mark.parametrize("clone_first", [True, False]) |
| def test_core_private_resume_is_independent_in_both_orders(clone_first): |
| fixture = json.loads((FIXTURES / "private_cases.json").read_text()) |
| assert fixture["output_schema_version"] == "lark-clone-repair-v1" |
| for case in fixture["resume_cases"]: |
| parser = Lark(case["grammar"], parser="lalr") |
| expected = token_values(parser.parse(case["text"])) |
| original = parser.parse_interactive(case["text"]) |
| advance(original, case["advance"]) |
| clone = original.copy() |
| assert_clone_identity(original, clone) |
| original_position = original.lexer_thread.state.line_ctr.char_pos |
| clone_position = clone.lexer_thread.state.line_ctr.char_pos |
| assert original_position == clone_position |
| first, second = (clone, original) if clone_first else (original, clone) |
| first_tree = first.resume_parse() |
| assert token_values(first_tree) == expected, case["id"] |
| assert second.lexer_thread.state.line_ctr.char_pos == original_position |
| second_tree = second.resume_parse() |
| assert token_values(second_tree) == expected, case["id"] |
| assert first_tree == second_tree |
|
|
|
|
| class MutableTransformer(Transformer): |
| def ITEM(self, value): |
| return {"token": str(value), "notes": []} |
|
|
|
|
| def test_core_value_copy_policy_and_manual_continuation(): |
| parser = Lark("start: ITEM ITEM ITEM\nITEM: /[a-z]+/\n%ignore \" \"", parser="lalr", transformer=MutableTransformer()) |
| original = parser.parse_interactive("one two three") |
| advance(original, 1) |
| shallow = original.copy(deepcopy_values=False) |
| deep = original.copy(deepcopy_values=True) |
| assert_clone_identity(original, shallow) |
| assert_clone_identity(original, deep) |
| original_value = original.parser_state.value_stack[-1] |
| assert shallow.parser_state.value_stack[-1] is original_value |
| assert deep.parser_state.value_stack[-1] is not original_value |
| assert deep.parser_state.value_stack[-1] == original_value |
| shallow.parser_state.value_stack[-1]["notes"].append("shared") |
| assert original_value["notes"] == ["shared"] |
| assert deep.parser_state.value_stack[-1]["notes"] == [] |
|
|
| plain = Lark("start: WORD+\nWORD: /[a-z]+/\n%ignore \" \"", parser="lalr") |
| manual_original = plain.parse_interactive("north south east west") |
| advance(manual_original, 1) |
| manual_clone = manual_original.copy() |
| assert_clone_identity(manual_original, manual_clone) |
| clone_tokens = manual_clone.exhaust_lexer() |
| clone_tree = manual_clone.feed_eof(clone_tokens[-1]) |
| original_tokens = manual_original.exhaust_lexer() |
| original_tree = manual_original.feed_eof(original_tokens[-1]) |
| assert token_values(clone_tree) == token_values(plain.parse("north south east west")) |
| assert clone_tree == original_tree |
|
|
|
|
| def test_edge_no_text_eof_and_multiline_cursor_isolation(): |
| parser = Lark("start: A+\nA: \"a\"", parser="lalr") |
| original = parser.parse_interactive() |
| clone = original.copy() |
| assert_clone_identity(original, clone) |
| original.feed_token(Token("A", "a")) |
| clone.feed_token(Token("A", "a")) |
| clone.feed_token(Token("A", "a")) |
| assert token_values(original.feed_eof()) == [("A", "a")] |
| assert token_values(clone.feed_eof()) == [("A", "a"), ("A", "a")] |
|
|
| multiline = Lark("start: WORD+\nWORD: /[a-z]+/\n%ignore /[ \\t\\n]+/", parser="lalr", propagate_positions=True) |
| source = "first\nsecond\nthird\nfourth" |
| left = multiline.parse_interactive(source) |
| advance(left, 1) |
| right = left.copy() |
| assert_clone_identity(left, right) |
| right_tree = right.resume_parse() |
| assert left.lexer_thread.state.line_ctr.line == 1 |
| left_tree = left.resume_parse() |
| assert right_tree == left_tree == multiline.parse(source) |
| assert right_tree.meta.end_line == 4 |
|
|
