import 'package:petitparser/petitparser.dart';
import 'package:petitparser/src/parser/character/predicate/char.dart';
import 'package:petitparser/src/parser/character/predicate/constant.dart';
import 'package:test/test.dart' hide anyOf;

import 'utils/assertions.dart';
import 'utils/matchers.dart';

void main() {
  group('greedy', () {
    expectParserInvariants(any().starGreedy(digit()));
    test('star', () {
      final parser = word().starGreedy(digit());
      expect(parser, isParseFailure('', message: 'digit expected'));
      expect(parser, isParseFailure('a', message: 'digit expected'));
      expect(parser, isParseFailure('ab', message: 'digit expected'));
      expect(parser, isParseSuccess('1', result: isEmpty, position: 0));
      expect(parser, isParseSuccess('a1', result: ['a'], position: 1));
      expect(parser, isParseSuccess('ab1', result: ['a', 'b'], position: 2));
      expect(
        parser,
        isParseSuccess('abc1', result: ['a', 'b', 'c'], position: 3),
      );
      expect(parser, isParseSuccess('12', result: ['1'], position: 1));
      expect(parser, isParseSuccess('a12', result: ['a', '1'], position: 2));
      expect(
        parser,
        isParseSuccess('ab12', result: ['a', 'b', '1'], position: 3),
      );
      expect(
        parser,
        isParseSuccess('abc12', result: ['a', 'b', 'c', '1'], position: 4),
      );
      expect(parser, isParseSuccess('123', result: ['1', '2'], position: 2));
      expect(
        parser,
        isParseSuccess('a123', result: ['a', '1', '2'], position: 3),
      );
      expect(
        parser,
        isParseSuccess('ab123', result: ['a', 'b', '1', '2'], position: 4),
      );
      expect(
        parser,
        isParseSuccess(
          'abc123',
          result: ['a', 'b', 'c', '1', '2'],
          position: 5,
        ),
      );
    });
    test('plus', () {
      final parser = word().plusGreedy(digit());
      expect(parser, isParseFailure('', message: 'letter or digit expected'));
      expect(
        parser,
        isParseFailure('a', position: 1, message: 'digit expected'),
      );
      expect(
        parser,
        isParseFailure('ab', position: 1, message: 'digit expected'),
      );
      expect(
        parser,
        isParseFailure('1', position: 1, message: 'digit expected'),
      );
      expect(parser, isParseSuccess('a1', result: ['a'], position: 1));
      expect(parser, isParseSuccess('ab1', result: ['a', 'b'], position: 2));
      expect(
        parser,
        isParseSuccess('abc1', result: ['a', 'b', 'c'], position: 3),
      );
      expect(parser, isParseSuccess('12', result: ['1'], position: 1));
      expect(parser, isParseSuccess('a12', result: ['a', '1'], position: 2));
      expect(
        parser,
        isParseSuccess('ab12', result: ['a', 'b', '1'], position: 3),
      );
      expect(
        parser,
        isParseSuccess('abc12', result: ['a', 'b', 'c', '1'], position: 4),
      );
      expect(parser, isParseSuccess('123', result: ['1', '2'], position: 2));
      expect(
        parser,
        isParseSuccess('a123', result: ['a', '1', '2'], position: 3),
      );
      expect(
        parser,
        isParseSuccess('ab123', result: ['a', 'b', '1', '2'], position: 4),
      );
      expect(
        parser,
        isParseSuccess(
          'abc123',
          result: ['a', 'b', 'c', '1', '2'],
          position: 5,
        ),
      );
    });
    test('repeat', () {
      final parser = word().repeatGreedy(digit(), 2, 4);
      expect(parser, isParseFailure('', message: 'letter or digit expected'));
      expect(
        parser,
        isParseFailure('a', position: 1, message: 'letter or digit expected'),
      );
      expect(
        parser,
        isParseFailure('ab', position: 2, message: 'digit expected'),
      );
      expect(
        parser,
        isParseFailure('abc', position: 2, message: 'digit expected'),
      );
      expect(
        parser,
        isParseFailure('abcd', position: 2, message: 'digit expected'),
      );
      expect(
        parser,
        isParseFailure('abcde', position: 2, message: 'digit expected'),
      );
      expect(
        parser,
        isParseFailure('1', position: 1, message: 'letter or digit expected'),
      );
      expect(
        parser,
        isParseFailure('a1', position: 2, message: 'digit expected'),
      );
      expect(parser, isParseSuccess('ab1', result: ['a', 'b'], position: 2));
      expect(
        parser,
        isParseSuccess('abc1', result: ['a', 'b', 'c'], position: 3),
      );
      expect(
        parser,
        isParseSuccess('abcd1', result: ['a', 'b', 'c', 'd'], position: 4),
      );
      expect(
        parser,
        isParseFailure('abcde1', position: 2, message: 'digit expected'),
      );
      expect(
        parser,
        isParseFailure('12', position: 2, message: 'digit expected'),
      );
      expect(parser, isParseSuccess('a12', result: ['a', '1'], position: 2));
      expect(
        parser,
        isParseSuccess('ab12', result: ['a', 'b', '1'], position: 3),
      );
      expect(
        parser,
        isParseSuccess('abc12', result: ['a', 'b', 'c', '1'], position: 4),
      );
      expect(
        parser,
        isParseSuccess('abcd12', result: ['a', 'b', 'c', 'd'], position: 4),
      );
      expect(
        parser,
        isParseFailure('abcde12', position: 2, message: 'digit expected'),
      );
      expect(parser, isParseSuccess('123', result: ['1', '2'], position: 2));
      expect(
        parser,
        isParseSuccess('a123', result: ['a', '1', '2'], position: 3),
      );
      expect(
        parser,
        isParseSuccess('ab123', result: ['a', 'b', '1', '2'], position: 4),
      );
      expect(
        parser,
        isParseSuccess('abc123', result: ['a', 'b', 'c', '1'], position: 4),
      );
      expect(
        parser,
        isParseSuccess('abcd123', result: ['a', 'b', 'c', 'd'], position: 4),
      );
      expect(
        parser,
        isParseFailure('abcde123', position: 2, message: 'digit expected'),
      );
    });
    test('repeat unbounded', () {
      final inputLetter = List.filled(100000, 'a');
      final inputDigit = List.filled(100000, '1');
      final parser = word().repeatGreedy(digit(), 2, unbounded);
      expect(
        parser,
        isParseSuccess(
          '${inputLetter.join()}1',
          result: inputLetter,
          position: inputLetter.length,
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '${inputDigit.join()}1',
          result: inputDigit,
          position: inputDigit.length,
        ),
      );
    });
    test('infinite loop', () {
      final inner = epsilon(), limiter = failure<void>();
      expect(
        () => inner.starGreedy(limiter).parse(''),
        throwsA(
          isAssertionError.having(
            (exception) => exception.message,
            'message',
            '$inner must always consume',
          ),
        ),
      );
      expect(
        () => inner.starGreedy(limiter).fastParseOn('', 0),
        throwsA(
          isAssertionError.having(
            (exception) => exception.message,
            'message',
            '$inner must always consume',
          ),
        ),
      );
      expect(
        () => inner.plusGreedy(limiter).parse(''),
        throwsA(
          isAssertionError.having(
            (exception) => exception.message,
            'message',
            '$inner must always consume',
          ),
        ),
      );
      expect(
        () => inner.plusGreedy(limiter).fastParseOn('', 0),
        throwsA(
          isAssertionError.having(
            (exception) => exception.message,
            'message',
            '$inner must always consume',
          ),
        ),
      );
    }, skip: !hasAssertionsEnabled());
  });
  group('lazy', () {
    expectParserInvariants(any().starLazy(digit()));
    test('star', () {
      final parser = word().starLazy(digit());
      expect(parser, isParseFailure(''));
      expect(
        parser,
        isParseFailure('a', position: 1, message: 'digit expected'),
      );
      expect(
        parser,
        isParseFailure('ab', position: 2, message: 'digit expected'),
      );
      expect(parser, isParseSuccess('1', result: isEmpty, position: 0));
      expect(parser, isParseSuccess('a1', result: ['a'], position: 1));
      expect(parser, isParseSuccess('ab1', result: ['a', 'b'], position: 2));
      expect(
        parser,
        isParseSuccess('abc1', result: ['a', 'b', 'c'], position: 3),
      );
      expect(parser, isParseSuccess('12', result: isEmpty, position: 0));
      expect(parser, isParseSuccess('a12', result: ['a'], position: 1));
      expect(parser, isParseSuccess('ab12', result: ['a', 'b'], position: 2));
      expect(
        parser,
        isParseSuccess('abc12', result: ['a', 'b', 'c'], position: 3),
      );
      expect(parser, isParseSuccess('123', result: isEmpty, position: 0));
      expect(parser, isParseSuccess('a123', result: ['a'], position: 1));
      expect(parser, isParseSuccess('ab123', result: ['a', 'b'], position: 2));
      expect(
        parser,
        isParseSuccess('abc123', result: ['a', 'b', 'c'], position: 3),
      );
    });
    test('plus', () {
      final parser = word().plusLazy(digit());
      expect(parser, isParseFailure(''));
      expect(
        parser,
        isParseFailure('a', position: 1, message: 'digit expected'),
      );
      expect(
        parser,
        isParseFailure('ab', position: 2, message: 'digit expected'),
      );
      expect(
        parser,
        isParseFailure('1', position: 1, message: 'digit expected'),
      );
      expect(parser, isParseSuccess('a1', result: ['a'], position: 1));
      expect(parser, isParseSuccess('ab1', result: ['a', 'b'], position: 2));
      expect(
        parser,
        isParseSuccess('abc1', result: ['a', 'b', 'c'], position: 3),
      );
      expect(parser, isParseSuccess('12', result: ['1'], position: 1));
      expect(parser, isParseSuccess('a12', result: ['a'], position: 1));
      expect(parser, isParseSuccess('ab12', result: ['a', 'b'], position: 2));
      expect(
        parser,
        isParseSuccess('abc12', result: ['a', 'b', 'c'], position: 3),
      );
      expect(parser, isParseSuccess('123', result: ['1'], position: 1));
      expect(parser, isParseSuccess('a123', result: ['a'], position: 1));
      expect(parser, isParseSuccess('ab123', result: ['a', 'b'], position: 2));
      expect(
        parser,
        isParseSuccess('abc123', result: ['a', 'b', 'c'], position: 3),
      );
    });
    test('repeat', () {
      final parser = word().repeatLazy(digit(), 2, 4);
      expect(parser, isParseFailure('', message: 'letter or digit expected'));
      expect(
        parser,
        isParseFailure('a', position: 1, message: 'letter or digit expected'),
      );
      expect(
        parser,
        isParseFailure('ab', position: 2, message: 'digit expected'),
      );
      expect(
        parser,
        isParseFailure('abc', position: 3, message: 'digit expected'),
      );
      expect(
        parser,
        isParseFailure('abcd', position: 4, message: 'digit expected'),
      );
      expect(
        parser,
        isParseFailure('abcde', position: 4, message: 'digit expected'),
      );
      expect(
        parser,
        isParseFailure('1', position: 1, message: 'letter or digit expected'),
      );
      expect(
        parser,
        isParseFailure('a1', position: 2, message: 'digit expected'),
      );
      expect(parser, isParseSuccess('ab1', result: ['a', 'b'], position: 2));
      expect(
        parser,
        isParseSuccess('abc1', result: ['a', 'b', 'c'], position: 3),
      );
      expect(
        parser,
        isParseSuccess('abcd1', result: ['a', 'b', 'c', 'd'], position: 4),
      );
      expect(
        parser,
        isParseFailure('abcde1', position: 4, message: 'digit expected'),
      );
      expect(
        parser,
        isParseFailure('12', position: 2, message: 'digit expected'),
      );
      expect(parser, isParseSuccess('a12', result: ['a', '1'], position: 2));
      expect(parser, isParseSuccess('ab12', result: ['a', 'b'], position: 2));
      expect(
        parser,
        isParseSuccess('abc12', result: ['a', 'b', 'c'], position: 3),
      );
      expect(
        parser,
        isParseSuccess('abcd12', result: ['a', 'b', 'c', 'd'], position: 4),
      );
      expect(
        parser,
        isParseFailure('abcde12', position: 4, message: 'digit expected'),
      );
      expect(parser, isParseSuccess('123', result: ['1', '2'], position: 2));
      expect(parser, isParseSuccess('a123', result: ['a', '1'], position: 2));
      expect(parser, isParseSuccess('ab123', result: ['a', 'b'], position: 2));
      expect(
        parser,
        isParseSuccess('abc123', result: ['a', 'b', 'c'], position: 3),
      );
      expect(
        parser,
        isParseSuccess('abcd123', result: ['a', 'b', 'c', 'd'], position: 4),
      );
      expect(
        parser,
        isParseFailure('abcde123', position: 4, message: 'digit expected'),
      );
    });
    test('repeat unbounded', () {
      final input = List.filled(100000, 'a');
      final parser = word().repeatLazy(digit(), 2, unbounded);
      expect(
        parser,
        isParseSuccess(
          '${input.join()}1111',
          result: input,
          position: input.length,
        ),
      );
    });
    test('infinite loop', () {
      final inner = epsilon(), limiter = failure<void>();
      expect(
        () => inner.starLazy(limiter).parse(''),
        throwsA(
          isAssertionError.having(
            (exception) => exception.message,
            'message',
            '$inner must always consume',
          ),
        ),
      );
      expect(
        () => inner.starLazy(limiter).fastParseOn('', 0),
        throwsA(
          isAssertionError.having(
            (exception) => exception.message,
            'message',
            '$inner must always consume',
          ),
        ),
      );
      expect(
        () => inner.plusLazy(limiter).parse(''),
        throwsA(
          isAssertionError.having(
            (exception) => exception.message,
            'message',
            '$inner must always consume',
          ),
        ),
      );
      expect(
        () => inner.plusLazy(limiter).fastParseOn('', 0),
        throwsA(
          isAssertionError.having(
            (exception) => exception.message,
            'message',
            '$inner must always consume',
          ),
        ),
      );
    }, skip: !hasAssertionsEnabled());
  });
  group('possessive', () {
    expectParserInvariants(any().star());
    test('star', () {
      final parser = char('a').star();
      expect(parser, isParseSuccess('', result: isEmpty));
      expect(parser, isParseSuccess('a', result: ['a']));
      expect(parser, isParseSuccess('aa', result: ['a', 'a']));
      expect(parser, isParseSuccess('aaa', result: ['a', 'a', 'a']));
    });
    test('plus', () {
      final parser = char('a').plus();
      expect(parser, isParseFailure('', message: '"a" expected'));
      expect(parser, isParseSuccess('a', result: ['a']));
      expect(parser, isParseSuccess('aa', result: ['a', 'a']));
      expect(parser, isParseSuccess('aaa', result: ['a', 'a', 'a']));
    });
    test('times', () {
      final parser = char('a').times(2);
      expect(parser, isParseFailure('', message: '"a" expected'));
      expect(parser, isParseFailure('a', position: 1, message: '"a" expected'));
      expect(parser, isParseSuccess('aa', result: ['a', 'a']));
      expect(parser, isParseSuccess('aaa', result: ['a', 'a'], position: 2));
    });
    test('repeat', () {
      final parser = char('a').repeat(2, 3);
      expect(parser, isParseFailure('', message: '"a" expected'));
      expect(parser, isParseFailure('a', position: 1, message: '"a" expected'));
      expect(parser, isParseSuccess('aa', result: ['a', 'a']));
      expect(parser, isParseSuccess('aaa', result: ['a', 'a', 'a']));
      expect(
        parser,
        isParseSuccess('aaaa', result: ['a', 'a', 'a'], position: 3),
      );
    });
    test('repeat unbounded', () {
      final input = List.filled(100000, 'a');
      final parser = char('a').repeat(2, unbounded);
      expect(parser, isParseSuccess(input.join(), result: input));
    });
    test('repeat erroneous', () {
      expect(
        () => char('a').repeat(-1, 1),
        throwsA(
          isAssertionError.having(
            (exception) => exception.message,
            'message',
            'min must be at least 0, but got -1',
          ),
        ),
      );
      expect(
        () => char('a').repeat(2, 1),
        throwsA(
          isAssertionError.having(
            (exception) => exception.message,
            'message',
            'max must be at least 2, but got 1',
          ),
        ),
      );
    }, skip: !hasAssertionsEnabled());
    test('times', () {
      final parser = char('a').times(2);
      expect(parser, isParseFailure('', message: '"a" expected'));
      expect(parser, isParseFailure('a', position: 1, message: '"a" expected'));
      expect(parser, isParseSuccess('aa', result: ['a', 'a']));
      expect(parser, isParseSuccess('aaa', result: ['a', 'a'], position: 2));
    });
    test('infinite loop', () {
      final inner = epsilon();
      expect(
        () => inner.star().parse(''),
        throwsA(
          isAssertionError.having(
            (exception) => exception.message,
            'message',
            '$inner must always consume',
          ),
        ),
      );
      expect(
        () => inner.star().fastParseOn('', 0),
        throwsA(
          isAssertionError.having(
            (exception) => exception.message,
            'message',
            '$inner must always consume',
          ),
        ),
      );
      expect(
        () => inner.plus().parse(''),
        throwsA(
          isAssertionError.having(
            (exception) => exception.message,
            'message',
            '$inner must always consume',
          ),
        ),
      );
      expect(
        () => inner.plus().fastParseOn('', 0),
        throwsA(
          isAssertionError.having(
            (exception) => exception.message,
            'message',
            '$inner must always consume',
          ),
        ),
      );
    }, skip: !hasAssertionsEnabled());
  });
  group('string', () {
    expectParserInvariants(any().starString());
    test('star', () {
      final parser = char('a').starString();
      expect(
        parser,
        isA<RepeatingCharacterParser>().having(
          (parser) => parser.predicate,
          'predicate',
          isA<SingleCharPredicate>(),
        ),
      );
      expect(parser, isParseSuccess('', result: ''));
      expect(parser, isParseSuccess('a', result: 'a'));
      expect(parser, isParseSuccess('aa', result: 'aa'));
      expect(parser, isParseSuccess('aaa', result: 'aaa'));
    });
    test('plus', () {
      final parser = char('a').plusString();
      expect(
        parser,
        isA<RepeatingCharacterParser>().having(
          (parser) => parser.predicate,
          'predicate',
          isA<SingleCharPredicate>(),
        ),
      );
      expect(parser, isParseFailure('', message: '"a" expected'));
      expect(parser, isParseSuccess('a', result: 'a'));
      expect(parser, isParseSuccess('aa', result: 'aa'));
      expect(parser, isParseSuccess('aaa', result: 'aaa'));
    });
    test('times', () {
      final parser = char('a').timesString(2);
      expect(
        parser,
        isA<RepeatingCharacterParser>().having(
          (parser) => parser.predicate,
          'predicate',
          isA<SingleCharPredicate>(),
        ),
      );
      expect(parser, isParseFailure('', message: '"a" expected'));
      expect(parser, isParseFailure('a', position: 1, message: '"a" expected'));
      expect(parser, isParseSuccess('aa', result: 'aa'));
      expect(parser, isParseSuccess('aaa', result: 'aa', position: 2));
    });
    test('repeat', () {
      final parser = char('a').repeatString(2, 3);
      expect(
        parser,
        isA<RepeatingCharacterParser>().having(
          (parser) => parser.predicate,
          'predicate',
          isA<SingleCharPredicate>(),
        ),
      );
      expect(parser, isParseFailure('', message: '"a" expected'));
      expect(parser, isParseFailure('a', position: 1, message: '"a" expected'));
      expect(parser, isParseSuccess('aa', result: 'aa'));
      expect(parser, isParseSuccess('aaa', result: 'aaa'));
      expect(parser, isParseSuccess('aaaa', result: 'aaa', position: 3));
    });
    test('repeat unbounded', () {
      final input = 'a' * 100000;
      final parser = char('a').repeatString(2, unbounded);
      expect(
        parser,
        isA<RepeatingCharacterParser>().having(
          (parser) => parser.predicate,
          'predicate',
          isA<SingleCharPredicate>(),
        ),
      );
      expect(parser, isParseSuccess(input, result: input));
    });
    test('repeat erroneous', () {
      expect(
        () => char('a').repeatString(-1, 1),
        throwsA(
          isAssertionError.having(
            (exception) => exception.message,
            'message',
            'min must be at least 0, but got -1',
          ),
        ),
      );
      expect(
        () => char('a').repeatString(2, 1),
        throwsA(
          isAssertionError.having(
            (exception) => exception.message,
            'message',
            'max must be at least 2, but got 1',
          ),
        ),
      );
    }, skip: !hasAssertionsEnabled());
    test('times', () {
      final parser = char('a').timesString(2);
      expect(
        parser,
        isA<RepeatingCharacterParser>().having(
          (parser) => parser.predicate,
          'predicate',
          isA<SingleCharPredicate>(),
        ),
      );
      expect(parser, isParseFailure('', message: '"a" expected'));
      expect(parser, isParseFailure('a', position: 1, message: '"a" expected'));
      expect(parser, isParseSuccess('aa', result: 'aa'));
      expect(parser, isParseSuccess('aaa', result: 'aa', position: 2));
    });
    test('any', () {
      final parser = any().plusString();
      expect(
        parser,
        isA<RepeatingCharacterParser>().having(
          (parser) => parser.predicate,
          'predicate',
          isA<ConstantCharPredicate>(),
        ),
      );
      expect(parser, isParseFailure('', message: 'input expected'));
      expect(parser, isParseSuccess('a', result: 'a'));
      expect(parser, isParseSuccess('aa', result: 'aa'));
      expect(parser, isParseSuccess('aaa', result: 'aaa'));
    });
    test('any (unicode)', () {
      final parser = any(unicode: true).plusString();
      expect(
        parser,
        isA<FlattenParser>().having(
          (parser) => parser.delegate,
          'delegate',
          isA<PossessiveRepeatingParser<String>>(),
        ),
      );
      expect(parser, isParseFailure('', message: 'input expected'));
      expect(parser, isParseSuccess('a', result: 'a'));
      expect(parser, isParseSuccess('aa', result: 'aa'));
      expect(parser, isParseSuccess('aaa', result: 'aaa'));
    });
    test('fallback', () {
      final parser = char('a').settable().plusString();
      expect(
        parser,
        isA<FlattenParser>().having(
          (parser) => parser.delegate,
          'delegate',
          isA<PossessiveRepeatingParser<String>>(),
        ),
      );
      expect(parser, isParseFailure('', message: '"a" expected'));
      expect(parser, isParseSuccess('a', result: 'a'));
      expect(parser, isParseSuccess('aa', result: 'aa'));
      expect(parser, isParseSuccess('aaa', result: 'aaa'));
    });
  });
  group('separated', () {
    expectParserInvariants(digit().starSeparated(letter()));
    test('star', () {
      final parser = digit().starSeparated(letter());
      expect(
        parser,
        isParseSuccess('', result: isSeparatedList<String, String>()),
      );
      expect(
        parser,
        isParseSuccess(
          'a',
          result: isSeparatedList<String, String>(),
          position: 0,
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1',
          result: isSeparatedList<String, String>(elements: ['1']),
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a',
          result: isSeparatedList<String, String>(elements: ['1']),
          position: 1,
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2',
          result: isSeparatedList<String, String>(
            elements: ['1', '2'],
            separators: ['a'],
          ),
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b',
          result: isSeparatedList<String, String>(
            elements: ['1', '2'],
            separators: ['a'],
          ),
          position: 3,
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b3',
          result: isSeparatedList<String, String>(
            elements: ['1', '2', '3'],
            separators: ['a', 'b'],
          ),
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b3c',
          result: isSeparatedList<String, String>(
            elements: ['1', '2', '3'],
            separators: ['a', 'b'],
          ),
          position: 5,
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b3c4',
          result: isSeparatedList<String, String>(
            elements: ['1', '2', '3', '4'],
            separators: ['a', 'b', 'c'],
          ),
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b3c4d',
          result: isSeparatedList<String, String>(
            elements: ['1', '2', '3', '4'],
            separators: ['a', 'b', 'c'],
          ),
          position: 7,
        ),
      );
    });
    test('plus', () {
      final parser = digit().plusSeparated(letter());
      expect(parser, isParseFailure('', message: 'digit expected'));
      expect(parser, isParseFailure('a', message: 'digit expected'));
      expect(
        parser,
        isParseSuccess(
          '1',
          result: isSeparatedList<String, String>(elements: ['1']),
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a',
          result: isSeparatedList<String, String>(elements: ['1']),
          position: 1,
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2',
          result: isSeparatedList<String, String>(
            elements: ['1', '2'],
            separators: ['a'],
          ),
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b',
          result: isSeparatedList<String, String>(
            elements: ['1', '2'],
            separators: ['a'],
          ),
          position: 3,
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b3',
          result: isSeparatedList<String, String>(
            elements: ['1', '2', '3'],
            separators: ['a', 'b'],
          ),
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b3c',
          result: isSeparatedList<String, String>(
            elements: ['1', '2', '3'],
            separators: ['a', 'b'],
          ),
          position: 5,
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b3c4',
          result: isSeparatedList<String, String>(
            elements: ['1', '2', '3', '4'],
            separators: ['a', 'b', 'c'],
          ),
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b3c4d',
          result: isSeparatedList<String, String>(
            elements: ['1', '2', '3', '4'],
            separators: ['a', 'b', 'c'],
          ),
          position: 7,
        ),
      );
    });
    test('times', () {
      final parser = digit().timesSeparated(letter(), 3);
      expect(parser, isParseFailure('', message: 'digit expected'));
      expect(parser, isParseFailure('a', message: 'digit expected'));
      expect(
        parser,
        isParseFailure('1', message: 'letter expected', position: 1),
      );
      expect(
        parser,
        isParseFailure('1a', message: 'digit expected', position: 2),
      );
      expect(
        parser,
        isParseFailure('1a2', message: 'letter expected', position: 3),
      );
      expect(
        parser,
        isParseFailure('1a2b', message: 'digit expected', position: 4),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b3',
          result: isSeparatedList<String, String>(
            elements: ['1', '2', '3'],
            separators: ['a', 'b'],
          ),
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b3c',
          result: isSeparatedList<String, String>(
            elements: ['1', '2', '3'],
            separators: ['a', 'b'],
          ),
          position: 5,
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b3c4',
          result: isSeparatedList<String, String>(
            elements: ['1', '2', '3'],
            separators: ['a', 'b'],
          ),
          position: 5,
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b3c4d',
          result: isSeparatedList<String, String>(
            elements: ['1', '2', '3'],
            separators: ['a', 'b'],
          ),
          position: 5,
        ),
      );
    });
    test('repeat', () {
      final parser = digit().repeatSeparated(letter(), 2, 3);
      expect(parser, isParseFailure('', message: 'digit expected'));
      expect(parser, isParseFailure('a', message: 'digit expected'));
      expect(
        parser,
        isParseFailure('1', message: 'letter expected', position: 1),
      );
      expect(
        parser,
        isParseFailure('1a', message: 'digit expected', position: 2),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2',
          result: isSeparatedList<String, String>(
            elements: ['1', '2'],
            separators: ['a'],
          ),
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b',
          result: isSeparatedList<String, String>(
            elements: ['1', '2'],
            separators: ['a'],
          ),
          position: 3,
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b3',
          result: isSeparatedList<String, String>(
            elements: ['1', '2', '3'],
            separators: ['a', 'b'],
          ),
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b3c',
          result: isSeparatedList<String, String>(
            elements: ['1', '2', '3'],
            separators: ['a', 'b'],
          ),
          position: 5,
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b3c4',
          result: isSeparatedList<String, String>(
            elements: ['1', '2', '3'],
            separators: ['a', 'b'],
          ),
          position: 5,
        ),
      );
      expect(
        parser,
        isParseSuccess(
          '1a2b3c4d',
          result: isSeparatedList<String, String>(
            elements: ['1', '2', '3'],
            separators: ['a', 'b'],
          ),
          position: 5,
        ),
      );
    });
    group('separated list', () {
      final empty = SeparatedList<String, String>([], []);
      final single = SeparatedList<String, String>(['1'], []);
      final double = SeparatedList<String, String>(['1', '2'], ['+']);
      final triple = SeparatedList<String, String>(['1', '2', '3'], ['+', '-']);
      final quadruple = SeparatedList<String, String>(
        ['1', '2', '3', '4'],
        ['+', '-', '*'],
      );
      final mixed = SeparatedList<int, String>([1, 2, 3], ['+', '-']);
      String combinator(String first, String separator, String second) =>
          '($first$separator$second)';
      test('elements', () {
        expect(empty.elements, isEmpty);
        expect(single.elements, ['1']);
        expect(double.elements, ['1', '2']);
        expect(triple.elements, ['1', '2', '3']);
        expect(quadruple.elements, ['1', '2', '3', '4']);
        expect(mixed.elements, [1, 2, 3]);
      });
      test('separators', () {
        expect(empty.separators, isEmpty);
        expect(single.separators, isEmpty);
        expect(double.separators, ['+']);
        expect(triple.separators, ['+', '-']);
        expect(quadruple.separators, ['+', '-', '*']);
        expect(mixed.separators, ['+', '-']);
      });
      test('sequence', () {
        expect(empty.sequential, isEmpty);
        expect(single.sequential, ['1']);
        expect(double.sequential, ['1', '+', '2']);
        expect(triple.sequential, ['1', '+', '2', '-', '3']);
        expect(quadruple.sequential, ['1', '+', '2', '-', '3', '*', '4']);
        expect(mixed.sequential, [1, '+', 2, '-', 3]);
      });
      test('foldLeft', () {
        expect(() => empty.foldLeft(combinator), throwsStateError);
        expect(single.foldLeft(combinator), '1');
        expect(double.foldLeft(combinator), '(1+2)');
        expect(triple.foldLeft(combinator), '((1+2)-3)');
        expect(quadruple.foldLeft(combinator), '(((1+2)-3)*4)');
      });
      test('foldRight', () {
        expect(() => empty.foldRight(combinator), throwsStateError);
        expect(single.foldRight(combinator), '1');
        expect(double.foldRight(combinator), '(1+2)');
        expect(triple.foldRight(combinator), '(1+(2-3))');
        expect(quadruple.foldRight(combinator), '(1+(2-(3*4)))');
      });
      test('toString', () {
        expect(
          empty.toString(),
          stringContainsInOrder(['SeparatedList', '<String, String>()']),
        );
        expect(
          single.toString(),
          stringContainsInOrder(['SeparatedList', '<String, String>(1)']),
        );
        expect(
          double.toString(),
          stringContainsInOrder(['SeparatedList', '(1, +, 2)']),
        );
        expect(
          triple.toString(),
          stringContainsInOrder(['SeparatedList', '(1, +, 2, -, 3)']),
        );
        expect(
          quadruple.toString(),
          stringContainsInOrder(['SeparatedList', '(1, +, 2, -, 3, *, 4)']),
        );
        expect(
          mixed.toString(),
          stringContainsInOrder(['SeparatedList', '(1, +, 2, -, 3)']),
        );
      });
    });
  });
}