yagi 0.0.3

Batteries-included DSP library
Documentation 
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

def parse_liquid_tests(lines):
    """
    Example line:
         2[    0.04 ms]   PASS   passed    4/   4 checks (100.0%) agc_crcf_dc_gain_control

    Example module line:
    120: fskmodem:
    """
    import re
    from collections import defaultdict

    TEST_RE = re.compile(r"^\s*\d+\[\s*\d+\.\d+ ms\]\s+(\w+)\s+passed\s+\d+/\s*\d+\s+checks\s+\(\s*\d+\.\d+%\)\s+(\w+)")
    MODULE_RE = re.compile(r"^(\d+): (\w+):$")

    module_map = defaultdict(list)
    passing_tests = []
    failing_tests = []
    current_module = None

    for line in lines:
        if m := TEST_RE.match(line):
            test_name = m.group(2)
            module_map[current_module].append(test_name)
            if m.group(1) == "PASS":
                passing_tests.append(test_name)
            else:
                failing_tests.append(test_name)

        if m := MODULE_RE.match(line):
            current_module = m.group(2)

    print(len(module_map), len(passing_tests), len(failing_tests))

    return module_map, passing_tests, failing_tests


def parse_yagi_tests(lines):
    """
    Example annotation line:
        !! liquid test annotation: autotest_iirfiltsos_step_n2 -> test_iirfiltsos_step_n2 !!

    Example test line:
    running 2 tests
        test filter::iirfiltsos::tests::test_iirfiltsos_impulse_n2 ... ok
        test filter::iirfiltsos::tests::test_iirfiltsos_step_n2 ... FAILED
    """
    import re

    RUNNING_TEST_RE = re.compile(r"^running (\d+) tests$")
    TEST_RE = re.compile(r"^\s*test (\S+) \.\.\. (ok|FAILED)$")
    TEST_ANNOTATION_RE = re.compile(r"^\s*!! liquid test annotation: autotest_(\S+) -> (\S+) !!$")

    test_map = {}
    test_count = None
    passing_tests = []
    failing_tests = []

    for line in lines:
        if m := RUNNING_TEST_RE.match(line):
            test_count = int(m.group(1))

        if test_count:
            if m := TEST_RE.match(line):
                test_name = m.group(1).split("::")[-1]
                test_result = m.group(2)
                if test_result == "ok":
                    passing_tests.append(test_name)
                else:
                    failing_tests.append(test_name)
                test_count -= 1

        if m := TEST_ANNOTATION_RE.match(line):
            liquid_test_name = m.group(1)
            yagi_test_name = m.group(2)
            if yagi_test_name in test_map:
                print(f"Duplicate test name: {yagi_test_name}")
            test_map[yagi_test_name] = liquid_test_name

    liquid_passing = [test_map[test] for test in passing_tests if test in test_map]
    liquid_failing = [test_map[test] for test in failing_tests if test in test_map]

    return liquid_passing, liquid_failing


def main():
    import os

    with open("liquid-test.out", "r") as f:
        liquid_module_map, liquid_passing, liquid_failing = parse_liquid_tests(f.readlines())

    with open("yagi-test.out", "r") as f:
        yagi_passing, yagi_failing = parse_yagi_tests(f.readlines())

    all_liquid_pass = 0
    all_liquid_fail = 0
    all_liquid_missing = 0
    all_yagi_pass = 0
    all_yagi_fail = 0
    all_yagi_missing = 0

    for module, tests in liquid_module_map.items():
        liquid_pass = 0
        liquid_fail = 0
        liquid_missing = 0
        yagi_pass = 0
        yagi_fail = 0
        yagi_missing = 0
        for test in tests:
            if test in liquid_passing:
                liquid_pass += 1
            elif test in liquid_failing:
                liquid_fail += 1
            else:
                liquid_missing += 1

            if test in yagi_passing:
                yagi_pass += 1
            elif test in yagi_failing:
                yagi_fail += 1
            else:
                yagi_missing += 1

        all_liquid_pass += liquid_pass
        all_liquid_fail += liquid_fail
        all_liquid_missing += liquid_missing
        all_yagi_pass += yagi_pass
        all_yagi_fail += yagi_fail
        all_yagi_missing += yagi_missing

        yagi_pass_pct = yagi_pass / (liquid_pass + liquid_fail) * 100
        yagi_present_pct = (yagi_pass + yagi_fail) / (liquid_pass + liquid_fail) * 100

        print(f"{module:30s}: {liquid_pass:4d} {liquid_fail:4d} {liquid_missing:4d} {yagi_pass:4d} {yagi_fail:4d} {yagi_missing:4d} {yagi_pass_pct:8.2f}% {yagi_present_pct:8.2f}%")

    all_yagi_pass_pct = all_yagi_pass / (all_liquid_pass + all_liquid_fail) * 100
    all_yagi_present_pct = (all_yagi_pass + all_yagi_fail) / (all_liquid_pass + all_liquid_fail) * 100
    total = "TOTAL"
    print(f"\n{total:30s}: {all_liquid_pass:4d} {all_liquid_fail:4d} {all_liquid_missing:4d} {all_yagi_pass:4d} {all_yagi_fail:4d} {all_yagi_missing:4d} {all_yagi_pass_pct:8.2f}% {all_yagi_present_pct:8.2f}%")


    # write result to LIQUID_COMPAT.md
    with open("LIQUID_COMPAT.md", "w") as f:
        for module, tests in liquid_module_map.items():
            f.write(f"\n\n## {module}\n")
            f.write(f"| Test | Liquid | Yagi |\n")
            f.write(f"| ---- | ------ | ---- |\n")
            for test in tests:
                f.write(f"| {test:40s} |")
                if test in liquid_passing:
                    f.write(f" ✅")
                else:
                    f.write(f" ❌")

                f.write(f" |")
                if test in yagi_passing:
                    f.write(f" ✅")
                elif test in yagi_failing:
                    f.write(f" ❌")
                else:
                    f.write(f" ❓")
                f.write(f" |\n")

if __name__ == "__main__":
    main()