Python convert_ebnf_grammar Examples

Example #1

 def mine_grammar(self):
     return convert_ebnf_grammar(self.mine_ebnf_grammar())

Example #2

 def grammar(self):
     return convert_ebnf_grammar(self._ebnf_grammar)

Example #3

File: ConfigurationFuzzer.py Project: wha000tif/fuzzingbook

    from Grammars import crange, srange, convert_ebnf_grammar, is_valid_grammar, START_SYMBOL, new_symbol
else:
    from .Grammars import crange, srange, convert_ebnf_grammar, is_valid_grammar, START_SYMBOL, new_symbol


PROCESS_NUMBERS_EBNF_GRAMMAR = {
    "<start>": ["<operator> <integers>"],
    "<operator>": ["--sum", "--min", "--max"],
    "<integers>": ["<integer>", "<integers> <integer>"],
    "<integer>": ["<digit>+"],
    "<digit>": crange('0', '9')
}

assert is_valid_grammar(PROCESS_NUMBERS_EBNF_GRAMMAR)

PROCESS_NUMBERS_GRAMMAR = convert_ebnf_grammar(PROCESS_NUMBERS_EBNF_GRAMMAR)

if __package__ is None or __package__ == "":
    from GrammarCoverageFuzzer import GrammarCoverageFuzzer
else:
    from .GrammarCoverageFuzzer import GrammarCoverageFuzzer


if __name__ == "__main__":
    f = GrammarCoverageFuzzer(PROCESS_NUMBERS_GRAMMAR, min_nonterminals=10)
    for i in range(3):
        print(f.fuzz())


if __name__ == "__main__":
    f = GrammarCoverageFuzzer(PROCESS_NUMBERS_GRAMMAR, min_nonterminals=10)

Example #4

    from Grammars import crange, srange, convert_ebnf_grammar, is_valid_grammar, START_SYMBOL, new_symbol
else:
    from .Grammars import crange, srange, convert_ebnf_grammar, is_valid_grammar, START_SYMBOL, new_symbol


PROCESS_NUMBERS_EBNF_GRAMMAR = {
    "<start>": ["<operator> <integers>"],
    "<operator>": ["--sum", "--min", "--max"],
    "<integers>": ["<integer>", "<integers> <integer>"],
    "<integer>": ["<digit>+"],
    "<digit>": crange('0', '9')
}

assert is_valid_grammar(PROCESS_NUMBERS_EBNF_GRAMMAR)

PROCESS_NUMBERS_GRAMMAR = convert_ebnf_grammar(PROCESS_NUMBERS_EBNF_GRAMMAR)

if __package__ is None or __package__ == "":
    from GrammarCoverageFuzzer import GrammarCoverageFuzzer
else:
    from .GrammarCoverageFuzzer import GrammarCoverageFuzzer


if __name__ == "__main__":
    f = GrammarCoverageFuzzer(PROCESS_NUMBERS_GRAMMAR, min_nonterminals=10)
    for i in range(3):
        print(f.fuzz())


if __name__ == "__main__":
    f = GrammarCoverageFuzzer(PROCESS_NUMBERS_GRAMMAR, min_nonterminals=10)

Example #5

if __package__ is None or __package__ == "":
    from ProbabilisticGrammarFuzzer import ProbabilisticGrammarFuzzer
else:
    from .ProbabilisticGrammarFuzzer import ProbabilisticGrammarFuzzer

INT_EBNF_GRAMMAR = {
    "<start>": ["<int>"],
    "<int>": ["<_int>"],
    "<_int>": ["(-)?<leaddigit><digit>*", "0"],
    "<leaddigit>": crange('1', '9'),
    "<digit>": crange('0', '9')
}

assert is_valid_grammar(INT_EBNF_GRAMMAR)

INT_GRAMMAR = convert_ebnf_grammar(INT_EBNF_GRAMMAR)
INT_GRAMMAR

if __name__ == "__main__":
    int_fuzzer = GrammarFuzzer(INT_GRAMMAR)
    print([int_fuzzer.fuzz() for i in range(10)])

if __package__ is None or __package__ == "":
    from Grammars import set_opts
else:
    from .Grammars import set_opts

import random


def int_grammar_with_range(start, end):

Example #6

File: GrammarCoverageFuzzer.py Project: engmux/fuzzingbook

if __package__ is None or __package__ == "":
    from Grammars import convert_ebnf_grammar, srange
else:
    from .Grammars import convert_ebnf_grammar, srange

