def test_self_deep_cycle_nonlazy(self):
with self.assertRaises(ValueError):
env = ModExpEnv()
ModExp(r'\d', 'a', env)
ModExp(r'~<a>', 'b', env)
ModExp(r'~<b>', 'c', env)
ModExp(r'~<c>', 'd', env)
ModExp(r'~<d>', 'a', env)
def setUp(self):
env = ModExpEnv()
self.natural = ModExp(r'\d+', 'natural', env)
self.operator = ModExp(r'\+|-|\/|\*', 'operator', env)
self.expr = ModExp(r'~<natural>\s?~<operator>\s?~<natural>', 'expr',
env)
self.complex_expr = ModExp(r'\(~<expr>\)\s?~<operator>\s?\(~<expr>\)',
'complex_expr', env)
def setUp(self):
env1 = ModExpEnv()
self.segment1 = ModExp(r'\d{3}', 'segment', env1)
self.long_segment1 = ModExp(r'\d{4}', 'long_segment', env1)
self.delimiter1 = ModExp(r'\-|\.|\s', 'delimiter', env1)
self.entity1 = ModExp(
r'~<segment>~<delimiter>~<segment>~<delimiter>~<long_segment>',
'entity', env1)
env2 = ModExpEnv()
self.segment2 = ModExp(r'[A-Za-z0-9\.]+', 'segment', env2)
self.long_segment2 = ModExp(
r'[A-Za-z0-9\.]*[A-Za-z0-9]\.(com|edu|org|net)', 'long_segment',
env2)
self.delimiter2 = ModExp(r'@', 'delimiter', env2)
self.entity2 = ModExp(r'~<segment>~<delimiter>~<long_segment>',
'entity', env2)
def test_self_deep_cycle_lazy(self):
with self.assertRaises(ValueError):
env = ModExpEnv(lazy=True)
ModExp(r'\d', 'a', env)
ModExp(r'~<a>', 'b', env)
ModExp(r'~<b>', 'c', env)
ModExp(r'~<c>', 'd', env)
a = ModExp(r'~<d>', 'a', env)
a.regex()
def test_nonlazy_eval(self):
with self.assertRaises(KeyError):
env = ModExpEnv()
complex_expr = ModExp(r'\(~<expr>\)\s?~<operator>\s?\(~<expr>\)',
'complex_expr', env)
expr = ModExp(r'~<natural>\s?~<operator>\s?~<natural>', 'expr',
env)
natural = ModExp(r'\d+', 'natural', env)
operator = ModExp(r'\+|-|\/|\*', 'operator', env)
def test_lazy_eval(self):
try:
env = ModExpEnv(lazy=True)
complex_expr = ModExp(r'\(~<expr>\)\s?~<operator>\s?\(~<expr>\)',
'complex_expr', env)
expr = ModExp(r'~<natural>\s?~<operator>\s?~<natural>', 'expr',
env)
natural = ModExp(r'\d+', 'natural', env)
operator = ModExp(r'\+|-|\/|\*', 'operator', env)
self.assertIsNone(env._expressions['complex_expr']._compiled_regex)
self.assertIsNone(env._expressions['expr']._compiled_regex)
self.assertIsNone(env._expressions['natural']._compiled_regex)
self.assertIsNone(env._expressions['operator']._compiled_regex)
complex_expr.regex()
except KeyError:
self.fail('Lazy evaluation raised KeyError unexpectedly.')
def setUp(self):
env = ModExpEnv()
self.natural = ModExp(r'\d+', 'natural', env)
self.positive_rational = ModExp(r'~<natural>\.~<natural>',
'positive_rational', env)
def setUp(self):
env = ModExpEnv()
self.natural = ModExp(r'\d+', 'natural', env)
self.integer = ModExp(r'-?\d+', 'integer', env)
self.rational = ModExp(r'~<integer>\.~<natural>', 'rational', env)
def test_self_cycle_lazy(self):
with self.assertRaises(ValueError):
env = ModExpEnv(lazy=True)
expr = ModExp(r'~<expr>', 'expr', env)
expr.regex()
def test_self_cycle_nonlazy(self):
with self.assertRaises(ValueError):
env = ModExpEnv()
ModExp(r'-?\d+(\.\d+)?', 'expr', env)
ModExp(r'~<expr>', 'expr', env)
def test_2_cycle_lazy(self):
with self.assertRaises(ValueError):
env = ModExpEnv(lazy=True)
ModExp(r'~<expr2>', 'expr1', env)
expr2 = ModExp(r'~<expr1>', 'expr2', env)
expr2.regex()
def test_2_cycle_nonlazy(self):
with self.assertRaises(ValueError):
env = ModExpEnv()
ModExp(r'-?\d+(\.\d+)?', 'expr', env)
ModExp(r'~<expr>\+~<expr>', 'complex_expr', env)
ModExp(r'(-?\d+(\.\d+)?)|~<complex_expr>', 'expr', env)
def setUp(self):
env = ModExpEnv()
self.number = ModExp(r'-?\d+(\.\d+)?', 'number', env)
self.operator = ModExp(r'\+|-|\/|\*', 'operator', env)
self.expr = ModExp(r'~<number>\s?~<operator>\s?~<number>', 'expr', env)
self.number = ModExp(r'\d+', 'number', env)