refactor: improve tests

jest-setup.ts

@@ -1,2 +1,3 @@
 import './test-utils/to-have-pattern';
 import './test-utils/to-match-groups';
+import './test-utils/to-match-string';

src/__tests__/examples.ts

@@ -36,14 +36,14 @@ test('example: IPv4 address validator', () => {
   expect(regex).toMatchGroups('255.255.255.255', ['255.255.255.255', '255', '255', '255', '255']);
   expect(regex).toMatchGroups('123.45.67.89', ['123.45.67.89', '123', '45', '67', '89']);
 
-  expect(regex.test('0.0.0.')).toBe(false);
-  expect(regex.test('0.0.0.0.')).toBe(false);
-  expect(regex.test('0.-1.0.0')).toBe(false);
-  expect(regex.test('0.1000.0.0')).toBe(false);
-  expect(regex.test('0.0.300.0')).toBe(false);
-  expect(regex.test('255.255.255.256')).toBe(false);
+  expect(regex).not.toMatchString('0.0.0.');
+  expect(regex).not.toMatchString('0.0.0.0.');
+  expect(regex).not.toMatchString('0.-1.0.0');
+  expect(regex).not.toMatchString('0.1000.0.0');
+  expect(regex).not.toMatchString('0.0.300.0');
+  expect(regex).not.toMatchString('255.255.255.256');
 
-  expect(regex.source).toEqual(
-    '^(\\d|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])\\.(\\d|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])\\.(\\d|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])\\.(\\d|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])$'
+  expect(regex).toHavePattern(
+    /^(\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])$/
   );
 });

src/components/__tests__/anchors.test.tsx

