Add benchmarking to tests

setup.py

@@ -5,18 +5,22 @@
 
 setup(
     name='regex_enumerator',
-    version='0.8.4',
+    version='0.8.5',
     packages=find_packages(include=['regex_enumerator', 'regex_enumerator.*']),
     description='Enumerate all strings that match a given regex',
     author='Vincenzo Greco',
     author_email='grecovincenzo98@gmail.com',
     extras_require={
-        'dev': ['pytest', 'pytest-cov'],
+        'dev': ['pytest', 'pytest-cov', 'pytest-benchmark'],
     },
     url='https://github.com/Buba98/regex_enumerator',
     keywords=['regex', 'regex enumerator', 'regular-expression', 'enumerator', 'string-generation',
               'exhaustive-matching', 'regex-testing', 'regex-tools', 'string-enumeration', 'data-generation'],
     long_description=long_description,
     long_description_content_type="text/markdown",
     python_requires='>=3.10',
+    classifiers=[
+        'Programming Language :: Python :: 3.10',
+        'Operating System :: OS Independent',
+    ],
 )

tests/test_alternative.py

@@ -2,70 +2,70 @@
 from .test_function import f_finite, f_infinite
 
 
-def test_two_alternatives():
+def test_two_alternatives(benchmark):
     regexEnumerator = RegexEnumerator(r'a|b')
     possibilities = ['a', 'b']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_alternatives_with_quantifier_on_second_option():
+def test_alternatives_with_quantifier_on_second_option(benchmark):
     regexEnumerator = RegexEnumerator(r'a|b*')
     possibilities = ['a', '', 'b', 'bb', 'bbb', 'bbbb', 'bbbbb']
 
-    f_infinite(regexEnumerator, possibilities)
+    benchmark(f_infinite, regexEnumerator, possibilities)
 
 
-def test_alternatives_with_quantifier_plus_on_first_option():
+def test_alternatives_with_quantifier_plus_on_first_option(benchmark):
     regexEnumerator = RegexEnumerator(r'a+|b')
     possibilities = ['b', 'a', 'aa', 'aaa', 'aaaa', 'aaaaa']
 
-    f_infinite(regexEnumerator, possibilities)
+    benchmark(f_infinite, regexEnumerator, possibilities)
 
 
-def test_multiple_alternatives():
+def test_multiple_alternatives(benchmark):
     regexEnumerator = RegexEnumerator(r'a|b|c')
     possibilities = ['a', 'b', 'c']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_alternative_with_literal_and_character_class():
+def test_alternative_with_literal_and_character_class(benchmark):
     regexEnumerator = RegexEnumerator(r'a|[b-d]')
     possibilities = ['a', 'b', 'c', 'd']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_alternative_with_character_class_and_literal():
+def test_alternative_with_character_class_and_literal(benchmarkbenchmark):
     regexEnumerator = RegexEnumerator(r'[a-c]{ 0}|d')
     possibilities = ['', 'd']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_alternation_with_character_classes_and_literals():
+def test_alternation_with_character_classes_and_literals(benchmark):
     regexEnumerator = RegexEnumerator(r'(a|[0-2])')
     possibilities = ['a', '0', '1', '2']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_nested_alternation():
+def test_nested_alternation(benchmark):
     regexEnumerator = RegexEnumerator(r'((a|b)|c)')
     possibilities = ['a', 'b', 'c']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_alternation_with_grouping():
+def test_alternation_with_grouping(benchmark):
     regexEnumerator = RegexEnumerator(r'(a(b|c)d|x)')
     possibilities = ['abd', 'acd', 'x']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
-def test_same_alternative_twice():
+def test_same_alternative_twice(benchmark):
     regexEnumerator = RegexEnumerator(r'a{1,2}|a{1,2}')
     possibilities = ['a', 'aa']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)

tests/test_backreference.py

@@ -2,82 +2,82 @@
 from .test_function import f_finite, f_infinite
 
 
