test_ebnf.py 12.1 KB
Newer Older
1
2
#!/usr/bin/python3

3
"""test_ebnf.py - tests of the ebnf module of DHParser 
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
                             

Author: Eckhart Arnold <arnold@badw.de>

Copyright 2017 Bavarian Academy of Sciences and Humanities

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""

23
from functools import partial
Eckhart Arnold's avatar
Eckhart Arnold committed
24
from multiprocessing import Pool
25
import sys
Eckhart Arnold's avatar
Eckhart Arnold committed
26
27
28
sys.path.extend(['../', './'])

from DHParser.toolkit import is_logging
Eckhart Arnold's avatar
Eckhart Arnold committed
29
from DHParser.parsers import compile_source, Retrieve, WHITESPACE_KEYWORD, nil_scanner
30
from DHParser.ebnf import get_ebnf_grammar, get_ebnf_transformer, EBNFTransformer, get_ebnf_compiler
31
from DHParser.dsl import compileEBNF, compileDSL, parser_factory
32
33


34
35
36
37
38
39
40
41
42
43
44
class TestDirectives:
    mini_language = """
        expression =  term  { ("+" | "-") term }
        term       =  factor  { ("*" | "/") factor }
        factor     =  constant | "("  expression  ")"
        constant   =  digit { digit } [ //~ ]
        digit      = /0/ | /1/ | /2/ | /3/ | /4/ | /5/ | /6/ | /7/ | /8/ | /9/ 
        """

    def test_whitespace_linefeed(self):
        lang = "@ whitespace = linefeed\n" + self.mini_language
45
        MinilangParser = parser_factory(lang)
46
47
        parser = MinilangParser()
        assert parser
Eckhart Arnold's avatar
Eckhart Arnold committed
48
        syntax_tree = parser("3 + 4 * 12")
49
        # parser.log_parsing_history("WSP")
50
        assert not syntax_tree.collect_errors()
Eckhart Arnold's avatar
Eckhart Arnold committed
51
        syntax_tree = parser("3 + 4 \n * 12")
52
53
        # parser.log_parsing_history("WSPLF")
        assert not syntax_tree.collect_errors()
Eckhart Arnold's avatar
Eckhart Arnold committed
54
        syntax_tree = parser("3 + 4 \n \n * 12")
55
        assert syntax_tree.collect_errors()
Eckhart Arnold's avatar
Eckhart Arnold committed
56
        syntax_tree = parser("3 + 4 \n\n * 12")
57
58
59
60
        assert syntax_tree.collect_errors()

    def test_whitespace_vertical(self):
        lang = "@ whitespace = vertical\n" + self.mini_language
61
        parser = parser_factory(lang)()
62
        assert parser
Eckhart Arnold's avatar
Eckhart Arnold committed
63
        syntax_tree = parser("3 + 4 * 12")
64
        assert not syntax_tree.collect_errors()
Eckhart Arnold's avatar
Eckhart Arnold committed
65
        syntax_tree = parser("3 + 4 \n * 12")
66
        assert not syntax_tree.collect_errors()
Eckhart Arnold's avatar
Eckhart Arnold committed
67
        syntax_tree = parser("3 + 4 \n \n * 12")
68
        assert not syntax_tree.collect_errors()
Eckhart Arnold's avatar
Eckhart Arnold committed
69
        syntax_tree = parser("3 + 4 \n\n * 12")
70
71
        assert not syntax_tree.collect_errors()

72
73
    def test_whitespace_horizontal(self):
        lang = "@ whitespace = horizontal\n" + self.mini_language
74
        parser = parser_factory(lang)()
75
        assert parser
Eckhart Arnold's avatar
Eckhart Arnold committed
76
        syntax_tree = parser("3 + 4 * 12")
77
        assert not syntax_tree.collect_errors()
Eckhart Arnold's avatar
Eckhart Arnold committed
78
        syntax_tree = parser("3 + 4 \n * 12")
79
80
        assert syntax_tree.collect_errors()

81

82
class TestEBNFParser:
Eckhart Arnold's avatar
Eckhart Arnold committed
83
    cases = {
84
85
86
87
88
89
90
91
92
93
94
95
96
97
        "list_": {
            "match": {
                1: "hund",
                2: "hund, katze,maus",
                3: "hund , katze"
            },
            "fail": {
                1: "123",
                2: '"literal"',
                3: "/regexp/"
            }
        }
    }

di68kap's avatar
di68kap committed
98

99
    def setup(self):
Eckhart Arnold's avatar
Eckhart Arnold committed
100
        self.EBNF = get_ebnf_grammar()
101
102
103

    def test_literal(self):
        snippet = '"literal" '
Eckhart Arnold's avatar
Eckhart Arnold committed
104
        result = self.EBNF(snippet, 'literal')
105
106
107
108
        assert not result.error_flag
        assert str(result) == snippet
        assert result.find(lambda node: str(node) == WHITESPACE_KEYWORD)

Eckhart Arnold's avatar
Eckhart Arnold committed
109
        result = self.EBNF(' "literal"', 'literal')
110
111
112
        assert result.error_flag  # literals catch following, but not leading whitespace


di68kap's avatar
di68kap committed
113
114


115
116
117
118
class TestPopRetrieve:
    mini_language = """
        document       = { text | codeblock }
        codeblock      = delimiter { text | (!:delimiter delimiter_sign) } ::delimiter
119
        delimiter      = delimiter_sign  # never use delimiter between capture and retrieve!!!
120
121
122
        delimiter_sign = /`+/
        text           = /[^`]+/ 
        """
123
    mini_lang2 = """
