File size: 7,125 Bytes
5708f7d | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 | 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
|