-def test_backreference():
+def test_backreference(benchmark):
     regexEnumerator = RegexEnumerator(r'(a)\1')
     possibilities = ['aa']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_backreference_with_group_quantifier():
+def test_backreference_with_group_quantifier(benchmark):
     regexEnumerator = RegexEnumerator(r'(a)+\1')
     possibilities = ['aa' * i for i in range(1, 6)]
 
-    f_infinite(regexEnumerator, possibilities)
+    benchmark(f_infinite, regexEnumerator, possibilities)
 
 
-def test_backreference_with_quantifier():
+def test_backreference_with_quantifier(benchmark):
     regexEnumerator = RegexEnumerator(r'(a)\1+')
     possibilities = ['a' * i + 'a' for i in range(1, 6)]
 
-    f_infinite(regexEnumerator, possibilities)
+    benchmark(f_infinite, regexEnumerator, possibilities)
 
 
-def test_backreference_with_named_group():
+def test_backreference_with_named_group(benchmark):
     regexEnumerator = RegexEnumerator(r'(?<name>[a-b])\k<name>')
     possibilities = ['aa', 'bb']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_backreference_with_named_group_and_quantifier():
+def test_backreference_with_named_group_and_quantifier(benchmark):
     regexEnumerator = RegexEnumerator(r'(?<name>[a-b])\k<name>{1, 2}')
     possibilities = ['aa', 'bb', 'aaa', 'bbb']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_zero_width_backreference():
+def test_zero_width_backreference(benchmark):
     regexEnumerator = RegexEnumerator(r'(a)?\1{0}')
     possibilities = ['a', '']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_10_backreference():
+def test_10_backreference(benchmark):
     regexEnumerator = RegexEnumerator(r'(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)\10')
     possibilities = ['abcdefghijj']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_multiple_backreferences():
+def test_multiple_backreferences(benchmark):
     regexEnumerator = RegexEnumerator(r'(a)(b)\2\1')
     possibilities = ['abba']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_backreference_with_mismatch():
+def test_backreference_with_mismatch(benchmark):
     regexEnumerator = RegexEnumerator(r'(a)(b)\1')
     possibilities = ['aba']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_named_group_with_backreference():
+def test_named_group_with_backreference(benchmark):
     regexEnumerator = RegexEnumerator(r'(?<letter>[ab])\k<letter>')
     possibilities = [
         'aa', 'bb'
     ]
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_named_group_infinite_repetition_with_backreference():
+def test_named_group_infinite_repetition_with_backreference(benchmark):
     regexEnumerator = RegexEnumerator(r'(?<letter>[ab])+\k<letter>')
     possibilities = [
         'aa', 'bb', 'abab', 'baba', 'aaaa', 'bbbb'
     ]
 
-    f_infinite(regexEnumerator, possibilities)
+    benchmark(f_infinite, regexEnumerator, possibilities)

tests/test_char_classes.py

@@ -2,129 +2,129 @@
 from .test_function import f_finite, f_infinite
 
 
-def test_single_character_class():
+def test_single_character_class(benchmark):
     regexEnumerator = RegexEnumerator(r'[a]')
     possibilities = ['a']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_character_class_with_two_literals():
+def test_character_class_with_two_literals(benchmark):
     regexEnumerator = RegexEnumerator(r'[ab]')
     possibilities = ['a', 'b']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_character_class_with_zero_or_more_quantifier():
+def test_character_class_with_zero_or_more_quantifier(benchmark):
     regexEnumerator = RegexEnumerator(r'[a]*')
     possibilities = ['', 'a', 'aa', 'aaa', 'aaaa', 'aaaaa']
 
-    f_infinite(regexEnumerator, possibilities)
+    benchmark(f_infinite, regexEnumerator, possibilities)
 
 
-def test_range_character_class():
+def test_range_character_class(benchmark):
     regexEnumerator = RegexEnumerator(r'[a-c]')
     possibilities = ['a', 'b', 'c']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_range_character_class_with_repetition():
