File size: 3,809 Bytes
e9dac18
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""What the two readers do, taken from the questions the corpus already carries."""

import pytest

from lgstratum import canonical, compare, corpus, read_a, read_b

ITEMS = {item["id"]: item for item in corpus.load()}
AGREED = [item_id for item_id, item in ITEMS.items() if (item.get("expect") or {}).get("state") == "AGREED"]
SINGLE = [item_id for item_id, item in ITEMS.items() if (item.get("expect") or {}).get("state") == "SINGLE"]
NEGATIVE = [item_id for item_id, item in ITEMS.items()
            if (item.get("expect") or {}).get("state") == "NOT COVERED"]
PASSTHROUGH = [item_id for item_id, item in ITEMS.items()
               if (item.get("expect") or {}).get("state") == "PASSTHROUGH"]


def _item(item_id):
    item = ITEMS[item_id]
    return str(item["lang"]), str(item["question"])


def test_the_readers_are_read_from_the_data_not_from_a_fork():
    # Two readers that share nothing but the data files are the whole point: one matches the shapes
    # written in the frames, the other follows the joints of the math language. If they became the
    # same procedure, the stratum would be reading a question twice with one pair of eyes.
    assert read_a.read.__module__ != read_b.read.__module__
    import inspect
    assert "gap_markers" not in inspect.getsource(read_a.read)
    assert "compile_pattern" not in inspect.getsource(read_b.read)


@pytest.mark.parametrize("item_id", AGREED)
def test_both_readers_reach_the_same_sentence(item_id):
    lang, question = _item(item_id)
    a = read_a.read(lang, question)
    b = read_b.read(lang, question)
    assert a["status"] == "READ", (item_id, a.get("notes"))
    assert b["status"] == "READ", (item_id, b.get("notes"))
    assert a["kind"] == b["kind"], (item_id, a["kind"], b["kind"])
    assert compare.equivalence(a, b)["same"] is True, (item_id, compare.equivalence(a, b).get("why"))
    expected = canonical.tidy(str((ITEMS[item_id].get("expect") or {}).get("sentence", "")))
    if expected:
        assert canonical.tidy(canonical.print_math(a["kind"], a["slots"])) == expected, item_id


@pytest.mark.parametrize("item_id", AGREED)
def test_a_reader_keeps_every_number_the_question_wrote(item_id):
    lang, question = _item(item_id)
    reading = read_a.read(lang, question)
    assert compare.keeps(reading, question)["ok"] is True, (item_id, compare.keeps(reading, question))


@pytest.mark.parametrize("item_id", SINGLE)
def test_one_reader_may_abstain_where_the_other_reads(item_id):
    # The varieties that put the joints after the slot, rather than before it, are read by the strict
    # reader and not by the frame reader. That disagreement is reported, never hidden, and it is what
    # keeps the assurance of those questions at one.
    lang, question = _item(item_id)
    a = read_a.read(lang, question)
    b = read_b.read(lang, question)
    assert a["status"] == "READ", (item_id, a.get("notes"))
    assert b["status"] != "READ", (item_id, b.get("notes"))
    assert compare.equivalence(a, b)["same"] is False, item_id


@pytest.mark.parametrize("item_id", NEGATIVE)
def test_a_question_this_variety_does_not_write_is_not_read(item_id):
    lang, question = _item(item_id)
    for reading in (read_a.read(lang, question), read_b.read(lang, question)):
        assert reading["status"] != "READ", (item_id, reading.get("kind"), reading.get("slots"))
        assert not reading.get("math"), (item_id, reading.get("math"))


@pytest.mark.parametrize("item_id", PASSTHROUGH)
def test_the_math_language_is_handed_on_without_being_read(item_id):
    lang, question = _item(item_id)
    direct = canonical.direct(question)
    assert direct is not None, item_id
    assert canonical.tidy(str(direct.get("math", ""))) == canonical.tidy(
        str((ITEMS[item_id].get("expect") or {}).get("sentence", ""))), item_id