test/glob_test.dart

// Copyright (c) 2014, 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:glob/glob.dart';
import 'package:path/path.dart' as p;
import 'package:test/test.dart';

void main() {
  group('Glob.quote()', () {
    test('quotes all active characters', () {
      expect(Glob.quote('*{[?\\}],-'), equals(r'\*\{\[\?\\\}\]\,\-'));
    });

    test("doesn't quote inactive characters", () {
      expect(Glob.quote('abc~`_+='), equals('abc~`_+='));
    });
  });

  group('Glob.matches()', () {
    test('returns whether the path matches the glob', () {
      var glob = Glob('foo*');
      expect(glob.matches('foobar'), isTrue);
      expect(glob.matches('baz'), isFalse);
    });

    test('only matches the entire path', () {
      var glob = Glob('foo');
      expect(glob.matches('foo/bar'), isFalse);
      expect(glob.matches('bar/foo'), isFalse);
    });
  });

  group('Glob.matchAsPrefix()', () {
    test('returns a match if the path matches the glob', () {
      var glob = Glob('foo*');
      expect(glob.matchAsPrefix('foobar'), isA<Match>());
      expect(glob.matchAsPrefix('baz'), isNull);
    });

    test('returns null for start > 0', () {
      var glob = Glob('*');
      expect(glob.matchAsPrefix('foobar', 1), isNull);
    });
  });

  group('Glob.allMatches()', () {
    test('returns a single match if the path matches the glob', () {
      var matches = Glob('foo*').allMatches('foobar');
      expect(matches, hasLength(1));
      expect(matches.first, isA<Match>());
    });

    test("returns an empty list if the path doesn't match the glob", () {
      expect(Glob('foo*').allMatches('baz'), isEmpty);
    });

    test('returns no matches for start > 0', () {
      var glob = Glob('*');
      expect(glob.allMatches('foobar', 1), isEmpty);
    });
  });

  group('GlobMatch', () {
    var glob = Glob('foo*');
    var match = glob.matchAsPrefix('foobar')!;

    test('returns the string as input', () {
      expect(match.input, equals('foobar'));
    });

    test('returns the glob as the pattern', () {
      expect(match.pattern, equals(glob));
    });

    test('returns the span of the string for start and end', () {
      expect(match.start, equals(0));
      expect(match.end, equals('foobar'.length));
    });

    test('has a single group that contains the whole string', () {
      expect(match.groupCount, equals(0));
      expect(match[0], equals('foobar'));
      expect(match.group(0), equals('foobar'));
      expect(match.groups([0]), equals(['foobar']));
    });

    test('throws a range error for an invalid group', () {
      expect(() => match[1], throwsRangeError);
      expect(() => match[-1], throwsRangeError);
      expect(() => match.group(1), throwsRangeError);
      expect(() => match.groups([1]), throwsRangeError);
    });
  });

  test('globs are case-sensitive by default for Posix and URL contexts', () {
    expect('foo', contains(Glob('foo', context: p.posix)));
    expect('FOO', isNot(contains(Glob('foo', context: p.posix))));
    expect('foo', isNot(contains(Glob('FOO', context: p.posix))));

    expect('foo', contains(Glob('foo', context: p.url)));
    expect('FOO', isNot(contains(Glob('foo', context: p.url))));
    expect('foo', isNot(contains(Glob('FOO', context: p.url))));
  });

  test('globs are case-insensitive by default for Windows contexts', () {
    expect('foo', contains(Glob('foo', context: p.windows)));
    expect('FOO', contains(Glob('foo', context: p.windows)));
    expect('foo', contains(Glob('FOO', context: p.windows)));
  });
}