+def test_range_character_class_with_repetition(benchmark):
     regexEnumerator = RegexEnumerator(r'[a-c]{1,2}')
     possibilities = ['a', 'b', 'c', 'aa', 'ab',
                      'ac', 'ba', 'bb', 'bc', 'ca', 'cb', 'cc']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_range_character_class_with_zero_repetition():
+def test_range_character_class_with_zero_repetition(benchmark):
     regexEnumerator = RegexEnumerator(r'[a-c]{0}')
     possibilities = ['']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_range_character_class_with_one_or_more_quantifier():
+def test_range_character_class_with_one_or_more_quantifier(benchmark):
     regexEnumerator = RegexEnumerator(r'[a-b]+')
     possibilities = ['a', 'b', 'aa', 'ab', 'ba', 'bb', 'aaa',
                      'aab', 'aba', 'abb', 'baa', 'bab', 'bba', 'bbb']
 
-    f_infinite(regexEnumerator, possibilities)
+    benchmark(f_infinite, regexEnumerator, possibilities)
 
 
-def test_two_ranges_with_optional_quantifier():
+def test_two_ranges_with_optional_quantifier(benchmark):
     regexEnumerator = RegexEnumerator(r'[a-cf-g]?')
     possibilities = ['', 'a', 'b', 'c', 'f', 'g']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_literal_in_character_class():
+def test_literal_in_character_class(benchmark):
     regexEnumerator = RegexEnumerator(r'[.]')
     possibilities = ['.']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_negated_character_class():
+def test_negated_character_class(benchmark):
     regexEnumerator = RegexEnumerator(r'[^a]')
     possibilities = [chr(i) for i in range(32, 127) if chr(i) != 'a']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_character_class_with_escaped_special_char_at_start():
+def test_character_class_with_escaped_special_char_at_start(benchmark):
     regexEnumerator = RegexEnumerator(r'[\]-a]')
     possibilities = [chr(i) for i in range(93, 98)]
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_character_class_with_escaped_special_char_at_end():
+def test_character_class_with_escaped_special_char_at_end(benchmark):
     regexEnumerator = RegexEnumerator(r'[Z-\]]')
     possibilities = [chr(i) for i in range(90, 94)]
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_character_class_with_escape_sequence():
+def test_character_class_with_escape_sequence(benchmark):
     regexEnumerator = RegexEnumerator(r'[\d]')
     possibilities = [str(i) for i in range(10)]
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_incomplete_range_character_class():
+def test_incomplete_range_character_class(benchmark):
     regexEnumerator = RegexEnumerator(r'[a-]')
     possibilities = ['a', '-']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_2_ranges():
+def test_2_ranges(benchmark):
     regexEnumerator = RegexEnumerator(r'[1a-crf-g3]')
     possibilities = ['1', 'a', 'b', 'c', 'f', 'g', 'r', '3']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_unicode_character_class():
+def test_unicode_character_class(benchmark):
     regexEnumerator = RegexEnumerator(r'[à-å]')
     possibilities = ['à', 'á', 'â', 'ã', 'ä', 'å']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_additional_charset():
+def test_additional_charset(benchmark):
     regexEnumerator = RegexEnumerator(
         r'[^\w\d\s]', additional_charset=['γ', 'β', 'α'])
     possibilities = ['!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', ':',
                      ';', '<', '=', '>', '?', '@', '[', '\\', ']', '^', '`', '{', '|', '}', '~', 'α', 'β', 'γ']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
-def test_charclass_with_quantifier_from_0():
+def test_charclass_with_quantifier_from_0(benchmark):
     regexEnumerator = RegexEnumerator(r'[b-d]{0,2}')
     possibilities = ['', 'b', 'c', 'd', 'bb', 'bc', 'bd', 'cb', 'cc', 'cd', 'db', 'dc', 'dd']