124
        @retrieve_counterpart = braces
125
        document       = { text | codeblock }
126
127
128
        codeblock      = braces { text | opening_braces | (!:braces closing_braces) } ::braces
        braces         = opening_braces
        opening_braces = /\{+/
129
        closing_braces = /\}+/
130
        text           = /[^{}]+/
131
        """
132
133

    def setup(self):
134
135
        self.minilang_parser = parser_factory(self.mini_language)()
        self.minilang_parser2 = parser_factory(self.mini_lang2)()
136

137
138
139
140
141
142
143
144
    @staticmethod
    def opening_delimiter(node, name):
        return node.tag_name == name and not isinstance(node.parser, Retrieve)

    @staticmethod
    def closing_delimiter(node):
        return isinstance(node.parser, Retrieve)

145
146
    def test_compile_mini_language(self):
        assert self.minilang_parser
147
        assert self.minilang_parser2
148
149
150

    def test_single_line(self):
        teststr = "Anfang ```code block `` <- keine Ende-Zeichen ! ``` Ende"
Eckhart Arnold's avatar
Eckhart Arnold committed
151
        syntax_tree = self.minilang_parser(teststr)
152
        assert not syntax_tree.collect_errors()
153
154
        delim = str(next(syntax_tree.find(partial(self.opening_delimiter, name="delimiter"))))
        pop = str(next(syntax_tree.find(self.closing_delimiter)))
155
        assert delim == pop
Eckhart Arnold's avatar
Eckhart Arnold committed
156
157
        if is_logging():
            syntax_tree.log("test_PopRetrieve_single_line.cst")
158
159
160
161
162
163
164
165
166
167

    def test_multi_line(self):
        teststr = """
            Anfang ```code block `` <- keine Ende-Zeichen ! ``` Ebde

            Absatz ohne ``` codeblock, aber
            das stellt sich erst am Ende herause...

            Mehrzeliger ```code block
            """
Eckhart Arnold's avatar
Eckhart Arnold committed
168
        syntax_tree = self.minilang_parser(teststr)
169
        assert not syntax_tree.collect_errors()
170
171
        delim = str(next(syntax_tree.find(partial(self.opening_delimiter, name="delimiter"))))
        pop = str(next(syntax_tree.find(self.closing_delimiter)))
172
        assert delim == pop
Eckhart Arnold's avatar
Eckhart Arnold committed
173
174
        if is_logging():
            syntax_tree.log("test_PopRetrieve_multi_line.cst")
175
176
177

    def test_single_line_complement(self):
        teststr = "Anfang {{{code block }} <- keine Ende-Zeichen ! }}} Ende"
Eckhart Arnold's avatar
Eckhart Arnold committed
178
        syntax_tree = self.minilang_parser2(teststr)
179
180
181
182
        assert not syntax_tree.collect_errors()
        delim = str(next(syntax_tree.find(partial(self.opening_delimiter, name="braces"))))
        pop = str(next(syntax_tree.find(self.closing_delimiter)))
        assert len(delim) == len(pop) and delim != pop
Eckhart Arnold's avatar
Eckhart Arnold committed
183
184
        if is_logging():
            syntax_tree.log("test_PopRetrieve_single_line.cst")
185
186
187
188
189
190
191
192
193
194

    def test_multi_line_complement(self):
        teststr = """
            Anfang {{{code block {{ <- keine Ende-Zeichen ! }}} Ende

            Absatz ohne {{{ codeblock, aber
            das stellt sich erst am Ende heraus...

            Mehrzeliger }}}code block
            """
Eckhart Arnold's avatar
Eckhart Arnold committed
195
        syntax_tree = self.minilang_parser2(teststr)
196
197
198
199
        assert not syntax_tree.collect_errors()
        delim = str(next(syntax_tree.find(partial(self.opening_delimiter, name="braces"))))
        pop = str(next(syntax_tree.find(self.closing_delimiter)))
        assert len(delim) == len(pop) and delim != pop
Eckhart Arnold's avatar
Eckhart Arnold committed
200
201
        if is_logging():
            syntax_tree.log("test_PopRetrieve_multi_line.cst")
202
203


204
205
class TestSemanticValidation:
    def check(self, minilang, bool_filter=lambda x: x):
Eckhart Arnold's avatar
Eckhart Arnold committed
206
        grammar = get_ebnf_grammar()
Eckhart Arnold's avatar
Eckhart Arnold committed
207
        st = grammar(minilang)
208
        assert not st.collect_errors()
209
        EBNFTransformer(st)
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
        assert bool_filter(st.collect_errors())

    def test_illegal_nesting(self):
        self.check('impossible = { [ "an optional requirement" ] }')

    def test_illegal_nesting_option_required(self):
        self.check('impossible = [ §"an optional requirement" ]')

    def test_illegal_nesting_oneormore_option(self):
        self.check('impossible = { [ "no use"] }+')

    def test_legal_nesting(self):
        self.check('possible = { [ "+" ] "1" }', lambda x: not x)


class TestCompilerErrors:
    def test_error_propagation(self):
227
        ebnf = "@ literalws = wrongvalue  # testing error propagation\n"
Eckhart Arnold's avatar
Eckhart Arnold committed
228
229
        result, messages, st = compile_source(ebnf, None, get_ebnf_grammar(),
            get_ebnf_transformer(), get_ebnf_compiler('ErrorPropagationTest'))
230
231
232
        assert messages


233
class TestSelfHosting:
Eckhart Arnold's avatar
Eckhart Arnold committed
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
    grammar = r"""
        # EBNF-Grammar in EBNF

        @ comment    =  /#.*(?:\n|$)/                    # comments start with '#' and eat all chars up to and including '\n'
        @ whitespace =  /\s*/                            # whitespace includes linefeed
        @ literalws  =  right                            # trailing whitespace of literals will be ignored tacitly

        syntax     =  [~//] { definition | directive } §EOF
        definition =  symbol §"=" expression
        directive  =  "@" §symbol §"=" ( regexp | literal | list_ )

        expression =  term { "|" term }
        term       =  { factor }+
        factor     =  [flowmarker] [retrieveop] symbol !"="   # negative lookahead to be sure it's not a definition
                    | [flowmarker] literal
                    | [flowmarker] regexp
                    | [flowmarker] group
                    | [flowmarker] regexchain
                    | [flowmarker] oneormore
                    | repetition
                    | option

        flowmarker =  "!"  | "&"  | "§" |                # '!' negative lookahead, '&' positive lookahead, '§' required
                      "-!" | "-&"                        # '-' negative lookbehind, '-&' positive lookbehind
        retrieveop =  "::" | ":"                         # '::' pop, ':' retrieve

        group      =  "(" expression §")"
        regexchain =  ">" expression §"<"                # compiles "expression" into a singular regular expression
        oneormore  =  "{" expression "}+"
        repetition =  "{" expression §"}"
        option     =  "[" expression §"]"

        link       = regexp | symbol | literal           # semantic restriction: symbol must evaluate to a regexp or chain

        symbol     =  /(?!\d)\w+/~                       # e.g. expression, factor, parameter_list
        literal    =  /"(?:[^"]|\\")*?"/~                # e.g. "(", '+', 'while'
                    | /'(?:[^']|\\')*?'/~                # whitespace following literals will be ignored tacitly.
        regexp     =  /~?\/(?:[^\/]|(?<=\\)\/)*\/~?/~    # e.g. /\w+/, ~/#.*(?:\n|$)/~
                                                         # '~' is a whitespace-marker, if present leading or trailing
                                                         # whitespace of a regular expression will be ignored tacitly.
        list_      =  /\w+/~ { "," /\w+/~ }              # comma separated list of symbols, e.g. BEGIN_LIST, END_LIST,
                                                         # BEGIN_QUOTE, END_QUOTE ; see CommonMark/markdown.py for an exmaple
        EOF =  !/./        
        """

279
280
    def test_self(self):
        compiler_name = "EBNF"
Eckhart Arnold's avatar
Eckhart Arnold committed
281
282
283
284
        compiler = get_ebnf_compiler(compiler_name, self.grammar)
        parser = get_ebnf_grammar()
        result, errors, syntax_tree = compile_source(self.grammar, None, parser,
                                            get_ebnf_transformer(), compiler)
285
286
287
        assert not errors, str(errors)
        # compile the grammar again using the result of the previous
        # compilation as parser
Eckhart Arnold's avatar
Eckhart Arnold committed
288
        compileDSL(self.grammar, nil_scanner, result, get_ebnf_transformer(), compiler)
289

Eckhart Arnold's avatar
Eckhart Arnold committed
290
291
292
293
294
295
296
297
298
299
300
301
302
303
    def multiprocessing_task(self):
        compiler_name = "EBNF"
        compiler = get_ebnf_compiler(compiler_name, self.grammar)
        parser = get_ebnf_grammar()
        result, errors, syntax_tree = compile_source(self.grammar, None, parser,
                                            get_ebnf_transformer(), compiler)
        return errors

    def test_multiprocessing(self):
        with Pool(processes=2) as pool:
            res = [pool.apply_async(self.multiprocessing_task, ()) for i in range(4)]
            errors = [r.get(timeout=5) for r in res]
        for i, e in enumerate(errors):
            assert not e, ("%i: " % i) + str(e)
304
305


306
if __name__ == "__main__":
307
    from run import runner
308
    runner("", globals())