Add remaining source files and tests

tests/test_generator.py

@@ -0,0 +1,224 @@
+"""Tests for the test case generator."""
+
+import re
+import pytest
+from regex_humanizer.test_generator import (
+    TestCaseGenerator,
+    generate_test_cases,
+)
+
+
+class TestTestCaseGenerator:
+    """Test cases for TestCaseGenerator."""
+
+    def test_generate_simple_literal(self):
+        """Test generating test cases for a simple literal."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("hello", count=3)
+
+        assert len(matching) >= 1
+        assert "hello" in matching or len(matching[0]) > 0
+
+    def test_generate_character_class(self):
+        """Test generating test cases for a character class."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("[abc]", count=3)
+
+        assert len(matching) >= 1
+        assert len(matching[0]) == 1
+        assert matching[0] in ["a", "b", "c"]
+
+    def test_generate_quantifier_plus(self):
+        """Test generating test cases for plus quantifier."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("a+", count=3)
+
+        assert len(matching) >= 1
+        assert "a" in matching[0]
+
+    def test_generate_quantifier_star(self):
+        """Test generating test cases for star quantifier."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("b*", count=3)
+
+        assert len(matching) >= 1
+        assert all("b" in m for m in matching)
+
+    def test_generate_quantifier_question(self):
+        """Test generating test cases for question quantifier."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("c?", count=3)
+
+        assert len(matching) >= 1
+        assert len(matching[0]) <= 1
+
+    def test_generate_digit_class(self):
+        """Test generating test cases for digit class."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("\\d+", count=3)
+
+        assert len(matching) >= 1
+        assert matching[0].isdigit()
+
+    def test_generate_word_class(self):
+        """Test generating test cases for word class."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("\\w+", count=3)
+
+        assert len(matching) >= 1
+
+    def test_generate_non_matching_simple(self):
+        """Test generating non-matching test cases."""
+        generator = TestCaseGenerator("pcre")
+        non_matching = generator.generate_non_matching("hello", count=3)
+
+        assert len(non_matching) >= 1
+        pattern = re.compile("hello")
+        for test_str in non_matching:
+            assert pattern.search(test_str) is None
+
+    def test_generate_non_matching_character_class(self):
+        """Test generating non-matching cases for character class."""
+        generator = TestCaseGenerator("pcre")
+        non_matching = generator.generate_non_matching("[abc]", count=3)
+
+        assert len(non_matching) >= 1
+        for test_str in non_matching:
+            if len(test_str) > 0:
+                assert test_str[0] not in ["a", "b", "c"]
+
+    def test_generate_phone_pattern(self):
+        """Test generating test cases for phone pattern."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("\\d{3}-\\d{4}", count=3)
+
+        assert len(matching) >= 1
+        assert "-" in matching[0]
+        parts = matching[0].split("-")
+        assert len(parts) == 2
+        assert len(parts[0]) == 3
+        assert len(parts[1]) == 4
+
+    def test_generate_with_flavor_js(self):
+        """Test generating test cases with JavaScript flavor."""
+        generator = TestCaseGenerator("javascript")
+        matching = generator.generate_matching("test", count=2)
+
+        assert len(matching) >= 1
+
+    def test_generate_with_flavor_python(self):
+        """Test generating test cases with Python flavor."""
+        generator = TestCaseGenerator("python")
+        matching = generator.generate_matching("test", count=2)
+
+        assert len(matching) >= 1
+
+    def test_generate_matching_count(self):
+        """Test that correct number of matching cases are generated."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("a", count=10)
+
+        assert len(matching) <= 10
+
+    def test_generate_non_matching_count(self):
+        """Test that correct number of non-matching cases are generated."""
+        generator = TestCaseGenerator("pcre")
+        non_matching = generator.generate_non_matching("a", count=10)
+
+        assert len(non_matching) <= 10
+
+    def test_generate_complex_pattern(self):
+        """Test generating test cases for a complex pattern."""
+        pattern = r"^(?:http|https)://[\\w.-]+\\.(?:com|org|net)$"
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching(pattern, count=3)
+
+        assert len(matching) >= 1
+
+    def test_generate_test_cases_function(self):
+        """Test the generate_test_cases convenience function."""
+        result = generate_test_cases("test", flavor="pcre", matching_count=2, non_matching_count=2)
+
+        assert "pattern" in result
+        assert "flavor" in result
+        assert "matching" in result
+        assert "non_matching" in result
+        assert len(result["matching"]) >= 1
+        assert len(result["non_matching"]) >= 1
+
+    def test_generate_group_pattern(self):
+        """Test generating test cases for a pattern with groups."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("(hello)\\s+(world)", count=3)
+
+        assert len(matching) >= 1
+        assert " " in matching[0] or len(matching[0]) > 5
+
+    def test_generate_alternation(self):
+        """Test generating test cases for alternation."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("cat|dog", count=3)
+
+        assert len(matching) >= 1
+        assert matching[0] in ["cat", "dog"]
+
+    def test_generate_empty_pattern(self):
+        """Test generating test cases for an empty pattern."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("", count=3)
+
+        assert len(matching) >= 0
+
+    def test_generate_anchored_pattern(self):
+        """Test generating test cases for anchored patterns."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("^start", count=3)
+
+        assert len(matching) >= 1
+        assert matching[0].startswith("start")
+
+    def test_generate_dotted_pattern(self):
+        """Test generating test cases for a pattern with dots."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("a.b", count=3)
+
+        assert len(matching) >= 1
+        assert len(matching[0]) == 3
+        assert matching[0][0] == "a"
+        assert matching[0][1] != "."
+
+
+class TestTestCaseGeneratorEdgeCases:
+    """Test edge cases for TestCaseGenerator."""
+
+    def test_generate_with_max_length(self):
+        """Test that max_length is respected."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("a+", count=5, max_length=5)
+
+        for m in matching:
+            if len(m) > 0:
+                assert len(m) <= 5
+
+    def test_generate_nested_groups(self):
+        """Test generating test cases for nested groups."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("((a)(b))", count=3)
+
+        assert len(matching) >= 1
+
+    def test_generate_quantifier_range(self):
+        """Test generating test cases for range quantifier."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("a{2,4}", count=3)
+
+        assert len(matching) >= 1
+        assert 2 <= len(matching[0]) <= 4
+        assert matching[0] == "a" * len(matching[0])
+
+    def test_generate_lookahead_pattern(self):
+        """Test generating test cases for a lookahead pattern."""
+        generator = TestCaseGenerator("pcre")
+        matching = generator.generate_matching("(?=test)", count=3)
+
+        assert len(matching) >= 0