From ae8c0be22fb3cf1740072e6a4e2707c61c8f11dc Mon Sep 17 00:00:00 2001
From: Bobby <30593201+luciferreeves@users.noreply.github.com>
Date: Fri, 2 Sep 2022 17:33:01 -0400
Subject: Added Extra Tests

---
 tests/test_builder.py | 423 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 423 insertions(+)

diff --git a/tests/test_builder.py b/tests/test_builder.py
index a48cdb5..4ba9a76 100644
--- a/tests/test_builder.py
+++ b/tests/test_builder.py
@@ -2,6 +2,48 @@ import re
 
 from edify import RegexBuilder
 
+simple_se = RegexBuilder().string('hello').any_char().string('world')
+flags_se = (
+    RegexBuilder()
+    .multi_line()
+    .ignore_case()
+    .string('hello')
+    .any_char()
+    .string('world')
+)
+start_end_se = (
+    RegexBuilder()
+    .start_of_input()
+    .string('hello')
+    .any_char()
+    .string('world')
+    .end_of_input()
+)
+nc_se = (
+    RegexBuilder()
+    .named_capture('module')
+    .exactly(2).any_char()
+    .end()
+    .named_back_reference('module')
+)
+indexed_back_reference_se = (
+    RegexBuilder()
+    .capture()
+    .exactly(2).any_char()
+    .end()
+    .back_reference(1)
+)
+nested_se = RegexBuilder().exactly(2).any_char()
+first_layer_se = (
+    RegexBuilder()
+    .string('outer begin')
+    .named_capture('inner_subexpression')
+    .optional()
+    .subexpression(nested_se)
+    .end()
+    .string('outer end')
+)
+
 
 def regex_equality(regex, rb_expression):
     regex_str = str(regex)
@@ -262,3 +304,384 @@ def test_back_reference():
     )
     regex_equality('/(hello\\ \\w!)\\1/', expr)
     regex_compilation('(hello\\ \\w!)\\1', expr)