@@ -2,17 +2,17 @@ import { endOfString, startOfString } from '../anchors';
 import { oneOrMore } from '../quantifiers';
 
 test('`startOfString` basic cases', () => {
-  expect([startOfString]).toHavePattern('^');
-  expect([startOfString, 'a', 'b']).toHavePattern('^ab');
+  expect(startOfString).toHavePattern(/^/);
+  expect([startOfString, 'a', 'b']).toHavePattern(/^ab/);
 });
 
 test('`startOfString` regex tests', () => {
   expect([startOfString, oneOrMore('a')]).toMatchGroups('a aa aaa', ['a']);
 });
 
 test('`endOfString` basic cases', () => {
-  expect([endOfString]).toHavePattern('$');
-  expect(['a', 'b', endOfString]).toHavePattern('ab$');
+  expect(endOfString).toHavePattern(/$/);
+  expect(['a', 'b', endOfString]).toHavePattern(/ab$/);
 });
 
 test('`endOfString` regex tests', () => {

src/components/__tests__/capture.test.tsx

@@ -2,10 +2,10 @@ import { capture } from '../capture';
 import { oneOrMore } from '../quantifiers';
 
 test('`capture` base cases', () => {
-  expect(capture('a')).toHavePattern('(a)');
-  expect(capture('abc')).toHavePattern('(abc)');
-  expect(capture(oneOrMore('abc'))).toHavePattern('((?:abc)+)');
-  expect(oneOrMore(capture('abc'))).toHavePattern('(abc)+');
+  expect(capture('a')).toHavePattern(/(a)/);
+  expect(capture('abc')).toHavePattern(/(abc)/);
+  expect(capture(oneOrMore('abc'))).toHavePattern(/((?:abc)+)/);
+  expect(oneOrMore(capture('abc'))).toHavePattern(/(abc)+/);
 });
 
 test('`capture` captures group', () => {

src/components/__tests__/character-class.test.ts

@@ -12,37 +12,37 @@ import {
 import { buildRegex } from '../../builders';
 
 test('`any` character class', () => {
-  expect(any).toHavePattern('.');
-  expect(['x', any]).toHavePattern('x.');
-  expect(['x', any, 'x']).toHavePattern('x.x');
+  expect(any).toHavePattern(/./);
+  expect(['x', any]).toHavePattern(/x./);
+  expect(['x', any, 'x']).toHavePattern(/x.x/);
 });
 
 test('`digit` character class', () => {
-  expect(digit).toHavePattern('\\d');
-  expect(['x', digit]).toHavePattern('x\\d');
-  expect(['x', digit, 'x']).toHavePattern('x\\dx');
+  expect(digit).toHavePattern(/\d/);
+  expect(['x', digit]).toHavePattern(/x\d/);
+  expect(['x', digit, 'x']).toHavePattern(/x\dx/);
 });
 
 test('`word` character class', () => {
-  expect(word).toHavePattern('\\w');
-  expect(['x', word]).toHavePattern('x\\w');
-  expect(['x', word, 'x']).toHavePattern('x\\wx');
+  expect(word).toHavePattern(/\w/);
+  expect(['x', word]).toHavePattern(/x\w/);
+  expect(['x', word, 'x']).toHavePattern(/x\wx/);
 });
 
 test('`whitespace` character class', () => {
-  expect(whitespace).toHavePattern('\\s');
-  expect(['x', whitespace]).toHavePattern('x\\s');
-  expect(['x', whitespace, 'x']).toHavePattern('x\\sx');
+  expect(whitespace).toHavePattern(/\s/);
+  expect(['x', whitespace]).toHavePattern(/x\s/);
+  expect(['x', whitespace, 'x']).toHavePattern(/x\sx/);
 });
 
 test('`characterClass` base cases', () => {
-  expect(characterClass(characterRange('a', 'z'))).toHavePattern('[a-z]');
+  expect(characterClass(characterRange('a', 'z'))).toHavePattern(/[a-z]/);
   expect(characterClass(characterRange('a', 'z'), characterRange('A', 'Z'))).toHavePattern(
-    '[a-zA-Z]'
+    /[a-zA-Z]/
   );
-  expect(characterClass(characterRange('a', 'z'), anyOf('05'))).toHavePattern('[a-z05]');
+  expect(characterClass(characterRange('a', 'z'), anyOf('05'))).toHavePattern(/[a-z05]/);
   expect(characterClass(characterRange('a', 'z'), whitespace, anyOf('05'))).toHavePattern(
-    '[a-z\\s05]'
+    /[a-z\s05]/
   );
 });
 
@@ -53,9 +53,9 @@ test('`characterClass` throws on inverted arguments', () => {
 });
 
 test('`characterRange` base cases', () => {
-  expect(characterRange('a', 'z')).toHavePattern('[a-z]');
-  expect(['x', characterRange('0', '9')]).toHavePattern('x[0-9]');
-  expect([characterRange('A', 'F'), 'x']).toHavePattern('[A-F]x');
+  expect(characterRange('a', 'z')).toHavePattern(/[a-z]/);
+  expect(['x', characterRange('0', '9')]).toHavePattern(/x[0-9]/);
+  expect([characterRange('A', 'F'), 'x']).toHavePattern(/[A-F]x/);
 });
 
 test('`characterRange` throws on incorrect arguments', () => {
@@ -71,25 +71,25 @@ test('`characterRange` throws on incorrect arguments', () => {
 });
 
 test('`anyOf` base cases', () => {
-  expect(anyOf('a')).toHavePattern('a');
-  expect(['x', anyOf('a'), 'x']).toHavePattern('xax');
-  expect(anyOf('ab')).toHavePattern('[ab]');
-  expect(['x', anyOf('ab')]).toHavePattern('x[ab]');
-  expect(['x', anyOf('ab'), 'x']).toHavePattern('x[ab]x');
+  expect(anyOf('a')).toHavePattern(/a/);
+  expect(['x', anyOf('a'), 'x']).toHavePattern(/xax/);
+  expect(anyOf('ab')).toHavePattern(/[ab]/);
+  expect(['x', anyOf('ab')]).toHavePattern(/x[ab]/);
+  expect(['x', anyOf('ab'), 'x']).toHavePattern(/x[ab]x/);
 });
 
 test('`anyOf` with quantifiers', () => {
-  expect(['x', oneOrMore(anyOf('abc')), 'x']).toHavePattern('x[abc]+x');
-  expect(['x', optionally(anyOf('abc')), 'x']).toHavePattern('x[abc]?x');
-  expect(['x', zeroOrMore(anyOf('abc')), 'x']).toHavePattern('x[abc]*x');
+  expect(['x', oneOrMore(anyOf('abc')), 'x']).toHavePattern(/x[abc]+x/);
+  expect(['x', optionally(anyOf('abc')), 'x']).toHavePattern(/x[abc]?x/);
+  expect(['x', zeroOrMore(anyOf('abc')), 'x']).toHavePattern(/x[abc]*x/);
 });
 
 test('`anyOf` escapes special characters', () => {
-  expect(anyOf('abc-+.]\\')).toHavePattern('[abc+.\\]\\\\-]');
+  expect(anyOf('abc-+.]\\')).toHavePattern(/[abc+.\]\\-]/);
 });
 
 test('`anyOf` moves hyphen to the last position', () => {
-  expect(anyOf('a-bc')).toHavePattern('[abc-]');
+  expect(anyOf('a-bc')).toHavePattern(/[abc-]/);
 });
 
 test('`anyOf` throws on empty text', () => {
@@ -99,17 +99,17 @@ test('`anyOf` throws on empty text', () => {
 });
 
 test('`inverted` character class', () => {
-  expect(inverted(anyOf('a'))).toHavePattern('[^a]');
-  expect(inverted(anyOf('abc'))).toHavePattern('[^abc]');
+  expect(inverted(anyOf('a'))).toHavePattern(/[^a]/);
+  expect(inverted(anyOf('abc'))).toHavePattern(/[^abc]/);
 });
 
 test('`inverted` character class double inversion', () => {
-  expect(inverted(inverted(anyOf('a')))).toHavePattern('a');
-  expect(inverted(inverted(anyOf('abc')))).toHavePattern('[abc]');
+  expect(inverted(inverted(anyOf('a')))).toHavePattern(/a/);
+  expect(inverted(inverted(anyOf('abc')))).toHavePattern(/[abc]/);
 });
 
 test('`inverted` character class execution', () => {
-  expect(inverted(anyOf('a'))).toMatchGroups('aa', []);
+  expect(inverted(anyOf('a'))).not.toMatchString('aa');
   expect(inverted(anyOf('a'))).toMatchGroups('aba', ['b']);
 });
 

src/components/__tests__/choice-of.test.ts

@@ -3,34 +3,34 @@ import { repeat } from '../repeat';
 import { choiceOf } from '../choice-of';
 
 test('`choiceOf` using basic strings', () => {
-  expect(choiceOf('a')).toHavePattern('a');
-  expect(choiceOf('a', 'b')).toHavePattern('a|b');
-  expect(choiceOf('a', 'b', 'c')).toHavePattern('a|b|c');
-  expect(choiceOf('aaa', 'bbb')).toHavePattern('aaa|bbb');
+  expect(choiceOf('a')).toHavePattern(/a/);
+  expect(choiceOf('a', 'b')).toHavePattern(/a|b/);
+  expect(choiceOf('a', 'b', 'c')).toHavePattern(/a|b|c/);
+  expect(choiceOf('aaa', 'bbb')).toHavePattern(/aaa|bbb/);
 });
 
 test('`choiceOf` used in sequence', () => {
-  expect(['x', choiceOf('a'), 'x']).toHavePattern('xax');
-  expect([choiceOf('a', 'b'), 'x']).toHavePattern('(?:a|b)x');
-  expect(['x', choiceOf('a', 'b')]).toHavePattern('x(?:a|b)');
+  expect(['x', choiceOf('a'), 'x']).toHavePattern(/xax/);
+  expect([choiceOf('a', 'b'), 'x']).toHavePattern(/(?:a|b)x/);
+  expect(['x', choiceOf('a', 'b')]).toHavePattern(/x(?:a|b)/);
 
-  expect(choiceOf('a', 'b', 'c')).toHavePattern('a|b|c');
-  expect(['x', choiceOf('a', 'b', 'c')]).toHavePattern('x(?:a|b|c)');
-  expect([choiceOf('a', 'b', 'c'), 'x']).toHavePattern('(?:a|b|c)x');
+  expect(choiceOf('a', 'b', 'c')).toHavePattern(/a|b|c/);
+  expect(['x', choiceOf('a', 'b', 'c')]).toHavePattern(/x(?:a|b|c)/);
+  expect([choiceOf('a', 'b', 'c'), 'x']).toHavePattern(/(?:a|b|c)x/);
 
-  expect(choiceOf('aaa', 'bbb')).toHavePattern('aaa|bbb');
+  expect(choiceOf('aaa', 'bbb')).toHavePattern(/aaa|bbb/);
 });
 
 test('`choiceOf` with sequence options', () => {
-  expect([choiceOf(['a', 'b'])]).toHavePattern('ab');
-  expect([choiceOf(['a', 'b'], ['c', 'd'])]).toHavePattern('ab|cd');
-  expect([choiceOf(['a', zeroOrMore('b')], [oneOrMore('c'), 'd'])]).toHavePattern('ab*|c+d');
+  expect([choiceOf(['a', 'b'])]).toHavePattern(/ab/);
+  expect([choiceOf(['a', 'b'], ['c', 'd'])]).toHavePattern(/ab|cd/);
+  expect([choiceOf(['a', zeroOrMore('b')], [oneOrMore('c'), 'd'])]).toHavePattern(/ab*|c+d/);
 });
 
 test('`choiceOf` using nested regex', () => {
-  expect(choiceOf(oneOrMore('a'), zeroOrMore('b'))).toHavePattern('a+|b*');
+  expect(choiceOf(oneOrMore('a'), zeroOrMore('b'))).toHavePattern(/a+|b*/);
   expect(choiceOf(repeat({ min: 1, max: 3 }, 'a'), repeat({ count: 5 }, 'bx'))).toHavePattern(
-    'a{1,3}|(?:bx){5}'
+    /a{1,3}|(?:bx){5}/
   );
 });
 

src/components/__tests__/quantifiers.test.tsx

@@ -1,46 +1,39 @@
-import { buildRegex } from '../../builders';
 import { digit } from '../character-class';
 import { oneOrMore, optionally, zeroOrMore } from '../quantifiers';
 
 test('`oneOrMore` quantifier', () => {
-  expect(oneOrMore('a')).toHavePattern('a+');
-  expect(oneOrMore('ab')).toHavePattern('(?:ab)+');
+  expect(oneOrMore('a')).toHavePattern(/a+/);
+  expect(oneOrMore('ab')).toHavePattern(/(?:ab)+/);
 });
 
 test('`optionally` quantifier', () => {
-  expect(optionally('a')).toHavePattern('a?');
-  expect(optionally('ab')).toHavePattern('(?:ab)?');
+  expect(optionally('a')).toHavePattern(/a?/);
+  expect(optionally('ab')).toHavePattern(/(?:ab)?/);
 });
 
 test('`zeroOrMore` quantifier', () => {
-  expect(zeroOrMore('a')).toHavePattern('a*');
-  expect(zeroOrMore('ab')).toHavePattern('(?:ab)*');
+  expect(zeroOrMore('a')).toHavePattern(/a*/);
+  expect(zeroOrMore('ab')).toHavePattern(/(?:ab)*/);
 });
 
 test('`oneOrMore` does not generate capture when grouping', () => {
-  const regex = buildRegex(oneOrMore('aa'));
-  const groups = [...'aa'.match(regex)!];
-  expect(groups).toEqual(['aa']);
+  expect(oneOrMore('aa')).toMatchGroups('aa', ['aa']);
 });
 
 test('`optionally` does not generate capture when grouping', () => {
-  const regex = buildRegex(optionally('aa'));
-  const groups = [...'aa'.match(regex)!];
-  expect(groups).toEqual(['aa']);
+  expect(optionally('aa')).toMatchGroups('aa', ['aa']);
 });
 
 test('`zeroOrMore` does not generate capture when grouping', () => {
-  const regex = buildRegex(zeroOrMore('aa'));
-  const groups = [...'aa'.match(regex)!];
-  expect(groups).toEqual(['aa']);
+  expect(zeroOrMore('aa')).toMatchGroups('aa', ['aa']);
 });
 
 test('base quantifiers optimize grouping for atoms', () => {
-  expect(oneOrMore(digit)).toHavePattern('\\d+');
-  expect(optionally(digit)).toHavePattern('\\d?');
-  expect(zeroOrMore(digit)).toHavePattern('\\d*');
+  expect(oneOrMore(digit)).toHavePattern(/\d+/);
+  expect(optionally(digit)).toHavePattern(/\d?/);
+  expect(zeroOrMore(digit)).toHavePattern(/\d*/);
 
-  expect(oneOrMore('a')).toHavePattern('a+');
-  expect(optionally('a')).toHavePattern('a?');
-  expect(zeroOrMore('a')).toHavePattern('a*');
+  expect(oneOrMore('a')).toHavePattern(/a+/);
+  expect(optionally('a')).toHavePattern(/a?/);
+  expect(zeroOrMore('a')).toHavePattern(/a*/);
 });

src/components/__tests__/repeat.test.tsx

@@ -3,18 +3,18 @@ import { oneOrMore, zeroOrMore } from '../quantifiers';
 import { repeat } from '../repeat';
 
 test('`repeat` quantifier', () => {
-  expect(['a', repeat({ min: 1, max: 5 }, 'b')]).toHavePattern('ab{1,5}');
-  expect(['a', repeat({ min: 1 }, 'b')]).toHavePattern('ab{1,}');
-  expect(['a', repeat({ count: 1 }, 'b')]).toHavePattern('ab{1}');
+  expect(['a', repeat({ min: 1, max: 5 }, 'b')]).toHavePattern(/ab{1,5}/);
+  expect(['a', repeat({ min: 1 }, 'b')]).toHavePattern(/ab{1,}/);
+  expect(['a', repeat({ count: 1 }, 'b')]).toHavePattern(/ab{1}/);
 
-  expect(['a', repeat({ count: 1 }, ['a', zeroOrMore('b')])]).toHavePattern('a(?:ab*){1}');
-  expect(repeat({ count: 5 }, ['text', ' ', oneOrMore('d')])).toHavePattern('(?:text d+){5}');
+  expect(['a', repeat({ count: 1 }, ['a', zeroOrMore('b')])]).toHavePattern(/a(?:ab*){1}/);
+  expect(repeat({ count: 5 }, ['text', ' ', oneOrMore('d')])).toHavePattern(/(?:text d+){5}/);
 });
 
 test('`repeat` optimizes grouping for atoms', () => {
-  expect(repeat({ count: 2 }, digit)).toHavePattern('\\d{2}');
-  expect(repeat({ min: 2 }, digit)).toHavePattern('\\d{2,}');
-  expect(repeat({ min: 1, max: 5 }, digit)).toHavePattern('\\d{1,5}');
+  expect(repeat({ count: 2 }, digit)).toHavePattern(/\d{2}/);
+  expect(repeat({ min: 2 }, digit)).toHavePattern(/\d{2,}/);
+  expect(repeat({ min: 1, max: 5 }, digit)).toHavePattern(/\d{1,5}/);
 });
 
 test('`repeat` throws on no children', () => {