pkgs/checks/test/extensions/string_test.dart

// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'package:checks/checks.dart';
import 'package:test/scaffolding.dart';

import '../test_shared.dart';

void main() {
  group('StringChecks', () {
    test('contains', () {
      check('bob').contains('bo');
      check('bob').isRejectedBy(
        (it) => it.contains('kayleb'),
        which: ["Does not contain 'kayleb'"],
      );
    });
    test('length', () {
      check('bob').length.equals(3);
    });
    test('isEmpty', () {
      check('').isEmpty();
      check('bob').isRejectedBy((it) => it.isEmpty(), which: ['is not empty']);
    });
    test('isNotEmpty', () {
      check('bob').isNotEmpty();
      check('').isRejectedBy((it) => it.isNotEmpty(), which: ['is empty']);
    });
    test('startsWith', () {
      check('bob').startsWith('bo');
      check('bob').isRejectedBy(
        (it) => it.startsWith('kayleb'),
        which: ["does not start with 'kayleb'"],
      );
    });
    test('endsWith', () {
      check('bob').endsWith('ob');
      check('bob').isRejectedBy(
        (it) => it.endsWith('kayleb'),
        which: ["does not end with 'kayleb'"],
      );
    });

    group('matches', () {
      test('succeeds for strings that match a regex', () {
        check('123').matchesPattern(RegExp(r'\d\d\d'));
      });
      test('succeeds for strings that match a string pattern', () {
        check(r'\d').matchesPattern(r'\d');
      });
      test('fails for non-matching regex', () {
        check('abc').isRejectedBy(
          (it) => it.matchesPattern(RegExp(r'\d\d\d')),
          which: [r'does not match <RegExp: pattern=\d\d\d flags=>'],
        );
      });
      test('fails for non-matching string pattern', () {
        // A string is _not_ converted to a regex, string patterns must match
        // directly.
        check('123').isRejectedBy(
          (it) => it.matchesPattern(r'\d\d\d'),
          which: [r"does not match '\\d\\d\\d'"],
        );
      });
      test('can be described', () {
        check((Subject<String> it) => it.matchesPattern(RegExp(r'\d\d\d')))
            .description
            .deepEquals([r'  matches <RegExp: pattern=\d\d\d flags=>']);
        check(
          (Subject<String> it) => it.matchesPattern('abc'),
        ).description.deepEquals([r"  matches 'abc'"]);
      });
    });

    group('containsInOrder', () {
      test('happy case', () {
        check('foo bar baz').containsInOrder(['foo', 'baz']);
      });
      test('reports when first substring is missing', () {
        check('baz').isRejectedBy(
          (it) => it.containsInOrder(['foo', 'baz']),
          which: ['does not have a match for the substring \'foo\''],
        );
      });
      test('reports when substring is missing following a match', () {
        check('foo bar').isRejectedBy(
          (it) => it.containsInOrder(['foo', 'baz']),
          which: [
            'does not have a match for the substring \'baz\'',
            'following the other matches up to character 3',
          ],
        );
      });
    });

    group('equals', () {
      test('succeeeds for happy case', () {
        check('foo').equals('foo');
      });
      test('succeeeds for equal empty strings', () {
        check('').equals('');
      });
      test('reports extra characters for long string', () {
        check('foobar').isRejectedBy(
          (it) => it.equals('foo'),
          which: ['is too long with unexpected trailing characters:', 'bar'],
        );
      });
      test('reports extra characters for long string against empty', () {
        check('foo').isRejectedBy(
          (it) => it.equals(''),
          which: ['is not the empty string'],
        );
      });
      test('reports truncated extra characters for very long string', () {
        check('foobar baz more stuff').isRejectedBy(
          (it) => it.equals('foo'),
          which: [
            'is too long with unexpected trailing characters:',
            'bar baz mo ...',
          ],
        );
      });
      test('reports missing characters for short string', () {
        check('foo').isRejectedBy(
          (it) => it.equals('foobar'),
          which: ['is too short with missing trailing characters:', 'bar'],
        );
      });
      test('reports missing characters for empty string', () {
        check('').isRejectedBy(
          (it) => it.equals('foo bar baz'),
          actual: ['an empty string'],
          which: ['is missing all expected characters:', 'foo bar ba ...'],
        );
      });
      test('reports truncated missing characters for very short string', () {
        check('foo').isRejectedBy(
          (it) => it.equals('foobar baz more stuff'),
          which: [
            'is too short with missing trailing characters:',
            'bar baz mo ...',
          ],
        );
      });
      test('reports index of different character', () {
        check('hit').isRejectedBy(
          (it) => it.equals('hat'),
          which: ['differs at offset 1:', '  hat', '  hit', '   ^'],
        );
      });
      test(
        'reports truncated index of different character in large string',
        () {
          check('blah blah blah hit blah blah blah').isRejectedBy(
            (it) => it.equals('blah blah blah hat blah blah blah'),
            which: [
              'differs at offset 16:',
              '  ... lah blah hat blah bl ...',
              '  ... lah blah hit blah bl ...',
              '                ^',
            ],
          );
        },
      );
    });

    group('equalsIgnoringCase', () {
      test('succeeeds for happy case', () {
        check('FOO').equalsIgnoringCase('foo');
        check('foo').equalsIgnoringCase('FOO');
      });
      test('reports original extra characters for long string', () {
        check('FOOBAR').isRejectedBy(
          (it) => it.equalsIgnoringCase('foo'),
          which: ['is too long with unexpected trailing characters:', 'BAR'],
        );
      });
      test('reports original missing characters for short string', () {
        check('FOO').isRejectedBy(
          (it) => it.equalsIgnoringCase('fooBAR'),
          which: ['is too short with missing trailing characters:', 'BAR'],
        );
      });
      test('reports index of different character with original characters', () {
        check('HiT').isRejectedBy(
          (it) => it.equalsIgnoringCase('hAt'),
          which: ['differs at offset 1:', '  hAt', '  HiT', '   ^'],
        );
      });
    });

    group('equalsIgnoringWhitespace', () {
      test('allows differing internal whitespace', () {
        check('foo \t\n bar').equalsIgnoringWhitespace('foo bar');
      });
      test('allows extra leading/trailing whitespace', () {
        check(' foo ').equalsIgnoringWhitespace('foo');
      });
      test('allows missing leading/trailing whitespace', () {
        check('foo').equalsIgnoringWhitespace(' foo ');
      });
      test('reports original extra characters for long string', () {
        check('foo \t bar \n baz').isRejectedBy(
          (it) => it.equalsIgnoringWhitespace('foo bar'),
          which: ['is too long with unexpected trailing characters:', ' baz'],
        );
      });
      test('reports original missing characters for short string', () {
        check('foo  bar').isRejectedBy(
          (it) => it.equalsIgnoringWhitespace('foo bar baz'),
          which: ['is too short with missing trailing characters:', ' baz'],
        );
      });
      test('reports index of different character with original characters', () {
        check('x  hit  x').isRejectedBy(
          (it) => it.equalsIgnoringWhitespace('x hat x'),
          which: ['differs at offset 3:', '  x hat x', '  x hit x', '     ^'],
        );
      });
    });
  });
}