diff --git a/setup.py b/setup.py
index 3846e14..892f7b5 100644
--- a/setup.py
+++ b/setup.py
@@ -5,13 +5,13 @@
 
 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',
@@ -19,4 +19,8 @@
     long_description=long_description,
     long_description_content_type="text/markdown",
     python_requires='>=3.10',
+    classifiers=[
+        'Programming Language :: Python :: 3.10',
+        'Operating System :: OS Independent',
+    ],
 )
diff --git a/tests/test_alternative.py b/tests/test_alternative.py
index f3db21a..9075bb4 100644
--- a/tests/test_alternative.py
+++ b/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)
\ No newline at end of file
+    benchmark(f_finite, regexEnumerator, possibilities)
\ No newline at end of file
diff --git a/tests/test_backreference.py b/tests/test_backreference.py
index 3098999..9b5c45c 100644
--- a/tests/test_backreference.py
+++ b/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)
\ No newline at end of file
+    benchmark(f_infinite, regexEnumerator, possibilities)
\ No newline at end of file
diff --git a/tests/test_char_classes.py b/tests/test_char_classes.py
index 5d75f7e..4701f36 100644
--- a/tests/test_char_classes.py
+++ b/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']
 
diff --git a/tests/test_escape_char.py b/tests/test_escape_char.py
index ee5f9af..2db7613 100644
--- a/tests/test_escape_char.py
+++ b/tests/test_escape_char.py
@@ -2,141 +2,141 @@
 from .test_function import f_finite
 
 
-def test_digit_escape():
+def test_digit_escape(benchmark):
     regexEnumerator = RegexEnumerator(r'\d')
     possibilities = [str(i) for i in range(10)]
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_digit_escape_with_quantifier():
+def test_digit_escape_with_quantifier(benchmark):
     regexEnumerator = RegexEnumerator(r'\d{1 , 2 }')
     possibilities = [str(i) for i in range(10)] + [str(i) + str(j)
                                                    for i in range(10) for j in range(10)]
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_non_digit_escape():
+def test_non_digit_escape(benchmark):
     regexEnumerator = RegexEnumerator(r'\D')
     possibilities = [chr(i)
                      for i in range(32, 127) if chr(i) not in '0123456789']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_word_escape():
+def test_word_escape(benchmark):
     regexEnumerator = RegexEnumerator(r'\w')
     possibilities = [chr(i) for i in range(
         32, 127) if chr(i).isalnum() or chr(i) == '_']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_non_word_escape():
+def test_non_word_escape(benchmark):
     regexEnumerator = RegexEnumerator(r'\W')
     possibilities = [chr(i) for i in range(
         32, 127) if not (chr(i).isalnum() or chr(i) == '_')]
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_whitespace_escape():
+def test_whitespace_escape(benchmark):
     regexEnumerator = RegexEnumerator(r'\s')
     possibilities = [' ', '\t', '\n', '\r', '\f', '\v']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_non_whitespace_escape():
+def test_non_whitespace_escape(benchmark):
     regexEnumerator = RegexEnumerator(r'\S')
     possibilities = [chr(i) for i in range(
         32, 127) if chr(i) not in ' \t\n\r\f\v']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_tab_escape():
+def test_tab_escape(benchmark):
     regexEnumerator = RegexEnumerator(r'\t')
     possibilities = ['\t']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_carriage_return_escape():
+def test_carriage_return_escape(benchmark):
     regexEnumerator = RegexEnumerator(r'\r')
     possibilities = ['\r']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_newline_escape():
+def test_newline_escape(benchmark):
     regexEnumerator = RegexEnumerator(r'\n')
     possibilities = ['\n']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_vertical_tab_escape():
+def test_vertical_tab_escape(benchmark):
     regexEnumerator = RegexEnumerator(r'\v')
     possibilities = ['\v']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_form_feed_escape():
+def test_form_feed_escape(benchmark):
     regexEnumerator = RegexEnumerator(r'\f')
     possibilities = ['\f']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_hex_escape():
+def test_hex_escape(benchmark):
     regexEnumerator = RegexEnumerator(r'\x41')
     possibilities = ['A']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_escaped_open_square_bracket():
+def test_escaped_open_square_bracket(benchmark):
     regexEnumerator = RegexEnumerator(r'\[')
     possibilities = ['[']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_escaped_open_close_square_brackets():
+def test_escaped_open_close_square_brackets(benchmark):
     regexEnumerator = RegexEnumerator(r'\[\]')
     possibilities = ['[]']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_escaped_characters_inside_character_class():
