def test_empty_alternation_in_root(self):
# special case because linenum is bogus on root.
r = Regex.get_parse_tree(r"a|")
print("\n".join(fmttree(r)))
errs = []
check_no_empty_alternations(r, errs)
self.assertEqual(len(errs), 1)
def test_out_of_order_crazy_complicated(self):
r = Regex.get_parse_tree(r'''(!=|#|&&|&|\(|\)|\*|\+|,|-|-\.)''')
#|->|\.|\.\.|::|:=|:>|:|;;|;|<|<-|=|>|>]|>}|\?|\?\?|\[|\[<|\[>|\[\||]|_|`|{|{<|\||\|]|}|~)''')
print '\n'.join(fmttree(r))
errs = []
check_prefix_ordering(r, errs)
self.assertEquals(len(errs), 1)
def test_bygroups_check_overlap_descending2(self):
r = Regex.get_parse_tree(r"(?:^|xx)(foo)")
print("\n".join(fmttree(r)))
errs = []
bygroups_check_overlap(r, errs, (Text, ))
print(errs)
self.assertEqual(len(errs), 1)
def test_bygroups_check_overlap_lookaround_ok(self):
r = Regex.get_parse_tree(r'(?<!\.)(Class|Structure|Enum)(\s+)')
print '\n'.join(fmttree(r))
errs = []
bygroups_check_overlap(r, errs, (Text, Text))
print errs
self.assertEquals(len(errs), 0)
def test_charclass_parsing(self):
r = Regex.get_parse_tree(r'[ a]')
l = list(find_all(r))[1:] # skip root
print '\n'.join(fmttree(r))
self.assertEquals(3, len(l))
self.assertEquals(r' ', l[1].data)
self.assertEquals(r'a', l[2].data)
def test_out_of_order_alternation_with_anchor_after(self):
r = Regex.get_parse_tree(r'(a|ab)\b')
print '\n'.join(fmttree(r))
errs = []
check_prefix_ordering(r, errs)
print errs
self.assertEquals(len(errs), 0)
def test_escaped_space_parsing(self):
r = Regex.get_parse_tree(r'\ a')
l = list(find_all(r))[1:] # skip root
print '\n'.join(fmttree(r))
self.assertEquals(2, len(l))
self.assertEquals(r'\ ', l[0].data)
self.assertEquals(Other.Suspicious, l[0].type)
def test_bygroups_check_overlap_fail(self):
r = Regex.get_parse_tree(r'z(a)?z(b)z')
print('\n'.join(fmttree(r)))
errs = []
bygroups_check_overlap(r, errs, (Text, Text))
print(errs)
self.assertEqual(len(errs), 3)
def test_charclass_parsing(self):
r = Regex.get_parse_tree(r'[ a]')
l = list(find_all(r))[1:] # skip root
print('\n'.join(fmttree(r)))
self.assertEqual(3, len(l))
self.assertEqual(r' ', l[1].data)
self.assertEqual(r'a', l[2].data)
def test_bygroups_check_overlap_descending(self):
r = Regex.get_parse_tree(r'(?:^|\b)(foo)')
print('\n'.join(fmttree(r)))
errs = []
bygroups_check_overlap(r, errs, (Text, ))
print(errs)
self.assertEqual(len(errs), 0)
def test_bygroups_check_overlap_fail(self):
r = Regex.get_parse_tree(r'z(a)?z(b)z')
print('\n'.join(fmttree(r)))
errs = []
bygroups_check_overlap(r, errs, (Text, Text))
print(errs)
self.assertEqual(len(errs), 3)
def test_escaped_space_parsing(self):
r = Regex.get_parse_tree(r'\ a')
l = list(find_all(r))[1:] # skip root
print('\n'.join(fmttree(r)))
self.assertEqual(2, len(l))
self.assertEqual(r'\ ', l[0].data)
self.assertEqual(Other.Suspicious, l[0].type)
def test_bygroups_check_overlap_descending_with_capture_and_gap(self):
r = Regex.get_parse_tree(r'(?:([A-Za-z_][A-Za-z0-9_]*)x(\.))?([A-Za-z_][A-Za-z0-9_]*)')
print '\n'.join(fmttree(r))
errs = []
bygroups_check_overlap(r, errs, (Text, Text, Text))
print errs
self.assertEquals(len(errs), 1)
def test_capture_group_in_repetition(self):
r = Regex.get_parse_tree(r'(a)+((b)|c)*')
print '\n'.join(fmttree(r))
errs = []
bygroups_check_no_capture_group_in_repetition(r, errs, (Text, Text))
print errs
self.assertEquals(len(errs), 3)
def test_bygroups_check_overlap_but_none_for_token(self):
r = Regex.get_parse_tree(r"(<(%)?)(\w+)((?(2)%)>)")
print("\n".join(fmttree(r)))
errs = []
bygroups_check_overlap(r, errs, (Punctuation, None, Name, Punctuation))
print(errs)
self.assertEqual(len(errs), 0)
def test_bygroups_check_overlap_lookaround_ok(self):
r = Regex.get_parse_tree(r"(?<!\.)(Class|Structure|Enum)(\s+)")
print("\n".join(fmttree(r)))
errs = []
bygroups_check_overlap(r, errs, (Text, Text))
print(errs)
self.assertEqual(len(errs), 0)
def test_bygroups_check_overlap_descending(self):
r = Regex.get_parse_tree(r'(?:^|xx)(foo)')
print '\n'.join(fmttree(r))
errs = []
bygroups_check_overlap(r, errs, (Text,))
print errs
self.assertEquals(len(errs), 1)
def test_bygroups_check_overlap_fail2(self):
r = Regex.get_parse_tree(r"\b(a)$")
print("\n".join(fmttree(r)))
errs = []
bygroups_check_overlap(r, errs, (Text, ))
print(errs)
self.assertEqual(len(errs), 0)
def test_bygroups_check_overlap_fail2(self):
r = Regex.get_parse_tree(r'\b(a)$')
print '\n'.join(fmttree(r))
errs = []
bygroups_check_overlap(r, errs, (Text,))
print errs
self.assertEquals(len(errs), 0)
def test_charclass_parsing(self):
r = Regex.get_parse_tree(r"[ a]")
l = list(find_all(r))[1:] # skip root
print("\n".join(fmttree(r)))
self.assertEqual(3, len(l))
self.assertEqual(r" ", l[1].data)
self.assertEqual(r"a", l[2].data)
def test_empty_alternation_in_root(self):
# special case because linenum is bogus on root.
r = Regex.get_parse_tree(r'a|')
print '\n'.join(fmttree(r))
errs = []
check_no_empty_alternations(r, errs)
self.assertEquals(len(errs), 1)
def test_out_of_order_crazy_complicated(self):
r = Regex.get_parse_tree(r"""(!=|#|&&|&|\(|\)|\*|\+|,|-|-\.)""")
# |->|\.|\.\.|::|:=|:>|:|;;|;|<|<-|=|>|>]|>}|\?|\?\?|\[|\[<|\[>|\[\||]|_|`|{|{<|\||\|]|}|~)''')
print("\n".join(fmttree(r)))
errs = []
check_prefix_ordering(r, errs)
self.assertEqual(len(errs), 1)
def test_out_of_order_alternation_with_anchor_after(self):
r = Regex.get_parse_tree(r"(a|ab)\b")
print("\n".join(fmttree(r)))
errs = []
check_prefix_ordering(r, errs)
print(errs)
self.assertEqual(len(errs), 0)
def test_capture_group_in_repetition(self):
r = Regex.get_parse_tree(r"(a)+((b)|c)*")
print("\n".join(fmttree(r)))
errs = []
bygroups_check_no_capture_group_in_repetition(r, errs, (Text, Text))
print(errs)
self.assertEqual(len(errs), 3)
def test_bygroups_check_overlap_but_none_for_token(self):
r = Regex.get_parse_tree(r'(<(%)?)(\w+)((?(2)%)>)')
print '\n'.join(fmttree(r))
errs = []
bygroups_check_overlap(r, errs, (Punctuation, None, Name, Punctuation))
print errs
self.assertEquals(len(errs), 0)
def test_bygroups_check_overlap_nested_length2(self):
r = Regex.get_parse_tree(r"\b(a)((b)c)$")
print("\n".join(fmttree(r)))
errs = []
bygroups_check_overlap(r, errs, (Text, Text, Text))
print(errs)
self.assertEqual(len(errs), 1)
self.assertEqual(errs[0][1], logging.ERROR)
def test_bygroups_check_overlap_nested_length(self):
r = Regex.get_parse_tree(r'\b(a)((b)c)$')
print('\n'.join(fmttree(r)))
errs = []
bygroups_check_overlap(r, errs, (Text, Text))
print(errs)
self.assertEquals(len(errs), 1)
self.assertEquals(errs[0][1], logging.INFO)
def test_out_of_order_alternation_location(self):
r = Regex.get_parse_tree(r"(foo|bar|@|@@)")
print("\n".join(fmttree(r)))
errs = []
check_prefix_ordering(r, errs)
self.assertEqual(len(errs), 1)
# location of the second one.
self.assertEqual(errs[0][2], 11)
def test_no_capture_group_in_repetition(self):
# '?' is special-cased as being an okay repetition.
r = Regex.get_parse_tree(r"(a)?(b)")
print("\n".join(fmttree(r)))
errs = []
bygroups_check_no_capture_group_in_repetition(r, errs, (Text, Text))
print(errs)
self.assertEqual(len(errs), 0)
def test_bygroups_check_overlap_descending_with_capture(self):
r = Regex.get_parse_tree(
r'(?:([A-Za-z_][A-Za-z0-9_]*)(\.))?([A-Za-z_][A-Za-z0-9_]*)')
print('\n'.join(fmttree(r)))
errs = []
bygroups_check_overlap(r, errs, (Text, Text, Text))
print(errs)
self.assertEqual(len(errs), 0)
def test_bad_charclass3(self):
r = Regex.get_parse_tree(r"[\010-\020]")
print("\n".join(fmttree(r)))
print(r.children[0].chars)
errs = []
check_charclass_homogeneous_ranges(r, errs)
print(errs)
self.assertEqual(len(errs), 1)
def test_bad_charclass(self):
r = Regex.get_parse_tree(r'[A-z]')
print('\n'.join(fmttree(r)))
print(r.children[0].chars)
errs = []
check_charclass_homogeneous_ranges(r, errs)
print(errs)
self.assertEqual(len(errs), 1)
def test_good_unicode_charclass(self):
r = Regex.get_parse_tree(u"[\u1000-\uffff]")
print("\n".join(fmttree(r)))
print(r.children[0].chars)
errs = []
check_charclass_homogeneous_ranges(r, errs)
print(errs)
self.assertEqual(len(errs), 0)
def test_bygroups_check_overlap_descending_with_capture_and_gap(self):
r = Regex.get_parse_tree(
r"(?:([A-Za-z_][A-Za-z0-9_]*)x(\.))?([A-Za-z_][A-Za-z0-9_]*)")
print("\n".join(fmttree(r)))
errs = []
bygroups_check_overlap(r, errs, (Text, Text, Text))
print(errs)
self.assertEqual(len(errs), 1)
def test_bad_charclass(self):
r = Regex.get_parse_tree(r'[A-z]')
print('\n'.join(fmttree(r)))
print(r.children[0].chars)
errs = []
check_charclass_homogeneous_ranges(r, errs)
print(errs)
self.assertEqual(len(errs), 1)
def test_no_capture_group_in_repetition(self):
# '?' is special-cased as being an okay repetition.
r = Regex.get_parse_tree(r'(a)?(b)')
print '\n'.join(fmttree(r))
errs = []
bygroups_check_no_capture_group_in_repetition(r, errs, (Text, Text))
print errs
self.assertEquals(len(errs), 0)
def test_bygroups_check_overlap_nested_length2(self):
r = Regex.get_parse_tree(r'\b(a)((b)c)$')
print '\n'.join(fmttree(r))
errs = []
bygroups_check_overlap(r, errs, (Text, Text, Text))
print errs
self.assertEquals(len(errs), 1)
self.assertEquals(errs[0][1], logging.ERROR)
def test_good_unicode_charclass(self):
r = Regex.get_parse_tree(ur'[\u1000-\uffff]')
print '\n'.join(fmttree(r))
print r.children[0].chars
errs = []
check_charclass_homogeneous_ranges(r, errs)
print errs
self.assertEquals(len(errs), 0)
def test_bad_charclass3(self):
r = Regex.get_parse_tree(r'[\010-\020]')
print '\n'.join(fmttree(r))
print r.children[0].chars
errs = []
check_charclass_homogeneous_ranges(r, errs)
print errs
self.assertEquals(len(errs), 1)
def test_out_of_order_alternation_location(self):
r = Regex.get_parse_tree(r'(foo|bar|@|@@)')
print '\n'.join(fmttree(r))
errs = []
check_prefix_ordering(r, errs)
self.assertEquals(len(errs), 1)
# location of the second one.
self.assertEquals(errs[0][2], 11)
def test_repetition_curly1(self):
r = Regex.get_parse_tree(r'x{5,5}?')
print '\n'.join(fmttree(r))
l = list(find_all(r))[1:] # skip root
self.assertEquals(2, len(l))
# l[0] is Repetition, l[1] is Literal(x)
self.assertEquals(5, l[0].min)
self.assertEquals(5, l[0].max)
self.assertEquals(False, l[0].greedy)
def test_repetition_curly1(self):
r = Regex.get_parse_tree(r'x{5,5}?')
print('\n'.join(fmttree(r)))
l = list(find_all(r))[1:] # skip root
self.assertEqual(2, len(l))
# l[0] is Repetition, l[1] is Literal(x)
self.assertEqual(5, l[0].min)
self.assertEqual(5, l[0].max)
self.assertEqual(False, l[0].greedy)
def test_basic_verbose_parsing(self):
r = Regex.get_parse_tree(r'''(?x) a b # comment
c
d''')
l = list(find_all(r))[1:] # skip root
print '\n'.join(fmttree(r))
self.assertEquals(5, len(l))
self.assertEquals((4, 6), (l[1].parsed_start, l[1].start))
self.assertEquals('d', l[-1].data)
self.assertEquals((7, 72), (l[-1].parsed_start, l[-1].start))
def test_basic_verbose_parsing(self):
r = Regex.get_parse_tree(r'''(?x) a b # comment
c
d''')
l = list(find_all(r))[1:] # skip root
print('\n'.join(fmttree(r)))
self.assertEqual(5, len(l))
self.assertEqual((4, 6), (l[1].parsed_start, l[1].start))
self.assertEqual('d', l[-1].data)
self.assertEqual((7, 72), (l[-1].parsed_start, l[-1].start))
def test_dash_begins_charclass(self):
r = Regex.get_parse_tree(r'[-_]')
print('\n'.join(fmttree(r)))
print(r.children[0].chars)
errs = []
check_charclass_homogeneous_ranges(r, errs)
print(errs)
self.assertEqual(len(errs), 0)
self.assertEqual(len(r.children[0].chars), 2)
self.assertEqual(r.children[0].chars[0].data, '-')
self.assertEqual(r.children[0].chars[1].data, '_')
def test_dash_ends_charclass(self):
r = Regex.get_parse_tree(r"[_-]")
print("\n".join(fmttree(r)))
print(r.children[0].chars)
errs = []
check_charclass_homogeneous_ranges(r, errs)
print(errs)
self.assertEqual(len(errs), 0)
self.assertEqual(len(r.children[0].chars), 2)
self.assertEqual(r.children[0].chars[0].data, "_")
self.assertEqual(r.children[0].chars[1].data, "-")
def test_dash_ends_charclass(self):
r = Regex.get_parse_tree(r'[_-]')
print '\n'.join(fmttree(r))
print r.children[0].chars
errs = []
check_charclass_homogeneous_ranges(r, errs)
print errs
self.assertEquals(len(errs), 0)
self.assertEquals(len(r.children[0].chars), 2)
self.assertEquals(r.children[0].chars[0].data, '_')
self.assertEquals(r.children[0].chars[1].data, '-')
def test_dash_after_range_charclass(self):
r = Regex.get_parse_tree(r"[0-9-_]")
print("\n".join(fmttree(r)))
print(r.children[0].chars)
errs = []
check_charclass_homogeneous_ranges(r, errs)
print(errs)
self.assertEqual(len(errs), 0)
self.assertEqual(len(r.children[0].chars), 3)
self.assertEqual(r.children[0].chars[0].a.data, "0")
self.assertEqual(r.children[0].chars[0].b.data, "9")
self.assertEqual(r.children[0].chars[1].data, "-")
self.assertEqual(r.children[0].chars[2].data, "_")
def test_dash_after_range_charclass(self):
r = Regex.get_parse_tree(r'[0-9-_]')
print '\n'.join(fmttree(r))
print r.children[0].chars
errs = []
check_charclass_homogeneous_ranges(r, errs)
print errs
self.assertEquals(len(errs), 0)
self.assertEquals(len(r.children[0].chars), 3)
self.assertEquals(r.children[0].chars[0].a.data, '0')
self.assertEquals(r.children[0].chars[0].b.data, '9')
self.assertEquals(r.children[0].chars[1].data, '-')
self.assertEquals(r.children[0].chars[2].data, '_')
def test_dash_after_range_charclass(self):
r = Regex.get_parse_tree(r'[0-9-_]')
print('\n'.join(fmttree(r)))
print(r.children[0].chars)
errs = []
check_charclass_homogeneous_ranges(r, errs)
print(errs)
self.assertEquals(len(errs), 0)
self.assertEquals(len(r.children[0].chars), 3)
self.assertEquals(r.children[0].chars[0].a.data, '0')
self.assertEquals(r.children[0].chars[0].b.data, '9')
self.assertEquals(r.children[0].chars[1].data, '-')
self.assertEquals(r.children[0].chars[2].data, '_')
def test_out_of_order_alternation_longer(self):
r = Regex.get_parse_tree(r"(a|ab|c)")
print("\n".join(fmttree(r)))
errs = []
check_prefix_ordering(r, errs)
self.assertEqual(len(errs), 1)
def test_complex_charclass(Self):
r = Regex.get_parse_tree(r'[]\[:_@\".{}()|;,]')
l = list(find_all(r))[1:] # skip root
print('\n'.join(fmttree(r)))
def test_complex_charclass(Self):
r = Regex.get_parse_tree(r'[]\[:_@\".{}()|;,]')
l = list(find_all(r))[1:] # skip root
print '\n'.join(fmttree(r))
def test_good_charclass_hex(self):
r = Regex.get_parse_tree(r'[\x00-\xff]')
print '\n'.join(fmttree(r))
errs = []
check_charclass_homogeneous_ranges(r, errs)
self.assertEquals(len(errs), 0)
def test_out_of_order_alternation_longer(self):
r = Regex.get_parse_tree(r'(a|ab|c)')
print '\n'.join(fmttree(r))
errs = []
check_prefix_ordering(r, errs)
self.assertEquals(len(errs), 1)
def test_empty_alternation(self):
r = Regex.get_parse_tree(r'(a|)')
print '\n'.join(fmttree(r))
errs = []
check_no_empty_alternations(r, errs)
self.assertEquals(len(errs), 1)
def test_no_python_named_capture_groups(self):
r = Regex.get_parse_tree(r'(x)')
print '\n'.join(fmttree(r))
errs = []
check_no_python_named_capture_groups(r, errs)
self.assertEquals(len(errs), 0)
def test_run_all_checkers_errors(self):
r = Regex.get_parse_tree(r'(?P<name>x|)')
print '\n'.join(fmttree(r))
errs = run_all_checkers(r)
self.assertEquals(len(errs), 2)
def test_run_all_checkers_curly(self):
r = Regex.get_parse_tree(r'{')
print '\n'.join(fmttree(r))
errs = run_all_checkers(r)
print errs
self.assertEquals(len(errs), 1)
def test_bygroups_check_overlap_success(self):
r = Regex.get_parse_tree(r'(a)?(b)')
print '\n'.join(fmttree(r))
errs = []
bygroups_check_overlap(r, errs, (Text, Text))
self.assertEquals(len(errs), 0)
