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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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))