LS_EBNF_GRAMMAR = {
    '<start>': ['-<options>'],
    '<options>': ['<option>*'],
    '<option>': srange("ABCFGHLOPRSTUW@abcdefghiklmnopqrstuwx1")
}

if __name__ == "__main__":
    assert is_valid_grammar(LS_EBNF_GRAMMAR)

LS_GRAMMAR = convert_ebnf_grammar(LS_EBNF_GRAMMAR)

if __package__ is None or __package__ == "":
    from Fuzzer import ProgramRunner
else:
    from .Fuzzer import ProgramRunner

if __name__ == "__main__":
    f = GrammarCoverageFuzzer(LS_GRAMMAR, max_nonterminals=3)
    while len(f.max_expansion_coverage() - f.expansion_coverage()) > 0:
        invocation = f.fuzz()
        print("ls", invocation, end="; ")
        args = invocation.split()
        ls = ProgramRunner(["ls"] + args)
        ls.run()
    print()

Example #7

File: GrammarFuzzer.py Project: hw-standalonecomplex/fuzzingbook

    print('# Efficient Grammar Fuzzing')

# ## An Insufficient Algorithm

if __name__ == "__main__":
    print('\n## An Insufficient Algorithm')

import fuzzingbook_utils

if __package__ is None or __package__ == "":
    from Grammars import EXPR_EBNF_GRAMMAR, convert_ebnf_grammar, simple_grammar_fuzzer, is_valid_grammar, exp_string, exp_opts
else:
    from .Grammars import EXPR_EBNF_GRAMMAR, convert_ebnf_grammar, simple_grammar_fuzzer, is_valid_grammar, exp_string, exp_opts

if __name__ == "__main__":
    expr_grammar = convert_ebnf_grammar(EXPR_EBNF_GRAMMAR)
    expr_grammar

if __package__ is None or __package__ == "":
    from ExpectError import ExpectTimeout
else:
    from .ExpectError import ExpectTimeout

if __name__ == "__main__":
    with ExpectTimeout(1):
        simple_grammar_fuzzer(grammar=expr_grammar, max_nonterminals=3)

if __name__ == "__main__":
    expr_grammar['<factor>']

if __package__ is None or __package__ == "":

Example #8

if __package__ is None or __package__ == "":
    from Grammars import START_SYMBOL, new_symbol
else:
    from .Grammars import START_SYMBOL, new_symbol

PROCESS_NUMBERS_EBNF_GRAMMAR = {
    "<start>": ["<operator> <integers>"],
    "<operator>": ["--sum", "--min", "--max"],
    "<integers>": ["<integer>", "<integers> <integer>"],
    "<integer>": ["<digit>+"],
    "<digit>": crange('0', '9')
}

assert is_valid_grammar(PROCESS_NUMBERS_EBNF_GRAMMAR)

PROCESS_NUMBERS_GRAMMAR = convert_ebnf_grammar(PROCESS_NUMBERS_EBNF_GRAMMAR)

if __package__ is None or __package__ == "":
    from GrammarCoverageFuzzer import GrammarCoverageFuzzer
else:
    from .GrammarCoverageFuzzer import GrammarCoverageFuzzer

if __name__ == "__main__":
    f = GrammarCoverageFuzzer(PROCESS_NUMBERS_GRAMMAR, min_nonterminals=10)
    for i in range(3):
        print(f.fuzz())

if __name__ == "__main__":
    f = GrammarCoverageFuzzer(PROCESS_NUMBERS_GRAMMAR, min_nonterminals=10)
    for i in range(3):
        args = f.fuzz().split()

Example #9

else:
    from .Grammars import is_valid_grammar, crange, convert_ebnf_grammar  # minor dependency

SUM2_EBNF_GRAMMAR = {
    "<start>": ["<sum2>"],
    "<sum2>": ["sum2(<int>, <int>)"],
    "<int>": ["<_int>"],
    "<_int>": ["(-)?<leaddigit><digit>*", "0"],
    "<leaddigit>": crange('1', '9'),
    "<digit>": crange('0', '9')
}

assert is_valid_grammar(SUM2_EBNF_GRAMMAR)

if __name__ == "__main__":
    sum2_grammar = convert_ebnf_grammar(SUM2_EBNF_GRAMMAR)

if __name__ == "__main__":
    sum2_fuzzer = GrammarFuzzer(sum2_grammar)
    [sum2_fuzzer.fuzz() for i in range(10)]

if __name__ == "__main__":
    with InvariantAnnotator() as annotator:
        for i in range(10):
            eval(sum2_fuzzer.fuzz())

    print_content(annotator.function_with_invariants('sum2'), '.py')

# ## Synopsis

if __name__ == "__main__":