+
+
+def test_back_reference_no_cg_exists():
+    try:
+        RegexBuilder().back_reference(1)
+    except Exception as e:
+        assert isinstance(e, Exception)
+
+
+def test_group():
+    expr = (
+        RegexBuilder()
+        .group()
+        .string('hello ')
+        .word()
+        .char('!')
+        .end()
+    )
+    regex_equality('/(?:hello\\ \\w!)/', expr)
+    regex_compilation('(?:hello\\ \\w!)', expr)
+
+
+def test_error_when_called_with_no_stack():
+    try:
+        RegexBuilder().end()
+    except Exception as e:
+        assert isinstance(e, Exception)
+
+def test_assert_ahead():
+    expr = (
+        RegexBuilder()
+        .assert_ahead()
+        .range('a', 'f')
+        .end()
+        .range('a', 'z')
+    )
+    regex_equality('/(?=[a-f])[a-z]/', expr)
+    regex_compilation('(?=[a-f])[a-z]', expr)
+
+
+def test_assert_behind():
+    expr = (
+        RegexBuilder()
+        .assert_behind()
+        .string('hello ')
+        .end()
+        .range('a', 'z')
+    )
+    regex_equality('/(?<=hello\\ )[a-z]/', expr)
+    regex_compilation('(?<=hello\\ )[a-z]', expr)
+
+
+def test_assert_not_ahead():
+    expr = (
+        RegexBuilder()
+        .assert_not_ahead()
+        .range('a', 'f')
+        .end()
+        .range('0', '9')
+    )
+    regex_equality('/(?![a-f])[0-9]/', expr)
+    regex_compilation('(?![a-f])[0-9]', expr)
+
+
+def test_assert_not_behind():
+    expr = (
+        RegexBuilder()
+        .assert_not_behind()
+        .string('hello ')
+        .end()
+        .range('a', 'z')
+    )
+    regex_equality('/(?<!hello\\ )[a-z]/', expr)
+    regex_compilation('(?<!hello\\ )[a-z]', expr)
+
+
+def test_optional():
+    expr = RegexBuilder().optional().word()
+    regex_equality('/\\w?/', expr)
+    regex_compilation('\\w?', expr)
+
+
+def test_zero_or_more():
+    expr = RegexBuilder().zero_or_more().word()
+    regex_equality('/\\w*/', expr)
+    regex_compilation('\\w*', expr)
+
+
+def test_zero_or_more_lazy():
+    expr = RegexBuilder().zero_or_more_lazy().word()
+    regex_equality('/\\w*?/', expr)
+    regex_compilation('\\w*?', expr)
+
+
+def test_one_or_more():
+    expr = RegexBuilder().one_or_more().word()
+    regex_equality('/\\w+/', expr)
+    regex_compilation('\\w+', expr)
+
+
+def test_one_or_more_lazy():
+    expr = RegexBuilder().one_or_more_lazy().word()
+    regex_equality('/\\w+?/', expr)
+    regex_compilation('\\w+?', expr)
+
+
+def test_exactly():
+    expr = RegexBuilder().exactly(3).word()
+    regex_equality('/\\w{3}/', expr)
+    regex_compilation('\\w{3}', expr)
+
+
+def test_at_least():
+    expr = RegexBuilder().at_least(3).word()
+    regex_equality('/\\w{3,}/', expr)
+    regex_compilation('\\w{3,}', expr)
+
+
+def test_between():
+    expr = RegexBuilder().between(3, 5).word()
+    regex_equality('/\\w{3,5}/', expr)
+    regex_compilation('\\w{3,5}', expr)
+
+
+def test_between_lazy():
+    expr = RegexBuilder().between_lazy(3, 5).word()
+    regex_equality('/\\w{3,5}?/', expr)
+    regex_compilation('\\w{3,5}?', expr)
+
+
+def test_start_of_input():
+    expr = RegexBuilder().start_of_input()
+    regex_equality('/^/', expr)
+    regex_compilation('^', expr)
+
+
+def test_end_of_input():
+    expr = RegexBuilder().end_of_input()
+    regex_equality('/$/', expr)
+    regex_compilation('$', expr)
+
+
+def test_any_of_chars():
+    expr = RegexBuilder().any_of_chars('aeiou.-')
+    regex_equality('/[aeiou\\.\\-]/', expr)
+    regex_compilation('[aeiou\\.\\-]', expr)
+
+
+def test_anything_but_chars():
+    expr = RegexBuilder().anything_but_chars('aeiou.-')
+    regex_equality('/[^aeiou\\.\\-]/', expr)
+    regex_compilation('[^aeiou\\.\\-]', expr)
+
+
+def test_anything_but_range():
+    expr = RegexBuilder().anything_but_range('a', 'z')
+    regex_equality('/[^a-z]/', expr)
+    regex_compilation('[^a-z]', expr)
+    expr = RegexBuilder().anything_but_range('0', '9')
+    regex_equality('/[^0-9]/', expr)
+    regex_compilation('[^0-9]', expr)
+
+
+def test_string():
+    expr = RegexBuilder().string('hello')
+    regex_equality('/hello/', expr)
+    regex_compilation('hello', expr)
+
+
+def test_string_escapes_special_chars_with_strings_of_len_1():
+    expr = RegexBuilder().string('^').string('hello')
+    regex_equality('/\\^hello/', expr)
+    regex_compilation('\\^hello', expr)
+
+
+def test_char():
+    expr = RegexBuilder().char('a')
+    regex_equality('/a/', expr)
+    regex_compilation('a', expr)
+
+
+def test_char_more_than_one_error():
+    try:
+        RegexBuilder().char('hello')
+    except Exception as e:
+        assert isinstance(e, Exception)
+
+
+def test_range():
+    expr = RegexBuilder().range('a', 'z')
+    regex_equality('/[a-z]/', expr)
+    regex_compilation('[a-z]', expr)
+
+
+def test_must_be_instance_error():
+    try:
+        RegexBuilder().subexpression('nope')
+    except Exception as e:
+        assert isinstance(e, Exception)
+
+
+def test_simple_se():
+    expr = (
+        RegexBuilder()
+        .start_of_input()
+        .at_least(3).digit()
+        .subexpression(simple_se)
+        .range('0', '9')
+        .end_of_input()
+    )
+    regex_equality('/^\\d{3,}hello.world[0-9]$/', expr)
+    regex_compilation('^\\d{3,}hello.world[0-9]$', expr)
+
+
+def test_simple_quantified_se():
+    expr = (
+        RegexBuilder()
+        .start_of_input()
+        .at_least(3).digit()
+        .one_or_more().subexpression(simple_se)
+        .range('0', '9')
+        .end_of_input()
+    )
+    regex_equality('/^\\d{3,}(?:hello.world)+[0-9]$/', expr)
+    regex_compilation('^\\d{3,}(?:hello.world)+[0-9]$', expr)
+
+
+def test_flags_se():
+    expr = (
+        RegexBuilder()
+        .dot_all()
+        .start_of_input()
+        .at_least(3).digit()
+        .subexpression(flags_se, {'ignore_flags': False})
+        .range('0', '9')
+        .end_of_input()
+    )
+    regex_equality('/^\\d{3,}hello.world[0-9]$/IMS', expr)
+    regex_compilation('^\\d{3,}hello.world[0-9]$', expr, f = re.M | re.I | re.S)
+
+
+def test_flags_se_ignore_flags():
+    expr = (
+        RegexBuilder()
+        .dot_all()
+        .start_of_input()
+        .at_least(3).digit()
+        .subexpression(flags_se)
+        .range('0', '9')
+        .end_of_input()
+    )
+    regex_equality('/^\\d{3,}hello.world[0-9]$/S', expr)
+    regex_compilation('^\\d{3,}hello.world[0-9]$', expr, f = re.S)
+
+
+def test_ignore_start_and_end():
+    expr = (
+        RegexBuilder()
+        .at_least(3).digit()
+        .subexpression(start_end_se)
+        .range('0', '9')
+    )
+    regex_equality('/\\d{3,}hello.world[0-9]/', expr)
+    regex_compilation('\\d{3,}hello.world[0-9]', expr)
+
+
+def test_dont_ignore_start_and_end():
+    try:
+        (
+            RegexBuilder()
+            .at_least(3).digit()
+            .subexpression(start_end_se, {'ignore_start_and_end': False})
+            .range('0', '9')
+        )
+    except Exception as e:
+        assert isinstance(e, Exception)
+
+def test_start_defined_in_me_and_se():
+    try:
+        (
+            RegexBuilder()
+            .start_of_input()
+            .at_least(3).digit()
+            .subexpression(start_end_se, {'ignore_start_and_end': False})
+            .range('0', '9')
+        )
+    except Exception as e:
+        assert isinstance(e, Exception)
+
+def test_end_defined_in_me_and_se():
+    try:
+        (
+            RegexBuilder()
+            .at_least(3).digit()
+            .subexpression(start_end_se, {'ignore_start_and_end': False})
+            .range('0', '9')
+            .end_of_input()
+        )
+    except Exception as e:
+        assert isinstance(e, Exception)
+
+
+def test_no_namespacing():
+    expr = (
+        RegexBuilder()
+        .at_least(3).digit()
+        .subexpression(nc_se)
+        .range('0', '9')
+    )
+    regex_equality('/\\d{3,}(?P<module>.{2})\\k<module>[0-9]/', expr)
+    try:
+        expr.to_regex()
+    except Exception as e:
+        assert isinstance(e, Exception)
+
+
+def test_namespacing():
+    expr = (
+        RegexBuilder()
+        .at_least(3).digit()
+        .subexpression(nc_se, {'namespace': 'yolo'})
+        .range('0', '9')
+    )
+    regex_equality('/\\d{3,}(?P<yolomodule>.{2})\\k<yolomodule>[0-9]/', expr)
+    try:
+        expr.to_regex()
+    except Exception as e:
+        assert isinstance(e, Exception)
+
+def test_group_name_collision_error():
+    try:
+        (
+            RegexBuilder()
+            .namedCapture('module')
+            .at_least(3).digit()
+            .end()
+            .subexpression(nc_se)
+            .range('0', '9')
+        )
+    except Exception as e:
+        assert isinstance(e, Exception)
+
+
+def test_group_name_collision_error_after_namespacing():
+    try:
+        (
+            RegexBuilder()
+            .namedCapture('module')
+            .at_least(3).digit()
+            .end()
+            .subexpression(nc_se, {'namespace': 'yolo'})
+            .range('0', '9')
+        )
+    except Exception as e:
+        assert isinstance(e, Exception)
+
+def test_indexed_back_referencing():
+    expr = (
+        RegexBuilder()
+        .capture()
+        .at_least(3).digit()
+        .end()
+        .subexpression(indexed_back_reference_se)
+        .back_reference(1)
+        .range('0', '9')
+    )
+    regex_equality('/(\\d{3,})(.{2})\\2\\1[0-9]/', expr)
+    regex_compilation('(\\d{3,})(.{2})\\2\\1[0-9]', expr)
+
+def test_deeply_nested_se():
+    expr = (
+        RegexBuilder()
+        .capture()
+        .at_least(3).digit()
+        .end()
+        .subexpression(first_layer_se)
+        .back_reference(1)
+        .range('0', '9')
+    )
+    regex_equality('/(\\d{3,})outer\\ begin(?P<inner_subexpression>(?:.{2})?)outer\\ end\\1[0-9]/', expr)
+    regex_compilation('(\\d{3,})outer\\ begin(?P<inner_subexpression>(?:.{2})?)outer\\ end\\1[0-9]', expr)
-- 
cgit v1.2.3