test_ebnf.py 11.5 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
24
25
26
import os
import sys
sys.path.append(os.path.abspath('../../'))
Eckhart Arnold's avatar
Eckhart Arnold committed
27
from DHParser.parsers import compile_source, Retrieve, WHITESPACE_KEYWORD, nil_scanner
28
from DHParser.ebnf import EBNFGrammar, EBNFTransform, EBNFCompiler
29
from DHParser.dsl import compileEBNF, compileDSL
30
31
32
33
34


WRITE_LOGS = True


35
36
37
38
39
40
41
42
43
44
45
46
47
48
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
        MinilangParser = compileEBNF(lang)
        parser = MinilangParser()
        assert parser
Eckhart Arnold's avatar
Eckhart Arnold committed
49
        syntax_tree = parser("3 + 4 * 12")
50
        # parser.log_parsing_history("WSP")
51
        assert not syntax_tree.collect_errors()
Eckhart Arnold's avatar
Eckhart Arnold committed
52
        syntax_tree = parser("3 + 4 \n * 12")
53
54
        # parser.log_parsing_history("WSPLF")
        assert not syntax_tree.collect_errors()
Eckhart Arnold's avatar
Eckhart Arnold committed
55
        syntax_tree = parser("3 + 4 \n \n * 12")
56
        assert syntax_tree.collect_errors()
Eckhart Arnold's avatar
Eckhart Arnold committed
57
        syntax_tree = parser("3 + 4 \n\n * 12")
58
59
60
61
62
63
        assert syntax_tree.collect_errors()

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

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

82

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

di68kap's avatar
di68kap committed
99

100
101
102
103
104
    def setup(self):
        self.EBNF = EBNFGrammar()

    def test_literal(self):
        snippet = '"literal" '
Eckhart Arnold's avatar
Eckhart Arnold committed
105
        result = self.EBNF(snippet, 'literal')
106
107
108
109
        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
110
        result = self.EBNF(' "literal"', 'literal')
111
112
113
        assert result.error_flag  # literals catch following, but not leading whitespace


di68kap's avatar
di68kap committed
114
115


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

    def setup(self):
        self.minilang_parser = compileEBNF(self.mini_language)()
136
        self.minilang_parser2 = compileEBNF(self.mini_lang2)()
137

138
139
140
141
142
143
144
145
    @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)

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

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

    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
169
        syntax_tree = self.minilang_parser(teststr)
170
        assert not syntax_tree.collect_errors()
171
172
        delim = str(next(syntax_tree.find(partial(self.opening_delimiter, name="delimiter"))))
        pop = str(next(syntax_tree.find(self.closing_delimiter)))
173
        assert delim == pop
174
175
        if WRITE_LOGS:
            syntax_tree.log("test_PopRetrieve_multi_line", '.cst')
176
177
178

    def test_single_line_complement(self):
        teststr = "Anfang {{{code block }} <- keine Ende-Zeichen ! }}} Ende"
Eckhart Arnold's avatar
Eckhart Arnold committed
179
        syntax_tree = self.minilang_parser2(teststr)
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
        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
        if WRITE_LOGS:
            syntax_tree.log("test_PopRetrieve_single_line", '.cst')

    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
196
        syntax_tree = self.minilang_parser2(teststr)
197
198
199
200
201
202
        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
        if WRITE_LOGS:
            syntax_tree.log("test_PopRetrieve_multi_line", '.cst')
203
204


205
206
207
class TestSemanticValidation:
    def check(self, minilang, bool_filter=lambda x: x):
        grammar = EBNFGrammar()
Eckhart Arnold's avatar
Eckhart Arnold committed
208
        st = grammar(minilang)
209
        assert not st.collect_errors()
210
        EBNFTransform(st)
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
        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):
228
        ebnf = "@ literalws = wrongvalue  # testing error propagation\n"
Eckhart Arnold's avatar
Eckhart Arnold committed
229
230
        result, messages, st = compile_source(ebnf, None, EBNFGrammar(),
            EBNFTransform, EBNFCompiler('ErrorPropagationTest'))
231
232
233
        assert messages


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
279
280
281
282
class TestSelfHosting:
    def test_self(self):
        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 =  !/./        
            """
        compiler_name = "EBNF"
        compiler = EBNFCompiler(compiler_name, grammar)
        parser = EBNFGrammar()
Eckhart Arnold's avatar
Eckhart Arnold committed
283
284
        result, errors, syntax_tree = compile_source(grammar, None, parser,
                                                     EBNFTransform, compiler)
285
286
287
288
289
290
291
        assert not errors, str(errors)
        # compile the grammar again using the result of the previous
        # compilation as parser
        compileDSL(grammar, nil_scanner, result, EBNFTransform, compiler)



292
if __name__ == "__main__":
293
    from run import runner
294
    runner("", globals())