+def test_escaped_characters_inside_character_class(benchmark):
     regexEnumerator = RegexEnumerator(r'[\[\]]')
     possibilities = ['[', ']']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_escaped_char_interrups_range_after_divider():
+def test_escaped_char_interrups_range_after_divider(benchmark):
     regexEnumerator = RegexEnumerator(r'[a-\d]')
     possibilities = ['a', '-', '0', '1', '2',
                      '3', '4', '5', '6', '7', '8', '9']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_escaped_char_interrups_range_after_1st_char():
+def test_escaped_char_interrups_range_after_1st_char(benchmark):
 
     regexEnumerator = RegexEnumerator(r'[\[\d]')
     possibilities = ['[', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_escaped_unicode_literal():
+def test_escaped_unicode_literal(benchmark):
     regexEnumerator = RegexEnumerator(r'\u00E0')
     possibilities = ['à']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
diff --git a/tests/test_groups.py b/tests/test_groups.py
index f03eacb..1a1e6d1 100644
--- a/tests/test_groups.py
+++ b/tests/test_groups.py
@@ -2,112 +2,112 @@
 from .test_function import f_finite, f_infinite
 
 
-def test_single_capturing_group_with_literal():
+def test_single_capturing_group_with_literal(benchmark):
     regexEnumerator = RegexEnumerator(r'(a)')
     possibilities = ['a']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_single_capturing_group_with_class_single_char():
+def test_single_capturing_group_with_class_single_char(benchmark):
     regexEnumerator = RegexEnumerator(r'([a])')
     possibilities = ['a']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_single_capturing_group_with_class_multi_char():
+def test_single_capturing_group_with_class_multi_char(benchmark):
     regexEnumerator = RegexEnumerator(r'([a-c])')
     possibilities = ['a', 'b', 'c']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_capturing_group_with_star_quantifier():
+def test_capturing_group_with_star_quantifier(benchmark):
     regexEnumerator = RegexEnumerator(r'(a)*')
     possibilities = ['', 'a', 'aa', 'aaa', 'aaaa', 'aaaaa']
 
-    f_infinite(regexEnumerator, possibilities)
+    benchmark(f_infinite, regexEnumerator, possibilities)
 
 
-def test_named_capturing_group_with_optional_subgroup():
+def test_named_capturing_group_with_optional_subgroup(benchmark):
     regexEnumerator = RegexEnumerator(r'(?<name>a[bcd](e)?)')
     possibilities = ['ab', 'abe', 'ac', 'ace', 'ad', 'ade']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_literal_followed_by_group_with_star_quantifier():
+def test_literal_followed_by_group_with_star_quantifier(benchmark):
     regexEnumerator = RegexEnumerator(r'a(b)*')
     possibilities = ['a' + 'b' * i for i in range(6)]
 
-    f_infinite(regexEnumerator, possibilities)
+    benchmark(f_infinite, regexEnumerator, possibilities)
 
 
-def test_two_capturing_groups_with_star_quantifiers():
+def test_two_capturing_groups_with_star_quantifiers(benchmark):
     regexEnumerator = RegexEnumerator(r'(a)*(b)*')
     possibilities = ['a' * i + 'b' * j for i in range(6) for j in range(6)]
 
-    f_infinite(regexEnumerator, possibilities)
+    benchmark(f_infinite, regexEnumerator, possibilities)
 
 
-def test_nested_capturing_groups():
+def test_nested_capturing_groups(benchmark):
     regexEnumerator = RegexEnumerator(r'(a(b(c)))')
     possibilities = ['abc']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_capturing_groups_in_sequence():
+def test_capturing_groups_in_sequence(benchmark):
     regexEnumerator = RegexEnumerator(r'((a)(b))')
     possibilities = ['ab']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_non_capturing_group():
+def test_non_capturing_group(benchmark):
     regexEnumerator = RegexEnumerator(r'(?:a|b)*')
     possibilities = ['', 'a', 'b', 'aa', 'ab', 'ba', 'bb']
 
-    f_infinite(regexEnumerator, possibilities)
+    benchmark(f_infinite, regexEnumerator, possibilities)
 
 
-def test_non_capturing_group_with_quantifier():
+def test_non_capturing_group_with_quantifier(benchmark):
     regexEnumerator = RegexEnumerator(r'(?:ab)+')
     possibilities = ['ab', 'abab', 'ababab']
 
-    f_infinite(regexEnumerator, possibilities)
+    benchmark(f_infinite, regexEnumerator, possibilities)
 
 
-def test_named_capturing_group_with_quantifier():
+def test_named_capturing_group_with_quantifier(benchmark):
     regexEnumerator = RegexEnumerator(r'(?<chars>[ab]{1,2})')
     possibilities = ['a', 'b', 'aa', 'ab', 'ba', 'bb']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_nested_non_capturing_groups():
+def test_nested_non_capturing_groups(benchmark):
     regexEnumerator = RegexEnumerator(r'(?:a(?:b(?:c)))?')
     possibilities = ['', 'abc']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_group_for_quantifier_scope():
+def test_group_for_quantifier_scope(benchmark):
     regexEnumerator = RegexEnumerator(r'(ab)+')
     possibilities = ['ab', 'abab', 'ababab']
 
-    f_infinite(regexEnumerator, possibilities)
+    benchmark(f_infinite, regexEnumerator, possibilities)
 
 
-def test_group_with_char_class_infinite_repetition():
+def test_group_with_char_class_infinite_repetition(benchmark):
     regexEnumerator = RegexEnumerator(r'([ab])+')
     possibilities = ['a', 'b', 'aa', 'ab', 'ba', 'bb']
 
-    f_infinite(regexEnumerator, possibilities)
+    benchmark(f_infinite, regexEnumerator, possibilities)
 
 
-def test_group_with_multiple_elements_with_qunatifiers():
+def test_group_with_multiple_elements_with_qunatifiers(benchmark):
     regexEnumerator = RegexEnumerator(r'(a[b-d]{0,2}){0, 3}')
     possibilities = ['']
     char_class = ['', 'b', 'c', 'd', 'bb', 'bc',
@@ -118,11 +118,12 @@ def test_group_with_multiple_elements_with_qunatifiers():
     possibilities.extend(one)
     possibilities.extend(two)
     possibilities.extend(three)
+    possibilities = set(possibilities)
 
-    f_finite(regexEnumerator, set(possibilities))
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_nested_groups_with_multiple_elements_with_quantifiers():
+def test_nested_groups_with_multiple_elements_with_quantifiers(benchmark):
     regexEnumerator = RegexEnumerator(r'(a([e-g]){1, 3}){0, 3}')
     possibilities = ['']
     group = ['e', 'f', 'g', 'ee', 'ef', 'eg', 'fe', 'ff', 'fg', 'ge', 'gf', 'gg', 'eee', 'eef', 'eeg', 'efe', 'eff', 'efg', 'ege', 'egf', 'egg',
@@ -133,5 +134,6 @@ def test_nested_groups_with_multiple_elements_with_quantifiers():
     possibilities.extend(one)
     possibilities.extend(two)
     possibilities.extend(three)
+    possibilities = set(possibilities)
 
-    f_finite(regexEnumerator, set(possibilities))
+    benchmark(f_finite, regexEnumerator, possibilities)
diff --git a/tests/test_literals.py b/tests/test_literals.py
index 7d2eaaa..118d627 100644
--- a/tests/test_literals.py
+++ b/tests/test_literals.py
@@ -2,80 +2,80 @@
 from .test_function import f_finite, f_infinite
 
 
-def test_empty_pattern_yields_empty_string():
+def test_empty_pattern_yields_empty_string(benchmark):
     regexEnumerator = RegexEnumerator(r'')
     possibilities = ['']
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_single_literal_character():
+def test_single_literal_character(benchmark):
     regexEnumerator = RegexEnumerator(r'a')
     possibilities = ['a']
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_zero_or_more_quantifier_on_single_char():
+def test_zero_or_more_quantifier_on_single_char(benchmark):
     regexEnumerator = RegexEnumerator(r'a*')
     possibilities = ['', 'a', 'aa', 'aaa', 'aaaa', 'aaaaa']
-    f_infinite(regexEnumerator, possibilities)
+    benchmark(f_infinite, regexEnumerator, possibilities)
 
 
-def test_one_or_more_quantifier_on_single_char():
+def test_one_or_more_quantifier_on_single_char(benchmark):
     regexEnumerator = RegexEnumerator(r'a+')
     possibilities = ['a', 'aa', 'aaa', 'aaaa', 'aaaaa']
-    f_infinite(regexEnumerator, possibilities)
+    benchmark(f_infinite, regexEnumerator, possibilities)
 
 
-def test_zero_or_one_quantifier_on_single_char():
+def test_zero_or_one_quantifier_on_single_char(benchmark):
     regexEnumerator = RegexEnumerator(r'a?')
     possibilities = ['', 'a']
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_exact_repetition_quantifier_on_single_char():
+def test_exact_repetition_quantifier_on_single_char(benchmark):
     regexEnumerator = RegexEnumerator(r'a{2}')
     possibilities = ['aa']
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_minimum_repetition_quantifier_on_single_char():
+def test_minimum_repetition_quantifier_on_single_char(benchmark):
     regexEnumerator = RegexEnumerator(r'a{2,}')
     possibilities = ['aa', 'aaa', 'aaaa', 'aaaaa']
-    f_infinite(regexEnumerator, possibilities)
+    benchmark(f_infinite, regexEnumerator, possibilities)
 
 
-def test_min_max_repetition_quantifier_on_single_char():
+def test_min_max_repetition_quantifier_on_single_char(benchmark):
     # `a{2,4}` yields 'aa', 'aaa', 'aaaa'.
     regexEnumerator = RegexEnumerator(r'a{2,4}')
     possibilities = ['aa', 'aaa', 'aaaa']
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_zero_times_repetition_quantifier_on_single_char():
+def test_zero_times_repetition_quantifier_on_single_char(benchmark):
     regexEnumerator = RegexEnumerator(r'a{0}')
     possibilities = ['']
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_escaped_literal_special_characters():
+def test_escaped_literal_special_characters(benchmark):
     regexEnumerator = RegexEnumerator(r'\*\+\?')
     possibilities = ['*+?']
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_single_character_class():
+def test_single_character_class(benchmark):
     regexEnumerator = RegexEnumerator(r'[abc]')
     possibilities = ['a', 'b', 'c']
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_single_escaped_character():
+def test_single_escaped_character(benchmark):
     regexEnumerator = RegexEnumerator(r'\n')
     possibilities = ['\n']
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_literal_dot_character():
+def test_literal_dot_character(benchmark):
     regexEnumerator = RegexEnumerator(r'\.')
     possibilities = ['.']
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
diff --git a/tests/test_mixed.py b/tests/test_mixed.py
index 6a26d91..fcc063c 100644
--- a/tests/test_mixed.py
+++ b/tests/test_mixed.py
@@ -2,34 +2,34 @@
 from .test_function import f_finite
 
 
-def test_character_class_between_literals():
+def test_character_class_between_literals(benchmark):
     regexEnumerator = RegexEnumerator(r'a[0-9]b')
     possibilities = ['a0b', 'a1b', 'a2b', 'a3b',
                      'a4b', 'a5b', 'a6b', 'a7b', 'a8b', 'a9b']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_single_wildcard():
+def test_single_wildcard(benchmark):
     regexEnumerator = RegexEnumerator(r'.')
     possibilities = [chr(i) for i in range(32, 127)]
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_wildcard_with_unicode():
+def test_wildcard_with_unicode(benchmark):
     regexEnumerator = RegexEnumerator(r'.', additional_charset='¡¢£')
     possibilities = [chr(i) for i in range(32, 127)] + ['¡', '¢', '£']
 
 
-def test_done():
+def test_done(benchmark):
     regexEnumerator = RegexEnumerator(r'')
     possibilities = ['', None]
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
 
 
-def test_weak_password():
+def test_weak_password(benchmark):
     regexEnumerator = RegexEnumerator(
         r'[Ll][Oo0][Vv][Ee3]([Yy][Oo0][Uu])?(2023|2024)[!1.]{1,2}')
     possibilities = []
@@ -52,4 +52,4 @@ def test_weak_password():
                                     possibilities.append(
                                         l_char + o + v + e + y + year + special_1 + special_2)
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)
diff --git a/tests/test_not_capturing_groups.py b/tests/test_not_capturing_groups.py
index 2ea1540..72dfcb6 100644
--- a/tests/test_not_capturing_groups.py
+++ b/tests/test_not_capturing_groups.py
@@ -2,8 +2,8 @@
 from .test_function import f_finite, f_infinite
 
 
-def test_not_capturing_groups():
+def test_not_capturing_groups(benchmark):
     regexEnumerator = RegexEnumerator(r'(?:a)(b)\1')
     possibilities = ['abb']
 
-    f_finite(regexEnumerator, possibilities)
+    benchmark(f_finite, regexEnumerator, possibilities)