text: /*!
   * parse-glob <https://github.com/jonschlinkert/parse-glob>
   *
   * Copyright (c) 2015, Jon Schlinkert.
   * Licensed under the MIT License.
   */
  
  'use strict';
  
  var assert = require('assert');
  var parse = require('./');
  
  describe('`is` object:', function () {
    it('should detect when special characters are in a pattern:', function () {
      assert.equal(parse('!**{}[:[@()').is.negated, true);
      assert.equal(parse('!**{}[:[@()').is.glob, true);
      assert.equal(parse('!**{}[:[@()').is.extglob, true);
      assert.equal(parse('!**{}[:[@()').is.brackets, true);
      assert.equal(parse('!**{}[:[@()').is.braces, true);
    });
  
    it('should detect when the pattern is a glob pattern:', function () {
      assert.equal(parse('a.min.js').is.glob, false);
      assert.equal(parse('*.min.js').is.glob, true);
      assert.equal(parse('foo/{a,b}.min.js').is.glob, true);
      assert.equal(parse('foo/(a|b).min.js').is.glob, true);
      assert.equal(parse('foo/[a-b].min.js').is.glob, true);
      assert.equal(parse('!foo').is.glob, true);
    });
  
    it('should detect when a pattern is negated:', function () {
      assert.equal(parse('a.min.js').is.negated, false);
      assert.equal(parse('!*.min.js').is.negated, true);
      assert.equal(parse('!foo/{a,b}.min.js').is.negated, true);
      assert.equal(parse('!foo/(a|b).min.js').is.negated, true);
      assert.equal(parse('!foo/[a-b].min.js').is.negated, true);
      assert.equal(parse('foo').is.negated, false);
    });
  
    it('should detect when a pattern has a globstar:', function () {
      assert.equal(parse('**').is.globstar, true);
      assert.equal(parse('**/*.min.js').is.globstar, true);
      assert.equal(parse('**/*foo.js').is.globstar, true);
      assert.equal(parse('*/*').is.globstar, false);
      assert.equal(parse('*/*/**/a.js').is.globstar, true);
      assert.equal(parse('a.min.js').is.globstar, false);
      assert.equal(parse('!*.min.js').is.globstar, false);
      assert.equal(parse('!foo/{a,b}.min.js').is.globstar, false);
      assert.equal(parse('!foo/(a|b).min.js').is.globstar, false);
      assert.equal(parse('!foo/[a-b].min.js').is.globstar, false);
      assert.equal(parse('foo').is.globstar, false);
    });
  
    it('should detect when a pattern has brace patterns:', function () {
      assert.equal(parse('a/b/c').is.braces, false);
      assert.equal(parse('**/*.{js,min.js}').is.braces, true);
      assert.equal(parse('**/*{bar,foo}.js').is.braces, true);
    });
  });
  
  describe('should get a base path:', function () {
    it('should extract a base path from a glob pattern:', function () {
      assert.equal(parse('.*').base, '.');
      assert.equal(parse('.*').glob, '.*');
  
      assert.equal(parse('./*').base, '.');
      assert.equal(parse('./*').glob, '*');
  
      assert.equal(parse('*').base, '.');
      assert.equal(parse('*').glob, '*');
  
      assert.equal(parse('**').base, '.');
      assert.equal(parse('**').glob, '**');
  
      assert.equal(parse('**/*.md').base, '.');
      assert.equal(parse('**/*.md').glob, '**/*.md');
  
      assert.equal(parse('**/*.min.js').base, '.');
      assert.equal(parse('**/*.min.js').glob, '**/*.min.js');
  
      assert.equal(parse('**/*foo.js').base, '.');
      assert.equal(parse('**/*foo.js').glob, '**/*foo.js');
  
      assert.equal(parse('**/.*').base, '.');
      assert.equal(parse('**/.*').glob, '**/.*');
  
      assert.equal(parse('**/d').base, '.');
      assert.equal(parse('**/d').glob, '**/d');
  
      assert.equal(parse('*.*').base, '.');
      assert.equal(parse('*.*').glob, '*.*');
  
      assert.equal(parse('*.js').base, '.');
      assert.equal(parse('*.js').glob, '*.js');
  
      assert.equal(parse('*.md').base, '.');
      assert.equal(parse('*.md').glob, '*.md');
  
      assert.equal(parse('*.min.js').base, '.');
      assert.equal(parse('*.min.js').glob, '*.min.js');
  
      assert.equal(parse('*/*').base, '.');
      assert.equal(parse('*/*').glob, '*/*');
  
      assert.equal(parse('*/*/*/*').base, '.');
      assert.equal(parse('*/*/*/*').glob, '*/*/*/*');
  
      assert.equal(parse('*/*/*/e').base, '.');
      assert.equal(parse('*/*/*/e').glob, '*/*/*/e');
  
      assert.equal(parse('*/b/*/e').base, '.');
      assert.equal(parse('*/b/*/e').glob, '*/b/*/e');
  
      assert.equal(parse('*b').base, '.');
      assert.equal(parse('*b').glob, '*b');
  
      assert.equal(parse('./a/**/j/**/z/*.md').base, './a');
      assert.equal(parse('./a/**/j/**/z/*.md').glob, '**/j/**/z/*.md');
  
      assert.equal(parse('./a/**/z/*.md').base, './a');
      assert.equal(parse('./a/**/z/*.md').glob, '**/z/*.md');
  
      assert.equal(parse('./{a/b/{c,/foo.js}/e.f.g}').base, '.');
      assert.equal(parse('./{a/b/{c,/foo.js}/e.f.g}').glob, '{a/b/{c,/foo.js}/e.f.g}');
  
      assert.equal(parse('./node_modules/*-glob/**/*.js').base, './node_modules');
      assert.equal(parse('./node_modules/*-glob/**/*.js').glob, '*-glob/**/*.js');
  
      assert.equal(parse('a/b/{c,/.gitignore}').base, 'a/b');
      assert.equal(parse('a/b/{c,/.gitignore}').glob, '{c,/.gitignore}');
  
      assert.equal(parse('a/b/.{foo,bar}').base, 'a/b');
      assert.equal(parse('a/b/.{foo,bar}').glob, '.{foo,bar}');
  
      assert.equal(parse('a/b/*.{foo,bar}').base, 'a/b');
      assert.equal(parse('a/b/*.{foo,bar}').glob, '*.{foo,bar}');
  
      assert.equal(parse('a/**/b/*.{foo,bar}').base, 'a');
      assert.equal(parse('a/**/b/*.{foo,bar}').glob, '**/b/*.{foo,bar}');
  
      assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').base, 'a/b');
      assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').glob, '{c,.gitignore,{a,b}}/{a,b}/abc.foo.js');
  
      assert.equal(parse('a/b/{c,d}/').base, 'a/b');
      assert.equal(parse('a/b/{c,d}/').glob, '{c,d}/');
  
      assert.equal(parse('a/b/{c,d}/e/f.g').base, 'a/b');
      assert.equal(parse('a/b/{c,d}/e/f.g').glob, '{c,d}/e/f.g');
  
      assert.equal(parse('.a*').base, '.');
      assert.equal(parse('.a*').glob, '.a*');
  
      assert.equal(parse('.b*').base, '.');
      assert.equal(parse('.b*').glob, '.b*');
  
      assert.equal(parse('/*').base, '/');
      assert.equal(parse('/*').glob, '*');
  
      assert.equal(parse('a/***').base, 'a');
      assert.equal(parse('a/***').glob, '***');
  
      assert.equal(parse('a/**/b/*.{foo,bar}').base, 'a');
      assert.equal(parse('a/**/b/*.{foo,bar}').glob, '**/b/*.{foo,bar}');
  
      assert.equal(parse('a/**/c/*').base, 'a');
      assert.equal(parse('a/**/c/*').glob, '**/c/*');
  
      assert.equal(parse('a/**/c/*.md').base, 'a');
      assert.equal(parse('a/**/c/*.md').glob, '**/c/*.md');
  
      assert.equal(parse('a/**/e').base, 'a');
      assert.equal(parse('a/**/e').glob, '**/e');
  
      assert.equal(parse('a/**/j/**/z/*.md').base, 'a');
      assert.equal(parse('a/**/j/**/z/*.md').glob, '**/j/**/z/*.md');
  
      assert.equal(parse('a/**/z/*.md').base, 'a');
      assert.equal(parse('a/**/z/*.md').glob, '**/z/*.md');
  
      assert.equal(parse('a/**c*').base, 'a');
      assert.equal(parse('a/**c*').glob, '**c*');
  
      assert.equal(parse('a/**c/*').base, 'a');
      assert.equal(parse('a/**c/*').glob, '**c/*');
  
      assert.equal(parse('a/*/*/e').base, 'a');
      assert.equal(parse('a/*/*/e').glob, '*/*/e');
  
      assert.equal(parse('a/*/c/*.md').base, 'a');
      assert.equal(parse('a/*/c/*.md').glob, '*/c/*.md');
  
      assert.equal(parse('a/b/**/c{d,e}/**/xyz.md').base, 'a/b');
      assert.equal(parse('a/b/**/c{d,e}/**/xyz.md').glob, '**/c{d,e}/**/xyz.md');
  
      assert.equal(parse('a/b/**/e').base, 'a/b');
      assert.equal(parse('a/b/**/e').glob, '**/e');
  
      assert.equal(parse('a/b/*.{foo,bar}').base, 'a/b');
      assert.equal(parse('a/b/*.{foo,bar}').glob, '*.{foo,bar}');
  
      assert.equal(parse('a/b/*/e').base, 'a/b');
      assert.equal(parse('a/b/*/e').glob, '*/e');
  
      assert.equal(parse('a/b/c/*').base, 'a/b/c');
      assert.equal(parse('a/b/c/*').glob, '*');
  
      assert.equal(parse('a/b/c/*.md').base, 'a/b/c');
      assert.equal(parse('a/b/c/*.md').glob, '*.md');
  
      assert.equal(parse('a/b/c/.*.md').base, 'a/b/c');
      assert.equal(parse('a/b/c/.*.md').glob, '.*.md');
  
      assert.equal(parse('b/*/*/*').base, 'b');
      assert.equal(parse('b/*/*/*').glob, '*/*/*');
    });
  
    it('file extensions:', function () {
      assert.equal(parse('.md').base, '.');
      assert.equal(parse('.md').glob, '.md');
    });
  
    it('negation pattern:', function () {
      assert.equal(parse('!*.min.js').base, '.');
      assert.equal(parse('!*.min.js').glob, '!*.min.js');
  
      assert.equal(parse('!foo').base, '.');
      assert.equal(parse('!foo').glob, '!foo');
  
      assert.equal(parse('a/b/c/!foo').base, 'a/b/c');
      assert.equal(parse('a/b/c/!foo').glob, '!foo');
  
      assert.equal(parse('!foo/(a|b).min.js').base, '.');
      assert.equal(parse('!foo/(a|b).min.js').glob, '!foo/(a|b).min.js');
  
      assert.equal(parse('!foo/[a-b].min.js').base, '.');
      assert.equal(parse('!foo/[a-b].min.js').glob, '!foo/[a-b].min.js');
  
      assert.equal(parse('!foo/{a,b}.min.js').base, '.');
      assert.equal(parse('!foo/{a,b}.min.js').glob, '!foo/{a,b}.min.js');
    });
  
    describe('braces:', function () {
      it('should know when a base cannot be extracted:', function () {
        assert.equal(parse('/a/b/{c,/foo.js}/e.f.g/').base, '/a/b');
        assert.equal(parse('/a/b/{c,/foo.js}/e.f.g/').glob, '{c,/foo.js}/e.f.g/');
  
        assert.equal(parse('{a/b/c.js,/a/b/{c,/foo.js}/e.f.g/}').base, '.');
        assert.equal(parse('{a/b/c.js,/a/b/{c,/foo.js}/e.f.g/}').glob, '{a/b/c.js,/a/b/{c,/foo.js}/e.f.g/}');
  
        assert.equal(parse('/a/b/{c,d}/').base, '/a/b');
        assert.equal(parse('/a/b/{c,d}/').glob, '{c,d}/');
  
        assert.equal(parse('/a/b/{c,d}/*.js').base, '/a/b');
        assert.equal(parse('/a/b/{c,d}/*.js').glob, '{c,d}/*.js');
  
        assert.equal(parse('/a/b/{c,d}/*.min.js').base, '/a/b');
        assert.equal(parse('/a/b/{c,d}/*.min.js').glob, '{c,d}/*.min.js');
  
        assert.equal(parse('/a/b/{c,d}/e.f.g/').base, '/a/b');
        assert.equal(parse('/a/b/{c,d}/e.f.g/').glob, '{c,d}/e.f.g/');
  
        assert.equal(parse('{.,*}').base, '.');
        assert.equal(parse('{.,*}').glob, '{.,*}');
      });
  
      it('should work when the basename has braces:', function () {
        assert.equal(parse('a/b/.{c,.gitignore}').base, 'a/b');
        assert.equal(parse('a/b/.{c,.gitignore}').glob, '.{c,.gitignore}');
  
        assert.equal(parse('a/b/.{c,/.gitignore}').base, 'a/b');
        assert.equal(parse('a/b/.{c,/.gitignore}').glob, '.{c,/.gitignore}');
  
        assert.equal(parse('a/b/.{foo,bar}').base, 'a/b');
        assert.equal(parse('a/b/.{foo,bar}').glob, '.{foo,bar}');
  
        assert.equal(parse('a/b/{c,.gitignore}').base, 'a/b');
        assert.equal(parse('a/b/{c,.gitignore}').glob, '{c,.gitignore}');
  
        assert.equal(parse('a/b/{c,/.gitignore}').base, 'a/b');
        assert.equal(parse('a/b/{c,/.gitignore}').glob, '{c,/.gitignore}');
  
        assert.equal(parse('a/b/{c,/gitignore}').base, 'a/b');
        assert.equal(parse('a/b/{c,/gitignore}').glob, '{c,/gitignore}');
  
        assert.equal(parse('a/b/{c,d}').base, 'a/b');
        assert.equal(parse('a/b/{c,d}').glob, '{c,d}');
      });
  
      it('should work when the dirname has braces:', function () {
        assert.equal(parse('a/b/{c,./d}/e/f.g').base, 'a/b');
        assert.equal(parse('a/b/{c,./d}/e/f.g').glob, '{c,./d}/e/f.g');
  
        assert.equal(parse('a/b/{c,./d}/e/f.min.g').base, 'a/b');
        assert.equal(parse('a/b/{c,./d}/e/f.min.g').glob, '{c,./d}/e/f.min.g');
  
        assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').base, 'a/b');
        assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').glob, '{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js');
  
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').base, 'a/b');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').glob, '{c,.gitignore,{a,b}}/{a,b}/*.foo.js');
  
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').base, 'a/b');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').glob, '{c,.gitignore,{a,b}}/{a,b}/abc.foo.js');
  
        assert.equal(parse('a/b/{c,/d}/e/f.g').base, 'a/b');
        assert.equal(parse('a/b/{c,/d}/e/f.g').glob, '{c,/d}/e/f.g');
  
        assert.equal(parse('a/b/{c,/d}/e/f.min.g').base, 'a/b');
        assert.equal(parse('a/b/{c,/d}/e/f.min.g').glob, '{c,/d}/e/f.min.g');
  
        assert.equal(parse('a/b/{c,d}/').base, 'a/b');
        assert.equal(parse('a/b/{c,d}/').glob, '{c,d}/');
  
        assert.equal(parse('a/b/{c,d}/*.js').base, 'a/b');
        assert.equal(parse('a/b/{c,d}/*.js').glob, '{c,d}/*.js');
  
        assert.equal(parse('a/b/{c,d}/*.min.js').base, 'a/b');
        assert.equal(parse('a/b/{c,d}/*.min.js').glob, '{c,d}/*.min.js');
  
        assert.equal(parse('a/b/{c,d}/e.f.g/').base, 'a/b');
        assert.equal(parse('a/b/{c,d}/e.f.g/').glob, '{c,d}/e.f.g/');
  
        assert.equal(parse('a/b/{c,d}/e/f.g').base, 'a/b');
        assert.equal(parse('a/b/{c,d}/e/f.g').glob, '{c,d}/e/f.g');
  
        assert.equal(parse('a/b/{c,d}/e/f.min.g').base, 'a/b');
        assert.equal(parse('a/b/{c,d}/e/f.min.g').glob, '{c,d}/e/f.min.g');
  
        assert.equal(parse('foo/{a,b}.min.js').base, 'foo');
        assert.equal(parse('foo/{a,b}.min.js').glob, '{a,b}.min.js');
      });
    });
  
    it('character classes:', function () {
      assert.equal(parse('/[.]bashrc').base, '/');
      assert.equal(parse('/[.]bashrc').glob, '[.]bashrc');
      assert.equal(parse('/[.]bashrc').path.basename, '[.]bashrc');
      assert.equal(parse('/[.]bashrc').path.filename, '[.]bashrc');
      assert.equal(parse('/[.]bashrc').path.extname, '');
  
      assert.equal(parse('[a-c]b*').base, '.');
      assert.equal(parse('[a-c]b*').glob, '[a-c]b*');
  
      assert.equal(parse('[a-j]*[^c]').base, '.');
      assert.equal(parse('[a-j]*[^c]').glob, '[a-j]*[^c]');
  
      assert.equal(parse('[a-j]*[^c]b/c').base, '.');
      assert.equal(parse('[a-j]*[^c]b/c').glob, '[a-j]*[^c]b/c');
  
      assert.equal(parse('[a-j]*[^c]bc').base, '.');
      assert.equal(parse('[a-j]*[^c]bc').glob, '[a-j]*[^c]bc');
  
      assert.equal(parse('[ab][ab]').base, '.');
      assert.equal(parse('[ab][ab]').glob, '[ab][ab]');
  
      assert.equal(parse('foo/[a-b].min.js').base, 'foo');
      assert.equal(parse('foo/[a-b].min.js').glob, '[a-b].min.js');
    });
  
    it('qmarks:', function () {
      assert.equal(parse('?').base, '.');
      assert.equal(parse('?').glob, '?');
  
      assert.equal(parse('?/?').base, '.');
      assert.equal(parse('?/?').glob, '?/?');
  
      assert.equal(parse('??').base, '.');
      assert.equal(parse('??').glob, '??');
  
      assert.equal(parse('???').base, '.');
      assert.equal(parse('???').glob, '???');
  
      assert.equal(parse('?a').base, '.');
      assert.equal(parse('?a').glob, '?a');
  
      assert.equal(parse('?b').base, '.');
      assert.equal(parse('?b').glob, '?b');
  
      assert.equal(parse('a?b').base, '.');
      assert.equal(parse('a?b').glob, 'a?b');
  
      assert.equal(parse('a/?/c.js').base, 'a');
      assert.equal(parse('a/?/c.js').glob, '?/c.js');
  
      assert.equal(parse('a/?/c.md').base, 'a');
      assert.equal(parse('a/?/c.md').glob, '?/c.md');
  
      assert.equal(parse('a/?/c/?/*/f.js').base, 'a');
      assert.equal(parse('a/?/c/?/*/f.js').glob, '?/c/?/*/f.js');
  
      assert.equal(parse('a/?/c/?/*/f.md').base, 'a');
      assert.equal(parse('a/?/c/?/*/f.md').glob, '?/c/?/*/f.md');
  
      assert.equal(parse('a/?/c/?/e.js').base, 'a');
      assert.equal(parse('a/?/c/?/e.js').glob, '?/c/?/e.js');
  
      assert.equal(parse('a/?/c/?/e.md').base, 'a');
      assert.equal(parse('a/?/c/?/e.md').glob, '?/c/?/e.md');
  
      assert.equal(parse('a/?/c/???/e.js').base, 'a');
      assert.equal(parse('a/?/c/???/e.js').glob, '?/c/???/e.js');
  
      assert.equal(parse('a/?/c/???/e.md').base, 'a');
      assert.equal(parse('a/?/c/???/e.md').glob, '?/c/???/e.md');
  
      assert.equal(parse('a/??/c.js').base, 'a');
      assert.equal(parse('a/??/c.js').glob, '??/c.js');
  
      assert.equal(parse('a/??/c.md').base, 'a');
      assert.equal(parse('a/??/c.md').glob, '??/c.md');
  
      assert.equal(parse('a/???/c.js').base, 'a');
      assert.equal(parse('a/???/c.js').glob, '???/c.js');
  
      assert.equal(parse('a/???/c.md').base, 'a');
      assert.equal(parse('a/???/c.md').glob, '???/c.md');
  
      assert.equal(parse('a/????/c.js').base, 'a');
      assert.equal(parse('a/????/c.js').glob, '????/c.js');
    });
  
    it('non-glob pattern:', function () {
      assert.equal(parse('').base, '.');
      assert.equal(parse('').glob, '');
  
      assert.equal(parse('.').base, '.');
      assert.equal(parse('.').glob, '.');
  
      assert.equal(parse('a').base, '.');
      assert.equal(parse('a').glob, 'a');
  
      assert.equal(parse('.a').base, '.');
      assert.equal(parse('.a').glob, '.a');
  
      assert.equal(parse('/a').base, '/');
      assert.equal(parse('/a').glob, 'a');
  
      assert.equal(parse('/a/b/c').base, '/a/b');
      assert.equal(parse('/a/b/c').glob, 'c');
  
      assert.equal(parse('/a/b/c/').base, '/a/b/c/');
      assert.equal(parse('/a/b/c/').glob, '');
  
      assert.equal(parse('a/b/c/').base, 'a/b/c/');
      assert.equal(parse('a/b/c/').glob, '');
  
      assert.equal(parse('a.min.js').base, '.');
      assert.equal(parse('a.min.js').glob, 'a.min.js');
  
      assert.equal(parse('a/.x.md').base, 'a');
      assert.equal(parse('a/.x.md').glob, '.x.md');
  
      assert.equal(parse('a/b/.gitignore').base, 'a/b');
      assert.equal(parse('a/b/.gitignore').glob, '.gitignore');
  
      assert.equal(parse('a/b/c/d.md').base, 'a/b/c');
      assert.equal(parse('a/b/c/d.md').glob, 'd.md');
  
      assert.equal(parse('a/b/c/d.e.f/g.min.js').base, 'a/b/c/d.e.f');
      assert.equal(parse('a/b/c/d.e.f/g.min.js').glob, 'g.min.js');
  
      assert.equal(parse('a/b/.git').base, 'a/b');
      assert.equal(parse('a/b/.git').glob, '.git');
  
      assert.equal(parse('a/b/.git/').base, 'a/b/.git/');
      assert.equal(parse('a/b/.git/').glob, '');
  
      assert.equal(parse('a/b/.gitignore').base, 'a/b');
      assert.equal(parse('a/b/.gitignore').glob, '.gitignore');
  
      assert.equal(parse('a/b/c').base, 'a/b');
      assert.equal(parse('a/b/c').glob, 'c');
  
      assert.equal(parse('a/b/c.d/e.md').base, 'a/b/c.d');
      assert.equal(parse('a/b/c.d/e.md').glob, 'e.md');
  
      assert.equal(parse('a/b/c.md').base, 'a/b');
      assert.equal(parse('a/b/c.md').glob, 'c.md');
  
      assert.equal(parse('a/b/c.min.js').base, 'a/b');
      assert.equal(parse('a/b/c.min.js').glob, 'c.min.js');
  
      assert.equal(parse('a/b/c/').base, 'a/b/c/');
      assert.equal(parse('a/b/c/').glob, '');
  
      assert.equal(parse('a/b/c/d.e.f/g.min.js').base, 'a/b/c/d.e.f');
      assert.equal(parse('a/b/c/d.e.f/g.min.js').glob, 'g.min.js');
  
      assert.equal(parse('a/b/c/d.md').base, 'a/b/c');
      assert.equal(parse('a/b/c/d.md').glob, 'd.md');
  
      assert.equal(parse('a/b/git/').base, 'a/b/git/');
      assert.equal(parse('a/b/git/').glob, '');
  
      assert.equal(parse('aa').base, '.');
      assert.equal(parse('aa').glob, 'aa');
  
      assert.equal(parse('c.md').base, '.');
      assert.equal(parse('c.md').glob, 'c.md');
    });
  });
  
  describe('path parts:', function () {
    describe('complex patterns:', function () {
      it('should get a dirname:', function () {
        assert.equal(parse('*.min.js').base, '.');
        assert.equal(parse('/a/b/c').base, '/a/b');
        assert.equal(parse('/a/b/c/').base, '/a/b/c/');
        assert.equal(parse('/a/b/{c,d}/').base, '/a/b');
        assert.equal(parse('/a/b/{c,d}/*.js').base, '/a/b');
        assert.equal(parse('/a/b/{c,d}/*.min.js').base, '/a/b');
        assert.equal(parse('/a/b/{c,d}/e.f.g/').base, '/a/b');
        assert.equal(parse('/a/b/{c,/foo.js}/e.f.g/').base, '/a/b');
        assert.equal(parse('./{a/b/{c,/foo.js}/e.f.g}').base, '.');
        assert.equal(parse('[a-c]b*').base, '.');
        assert.equal(parse('[a-j]*[^c]').base, '.');
        assert.equal(parse('[a-j]*[^c]b/c').base, '.');
        assert.equal(parse('[a-j]*[^c]bc').base, '.');
        assert.equal(parse('a/b/{c,./d}/e/f.g').base, 'a/b');
        assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').base, 'a/b');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').base, 'a/b');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').base, 'a/b');
        assert.equal(parse('a/b/{c,.gitignore}').base, 'a/b');
        assert.equal(parse('a/b/{c,/.gitignore}').base, 'a/b');
        assert.equal(parse('a/b/{c,/d}/e/f.g').base, 'a/b');
        assert.equal(parse('a/b/{c,/gitignore}').base, 'a/b');
        assert.equal(parse('a/b/{c,d}').base, 'a/b');
        assert.equal(parse('a/b/{c,d}/').base, 'a/b');
        assert.equal(parse('a/b/{c,d}/*.js').base, 'a/b');
        assert.equal(parse('a/b/{c,d}/*.min.js').base, 'a/b');
        assert.equal(parse('a/b/{c,d}/e.f.g/').base, 'a/b');
        assert.equal(parse('a/b/{c,d}/e/f.g').base, 'a/b');
        assert.equal(parse('a').base, '.');
        assert.equal(parse('a/**/b/*.{foo,bar}').base, 'a');
        assert.equal(parse('a/b/*.{foo,bar}').base, 'a/b');
        assert.equal(parse('a/b/.gitignore').base, 'a/b');
        assert.equal(parse('a/b/.{c,.gitignore}').base, 'a/b');
        assert.equal(parse('a/b/.{c,/.gitignore}').base, 'a/b');
        assert.equal(parse('a/b/.{foo,bar}').base, 'a/b');
        assert.equal(parse('a/b/c').base, 'a/b');
        assert.equal(parse('a/b/c.d/e.md').base, 'a/b/c.d');
        assert.equal(parse('a/b/c.md').base, 'a/b');
        assert.equal(parse('a/b/c.min.js').base, 'a/b');
        assert.equal(parse('a/b/c/').base, 'a/b/c/');
        assert.equal(parse('a/b/c/d.e.f/g.min.js').base, 'a/b/c/d.e.f');
        assert.equal(parse('a/b/c/d.md').base, 'a/b/c');
        assert.equal(parse('c.md').base, '.');
      });
  
      it('should get a basename:', function () {
        assert.equal(parse('*.min.js').path.basename, '*.min.js');
        assert.equal(parse('/a/b/{c,d}/').path.basename, '');
        assert.equal(parse('/a/b/{c,d}/*.js').path.basename, '*.js');
        assert.equal(parse('/a/b/{c,d}/*.min.js').path.basename, '*.min.js');
        assert.equal(parse('/a/b/{c,d}/e.f.g/').path.basename, '');
        assert.equal(parse('[a-j]*[^c]').path.basename, '[a-j]*[^c]');
        assert.equal(parse('[a-j]*[^c]bc').path.basename, '[a-j]*[^c]bc');
        assert.equal(parse('a/**/b/*.{foo,bar}').path.basename, '*.{foo,bar}');
        assert.equal(parse('a/b/*.{foo,bar}').path.basename, '*.{foo,bar}');
        assert.equal(parse('a/b/.{c,.gitignore}').path.basename, '.{c,.gitignore}');
        assert.equal(parse('a/b/.{c,/.gitignore}').path.basename, '.{c,/.gitignore}');
        assert.equal(parse('a/b/.{foo,bar}').path.basename, '.{foo,bar}');
        assert.equal(parse('a/b/{c,./d}/e/f.g').path.basename, 'f.g');
        assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').path.basename, 'abc.foo.js');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').path.basename, '*.foo.js');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').path.basename, 'abc.foo.js');
        assert.equal(parse('a/b/{c,.gitignore}').path.basename, '{c,.gitignore}');
        assert.equal(parse('a/b/{c,/.gitignore}').path.basename, '{c,/.gitignore}');
        assert.equal(parse('a/b/{c,/d}/e/f.g').path.basename, 'f.g');
        assert.equal(parse('a/b/{c,/gitignore}').path.basename, '{c,/gitignore}');
        assert.equal(parse('a/b/{c,d}').path.basename, '{c,d}');
        assert.equal(parse('a/b/{c,d}/').path.basename, '');
        assert.equal(parse('a/b/{c,d}/*.js').path.basename, '*.js');
        assert.equal(parse('a/b/{c,d}/*.min.js').path.basename, '*.min.js');
        assert.equal(parse('a/b/{c,d}/e.f.g/').path.basename, '');
        assert.equal(parse('a/b/{c,d}/e/f.g').path.basename, 'f.g');
      });
  
      it('should get a filename:', function () {
        assert.equal(parse('*.min.js').path.filename, '*');
        assert.equal(parse('/a/b/c').path.filename, 'c');
        assert.equal(parse('/a/b/c/').path.filename, '');
        assert.equal(parse('/a/b/{c,d}/').path.filename, '');
        assert.equal(parse('/a/b/{c,d}/*.js').path.filename, '*');
        assert.equal(parse('/a/b/{c,d}/*.min.js').path.filename, '*');
        assert.equal(parse('/a/b/{c,d}/e.f.g/').path.filename, '');
        assert.equal(parse('[a-c]b*').path.filename, '[a-c]b*');
        assert.equal(parse('a').path.filename, 'a');
        assert.equal(parse('a/**/b/*.{foo,bar}').path.filename, '*');
        assert.equal(parse('a/b/*.{foo,bar}').path.filename, '*');
        assert.equal(parse('a/b/.gitignore').path.filename, '');
        assert.equal(parse('a/b/.{c,.gitignore}').path.filename, '');
        assert.equal(parse('a/b/.{c,/.gitignore}').path.filename, '');
        assert.equal(parse('a/b/.{foo,bar}').path.filename, '');
        assert.equal(parse('a/b/c').path.filename, 'c');
        assert.equal(parse('a/b/c.d/e.md').path.filename, 'e');
        assert.equal(parse('a/b/c.md').path.filename, 'c');
        assert.equal(parse('a/b/c.min.js').path.filename, 'c');
        assert.equal(parse('a/b/c/').path.filename, '');
        assert.equal(parse('a/b/c/d.e.f/g.min.js').path.filename, 'g');
        assert.equal(parse('a/b/c/d.md').path.filename, 'd');
        assert.equal(parse('a/b/{c,./d}/e/f.g').path.filename, 'f');
        assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').path.filename, 'abc');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').path.filename, '*');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').path.filename, 'abc');
        assert.equal(parse('a/b/{c,.gitignore}').path.filename, '{c,.gitignore}');
        assert.equal(parse('a/b/{c,/.gitignore}').path.filename, '{c,/.gitignore}');
        assert.equal(parse('a/b/{c,/d}/e/f.g').path.filename, 'f');
        assert.equal(parse('a/b/{c,/gitignore}').path.filename, '{c,/gitignore}');
        assert.equal(parse('a/b/{c,d}').path.filename, '{c,d}');
        assert.equal(parse('a/b/{c,d}/').path.filename, '');
        assert.equal(parse('a/b/{c,d}/*.js').path.filename, '*');
        assert.equal(parse('a/b/{c,d}/*.min.js').path.filename, '*');
        assert.equal(parse('a/b/{c,d}/e.f.g/').path.filename, '');
        assert.equal(parse('a/b/{c,d}/e/f.g').path.filename, 'f');
        assert.equal(parse('c.md').path.filename, 'c');
      });
  
      it('should get an extname:', function () {
        assert.equal(parse('*.min.js').path.extname, '.min.js');
        assert.equal(parse('/a/b/c').path.extname, '');
        assert.equal(parse('/a/b/c/').path.extname, '');
        assert.equal(parse('/a/b/{c,d}/').path.extname, '');
        assert.equal(parse('/a/b/{c,d}/*.js').path.extname, '.js');
        assert.equal(parse('/a/b/{c,d}/*.min.js').path.extname, '.min.js');
        assert.equal(parse('/a/b/{c,d}/e.f.g/').path.extname, '');
        assert.equal(parse('[a-c]b*').path.extname, '');
        assert.equal(parse('[a-j]*[^c]bc').path.extname, '');
        assert.equal(parse('a').path.extname, '');
        assert.equal(parse('a/**/b/*.{foo,bar}').path.extname, '.{foo,bar}');
        assert.equal(parse('a/b/*.{foo,bar}').path.extname, '.{foo,bar}');
        assert.equal(parse('a/b/.gitignore').path.extname, '.gitignore');
        assert.equal(parse('a/b/.{c,.gitignore}').path.extname, '.{c,.gitignore}');
        assert.equal(parse('a/b/.{c,/.gitignore}').path.extname, '.{c,/.gitignore}');
        assert.equal(parse('a/b/.{foo,bar}').path.extname, '.{foo,bar}');
        assert.equal(parse('a/b/c').path.extname, '');
        assert.equal(parse('a/b/c.d/e.md').path.extname, '.md');
        assert.equal(parse('a/b/c.md').path.extname, '.md');
        assert.equal(parse('a/b/c.min.js').path.extname, '.min.js');
        assert.equal(parse('a/b/c/').path.extname, '');
        assert.equal(parse('a/b/c/d.e.f/g.min.js').path.extname, '.min.js');
        assert.equal(parse('a/b/c/d.md').path.extname, '.md');
        assert.equal(parse('a/b/{c,./d}/e/f.g').path.extname, '.g');
        assert.equal(parse('a/b/{c,./d}/e/f.min.g').path.extname, '.min.g');
        assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').path.extname, '.foo.js');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').path.extname, '.foo.js');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').path.extname, '.foo.js');
        assert.equal(parse('a/b/{c,.gitignore}').path.extname, '');
        assert.equal(parse('a/b/{c,/.gitignore}').path.extname, '');
        assert.equal(parse('a/b/{c,/d}/e/f.g').path.extname, '.g');
        assert.equal(parse('a/b/{c,/d}/e/f.min.g').path.extname, '.min.g');
        assert.equal(parse('a/b/{c,/gitignore}').path.extname, '');
        assert.equal(parse('a/b/{c,d}').path.extname, '');
        assert.equal(parse('a/b/{c,d}/').path.extname, '');
        assert.equal(parse('a/b/{c,d}/*.js').path.extname, '.js');
        assert.equal(parse('a/b/{c,d}/*.min.js').path.extname, '.min.js');
        assert.equal(parse('a/b/{c,d}/e.f.g/').path.extname, '');
        assert.equal(parse('a/b/{c,d}/e/f.g').path.extname, '.g');
        assert.equal(parse('a/b/{c,d}/e/f.min.g').path.extname, '.min.g');
        assert.equal(parse('c.md').path.extname, '.md');
      });
  
      it('should match a path with an extension:', function () {
        assert.equal(parse('a/b/c.md').glob, 'c.md');
        assert.equal(parse('a/b/c.md').base, 'a/b');
        assert.equal(parse('a/b/c.md').path.basename, 'c.md');
        assert.equal(parse('a/b/c.md').path.filename, 'c');
        assert.equal(parse('a/b/c.md').path.extname, '.md');
        assert.equal(parse('a/b/c.md').path.ext, 'md');
        assert.equal(parse('c.md').glob, 'c.md');
        assert.equal(parse('c.md').base, '.');
        assert.equal(parse('c.md').path.basename, 'c.md');
        assert.equal(parse('c.md').path.filename, 'c');
        assert.equal(parse('c.md').path.extname, '.md');
        assert.equal(parse('c.md').path.ext, 'md');
      });
  
      it('should match a path with multiple extensions:', function () {
        assert.equal(parse('a/b/c.min.js').glob, 'c.min.js');
        assert.equal(parse('a/b/c.min.js').base, 'a/b');
        assert.equal(parse('a/b/c.min.js').path.basename, 'c.min.js');
        assert.equal(parse('a/b/c.min.js').path.filename, 'c');
        assert.equal(parse('a/b/c.min.js').path.extname, '.min.js');
        assert.equal(parse('a/b/c.min.js').path.ext, 'js');
      });
  
      it('should work with paths that have dots in the dirname:', function () {
        assert.equal(parse('a/b/c/d.e.f/g.min.js').glob, 'g.min.js');
        assert.equal(parse('a/b/c/d.e.f/g.min.js').base, 'a/b/c/d.e.f');
        assert.equal(parse('a/b/c/d.e.f/g.min.js').path.basename, 'g.min.js');
        assert.equal(parse('a/b/c/d.e.f/g.min.js').path.filename, 'g');
        assert.equal(parse('a/b/c/d.e.f/g.min.js').path.extname, '.min.js');
        assert.equal(parse('a/b/c/d.e.f/g.min.js').path.ext, 'js');
      });
  
      it('should match a path without an extension:', function () {
        assert.equal(parse('a').glob, 'a');
        assert.equal(parse('a').base, '.');
        assert.equal(parse('a').path.filename, 'a');
        assert.equal(parse('a').path.basename, 'a');
        assert.equal(parse('a').path.extname, '');
      });
  
      it('should match a file path ending with an extension:', function () {
        assert.equal(parse('a/b/c/d.md').glob, 'd.md');
        assert.equal(parse('a/b/c/d.md').base, 'a/b/c');
        assert.equal(parse('a/b/c/d.md').path.basename, 'd.md');
        assert.equal(parse('a/b/c/d.md').path.filename, 'd');
        assert.equal(parse('a/b/c/d.md').path.extname, '.md');
        assert.equal(parse('a/b/c/d.md').path.ext, 'md');
  
        assert.equal(parse('a/b/c.d/e.md').glob, 'e.md');
        assert.equal(parse('a/b/c.d/e.md').base, 'a/b/c.d');
        assert.equal(parse('a/b/c.d/e.md').path.basename, 'e.md');
        assert.equal(parse('a/b/c.d/e.md').path.filename, 'e');
        assert.equal(parse('a/b/c.d/e.md').path.extname, '.md');
        assert.equal(parse('a/b/c.d/e.md').path.ext, 'md');
      });
  
    });
  
    describe('glob characters:', function () {
      it('should match when the basename starts with a star:', function () {
        assert.equal(parse('a/b/*.{foo,bar}').glob, '*.{foo,bar}');
        assert.equal(parse('a/b/*.{foo,bar}').base, 'a/b');
        assert.equal(parse('a/b/*.{foo,bar}').path.basename, '*.{foo,bar}');
        assert.equal(parse('a/b/*.{foo,bar}').path.filename, '*');
        assert.equal(parse('a/b/*.{foo,bar}').path.extname, '.{foo,bar}');
        assert.equal(parse('a/b/*.{foo,bar}').path.ext, '{foo,bar}');
      });
  
      it('should match with globstars:', function () {
        assert.equal(parse('a/**/b/*.{foo,bar}').glob, '**/b/*.{foo,bar}');
        assert.equal(parse('a/**/b/*.{foo,bar}').base, 'a');
        assert.equal(parse('a/**/b/*.{foo,bar}').path.basename, '*.{foo,bar}');
        assert.equal(parse('a/**/b/*.{foo,bar}').path.filename, '*');
        assert.equal(parse('a/**/b/*.{foo,bar}').path.extname, '.{foo,bar}');
        assert.equal(parse('a/**/b/*.{foo,bar}').path.ext, '{foo,bar}');
      });
  
      it('should match complex patterns:', function () {
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').glob, '{c,.gitignore,{a,b}}/{a,b}/abc.foo.js');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').base, 'a/b');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').path.basename, 'abc.foo.js');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').path.filename, 'abc');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').path.extname, '.foo.js');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').path.ext, 'js');
  
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').glob, '{c,.gitignore,{a,b}}/{a,b}/*.foo.js');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').base, 'a/b');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').path.basename, '*.foo.js');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').path.filename, '*');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').path.extname, '.foo.js');
        assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').path.ext, 'js');
  
        assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').glob, '{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js');
        assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').base, 'a/b');
        assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').path.basename, 'abc.foo.js');
        assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').path.filename, 'abc');
        assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').path.extname, '.foo.js');
        assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').path.ext, 'js');
      });
    });
  
    describe('should parse a glob:', function () {
      it('ending with a brace pattern:', function () {
        assert.equal(parse('a/b/{c,d}').glob, '{c,d}');
        assert.equal(parse('a/b/{c,d}').base, 'a/b');
        assert.equal(parse('a/b/{c,d}').path.basename, '{c,d}');
        assert.equal(parse('a/b/{c,d}').path.filename, '{c,d}');
        assert.equal(parse('a/b/{c,d}').path.extname, '');
        assert.equal(parse('a/b/{c,d}').path.ext, '');
      });
  
      it('with a brace pattern in the dirname:', function () {
        assert.equal(parse('a/b/{c,d}/*.js').orig, 'a/b/{c,d}/*.js');
        assert.equal(parse('a/b/{c,d}/*.js').glob, '{c,d}/*.js');
        assert.equal(parse('a/b/{c,d}/*.js').base, 'a/b');
        assert.equal(parse('a/b/{c,d}/*.js').path.basename, '*.js');
        assert.equal(parse('a/b/{c,d}/*.js').path.filename, '*');
        assert.equal(parse('a/b/{c,d}/*.js').path.extname, '.js');
        assert.equal(parse('a/b/{c,d}/*.js').path.ext, 'js');
  
        assert.equal(parse('a/b/{c,d}/').orig, 'a/b/{c,d}/');
        assert.equal(parse('a/b/{c,d}/').glob, '{c,d}/');
        assert.equal(parse('a/b/{c,d}/').base, 'a/b');
        assert.equal(parse('a/b/{c,d}/').path.basename, '');
        assert.equal(parse('a/b/{c,d}/').path.filename, '');
        assert.equal(parse('a/b/{c,d}/').path.extname, '');
        assert.equal(parse('a/b/{c,d}/').path.ext, '');
  
        assert.equal(parse('a/b/{c,d}/e.f.g/').orig, 'a/b/{c,d}/e.f.g/');
        assert.equal(parse('a/b/{c,d}/e.f.g/').glob, '{c,d}/e.f.g/');
        assert.equal(parse('a/b/{c,d}/e.f.g/').base, 'a/b');
        assert.equal(parse('a/b/{c,d}/e.f.g/').path.basename, '');
        assert.equal(parse('a/b/{c,d}/e.f.g/').path.filename, '');
        assert.equal(parse('a/b/{c,d}/e.f.g/').path.extname, '');
        assert.equal(parse('a/b/{c,d}/e.f.g/').path.ext, '');
  
        assert.equal(parse('/a/b/{c,d}/e.f.g/').orig, '/a/b/{c,d}/e.f.g/');
        assert.equal(parse('/a/b/{c,d}/e.f.g/').glob, '{c,d}/e.f.g/');
        assert.equal(parse('/a/b/{c,d}/e.f.g/').base, '/a/b');
        assert.equal(parse('/a/b/{c,d}/e.f.g/').path.basename, '');
        assert.equal(parse('/a/b/{c,d}/e.f.g/').path.filename, '');
        assert.equal(parse('/a/b/{c,d}/e.f.g/').path.extname, '');
        assert.equal(parse('/a/b/{c,d}/e.f.g/').path.ext, '');
  
        assert.equal(parse('a/b/{c,d}/*.min.js').orig, 'a/b/{c,d}/*.min.js');
        assert.equal(parse('a/b/{c,d}/*.min.js').glob, '{c,d}/*.min.js');
        assert.equal(parse('a/b/{c,d}/*.min.js').base, 'a/b');
        assert.equal(parse('a/b/{c,d}/*.min.js').path.basename, '*.min.js');
        assert.equal(parse('a/b/{c,d}/*.min.js').path.filename, '*');
        assert.equal(parse('a/b/{c,d}/*.min.js').path.extname, '.min.js');
        assert.equal(parse('a/b/{c,d}/*.min.js').path.ext, 'js');
  
        assert.equal(parse('*.min.js').orig, '*.min.js');
        assert.equal(parse('*.min.js').glob, '*.min.js');
        assert.equal(parse('*.min.js').base, '.');
        assert.equal(parse('*.min.js').path.basename, '*.min.js');
        assert.equal(parse('*.min.js').path.filename, '*');
        assert.equal(parse('*.min.js').path.extname, '.min.js');
        assert.equal(parse('*.min.js').path.ext, 'js');
  
        assert.equal(parse('a/b/{c,d}/*.min.js').path.extname, '.min.js');
        assert.equal(parse('a/b/{c,d}/*.min.js').path.ext, 'js');
  
        assert.equal(parse('[a-j]*[^c]').glob, '[a-j]*[^c]');
        assert.equal(parse('[a-j]*[^c]').base, '.');
        assert.equal(parse('[a-j]*[^c]').path.dirname, '');
        assert.equal(parse('[a-j]*[^c]').path.basename, '[a-j]*[^c]');
        assert.equal(parse('[a-j]*[^c]b/c').glob, '[a-j]*[^c]b/c');
        assert.equal(parse('[a-j]*[^c]b/c').base, '.');
        assert.equal(parse('[a-j]*[^c]bc').glob, '[a-j]*[^c]bc');
        assert.equal(parse('[a-j]*[^c]bc').base, '.');
        assert.equal(parse('[a-j]*[^c]bc').path.basename, '[a-j]*[^c]bc');
      });
  
      it('ending with a slash:', function () {
        assert.equal(parse('a/b/{c,d}/').orig, 'a/b/{c,d}/');
        assert.equal(parse('a/b/{c,d}/').glob, '{c,d}/');
        assert.equal(parse('a/b/{c,d}/').base, 'a/b');
        assert.equal(parse('a/b/{c,d}/').path.basename, '');
        assert.equal(parse('a/b/{c,d}/').path.filename, '');
        assert.equal(parse('a/b/{c,d}/').path.extname, '');
      });
  
      it('beginning with a slash:', function () {
        assert.equal(parse('/a/b/{c,d}/').orig, '/a/b/{c,d}/');
        assert.equal(parse('/a/b/{c,d}/').glob, '{c,d}/');
        assert.equal(parse('/a/b/{c,d}/').base, '/a/b');
        assert.equal(parse('/a/b/{c,d}/').path.basename, '');
        assert.equal(parse('/a/b/{c,d}/').path.filename, '');
        assert.equal(parse('/a/b/{c,d}/').path.extname, '');
      });
  
      it('with a brace pattern in the dirname:', function () {
        assert.equal(parse('a/b/{c,d}/e/f.g').orig, 'a/b/{c,d}/e/f.g');
        assert.equal(parse('a/b/{c,d}/e/f.g').glob, '{c,d}/e/f.g');
        assert.equal(parse('a/b/{c,d}/e/f.g').base, 'a/b');
        assert.equal(parse('a/b/{c,d}/e/f.g').path.basename, 'f.g');
        assert.equal(parse('a/b/{c,d}/e/f.g').path.filename, 'f');
        assert.equal(parse('a/b/{c,d}/e/f.g').path.extname, '.g');
        assert.equal(parse('a/b/{c,d}/e/f.min.g').path.extname, '.min.g');
        assert.equal(parse('a/b/{c,d}/e/f.g').path.ext, 'g');
  
        assert.equal(parse('a/b/{c,./d}/e/f.g').orig, 'a/b/{c,./d}/e/f.g');
        assert.equal(parse('a/b/{c,./d}/e/f.g').glob, '{c,./d}/e/f.g');
        assert.equal(parse('a/b/{c,./d}/e/f.g').base, 'a/b');
        assert.equal(parse('a/b/{c,./d}/e/f.g').path.basename, 'f.g');
        assert.equal(parse('a/b/{c,./d}/e/f.g').path.filename, 'f');
        assert.equal(parse('a/b/{c,./d}/e/f.g').path.extname, '.g');
        assert.equal(parse('a/b/{c,./d}/e/f.min.g').path.extname, '.min.g');
        assert.equal(parse('a/b/{c,./d}/e/f.g').path.ext, 'g');
  
        assert.equal(parse('a/b/{c,/d}/e/f.g').orig, 'a/b/{c,/d}/e/f.g');
        assert.equal(parse('a/b/{c,/d}/e/f.g').glob, '{c,/d}/e/f.g');
        assert.equal(parse('a/b/{c,/d}/e/f.g').base, 'a/b');
        assert.equal(parse('a/b/{c,/d}/e/f.g').path.basename, 'f.g');
        assert.equal(parse('a/b/{c,/d}/e/f.g').path.filename, 'f');
        assert.equal(parse('a/b/{c,/d}/e/f.g').path.extname, '.g');
        assert.equal(parse('a/b/{c,/d}/e/f.min.g').path.extname, '.min.g');
        assert.equal(parse('a/b/{c,/d}/e/f.g').path.ext, 'g');
      });
    });
  
    describe('when the glob pattern has braces:', function () {
      it('should track the original pattern', function () {
        assert.equal(parse('/a/b/{c,d}/*.js').orig, '/a/b/{c,d}/*.js');
        assert.equal(parse('/a/b/{c,d}/*.js').orig, '/a/b/{c,d}/*.js');
      });
  
      it('should extract the dirname', function () {
        assert.equal(parse('/a/b/{c,d}/*.js').base, '/a/b');
        assert.equal(parse('/a/b/{c,d}/*.min.js').base, '/a/b');
        assert.equal(parse('/a/b/{c,d}/*.min.js').glob, '{c,d}/*.min.js');
      });
  
      it('should extract the basename', function () {
        assert.equal(parse('/a/b/{c,d}/*.js').path.basename, '*.js');
        assert.equal(parse('/a/b/{c,d}/*.min.js').path.basename, '*.min.js');
      });
  
      it('should extract the filename', function () {
        assert.equal(parse('/a/b/{c,d}/*.js').path.filename, '*');
        assert.equal(parse('/a/b/{c,d}/*.min.js').path.filename, '*');
      });
  
      it('should extract extname', function () {
        assert.equal(parse('/a/b/{c,d}/*.js').path.extname, '.js');
        assert.equal(parse('/a/b/{c,d}/*.min.js').path.extname, '.min.js');
      });
  
      it('should extract ext', function () {
        assert.equal(parse('/a/b/{c,d}/*.js').path.ext, 'js');
        assert.equal(parse('/a/b/{c,d}/*.js').path.ext, 'js');
      });
    });
  
    describe('trailing and leading slashs:', function () {
      it('should work without a trailing slash:', function () {
        assert.equal(parse('a/b/c').glob, 'c');
        assert.equal(parse('a/b/c').base, 'a/b');
        assert.equal(parse('a/b/c').path.filename, 'c');
        assert.equal(parse('a/b/c').path.basename, 'c');
        assert.equal(parse('a/b/c').path.extname, '');
      });
  
      it('should work with a trailing slash:', function () {
        assert.equal(parse('a/b/c/').glob, '');
        assert.equal(parse('a/b/c/').base, 'a/b/c/');
        assert.equal(parse('a/b/c/').path.filename, '');
        assert.equal(parse('a/b/c/').path.basename, '');
        assert.equal(parse('a/b/c/').path.extname, '');
      });
  
      it('should work with a leading slash:', function () {
        assert.equal(parse('/a/b/c').glob, 'c');
        assert.equal(parse('/a/b/c').base, '/a/b');
        assert.equal(parse('/a/b/c').path.filename, 'c');
        assert.equal(parse('/a/b/c').path.basename, 'c');
        assert.equal(parse('/a/b/c').path.extname, '');
      });
  
      it('should work with both trailing and leading slashes:', function () {
        assert.equal(parse('/a/b/c/').glob, '');
        assert.equal(parse('/a/b/c/').base, '/a/b/c/');
        assert.equal(parse('/a/b/c/').path.filename, '');
        assert.equal(parse('/a/b/c/').path.basename, '');
        assert.equal(parse('/a/b/c/').path.extname, '');
      });
    });
  
    describe('dotfile and dotdir:', function () {
      describe('dotfiles:', function () {
        it('should know when the file is a dotfile:', function () {
          assert.equal(parse('a/b/.gitignore').is.dotfile, true);
          assert.equal(parse('a/b/.gitignore').is.dotfile, true);
          assert.equal(parse('a/b/.git').is.dotfile, true);
          assert.equal(parse('a/b/.gitignore').is.dotdir, false);
          assert.equal(parse('a/b/.git').is.dotdir, false);
        });
  
        it('should work brace patterns:', function () {
          assert.equal(parse('a/b/.{foo,bar}').orig, 'a/b/.{foo,bar}');
          assert.equal(parse('a/b/.{foo,bar}').glob, '.{foo,bar}');
          assert.equal(parse('a/b/.{foo,bar}').base, 'a/b');
          assert.equal(parse('a/b/.{c,/.gitignore}').orig, 'a/b/.{c,/.gitignore}');
          assert.equal(parse('a/b/.{c,/.gitignore}').glob, '.{c,/.gitignore}');
          assert.equal(parse('a/b/.{c,/.gitignore}').base, 'a/b');
          assert.equal(parse('a/b/.{c,.gitignore}').orig, 'a/b/.{c,.gitignore}');
          assert.equal(parse('a/b/.{c,.gitignore}').glob, '.{c,.gitignore}');
          assert.equal(parse('a/b/.{c,.gitignore}').base, 'a/b');
        });
      });
  
      describe('dotdirs:', function () {
        it('should know when the file is a dot-directory:', function () {
          assert.equal(parse('a/b/.git/config').is.dotdir, true);
          assert.equal(parse('a/b/.git/').is.dotdir, true);
          assert.equal(parse('a/b/git/').is.dotdir, false);
          assert.equal(parse('a/b/.git/').is.dotfile, false);
        });
  
        it('should work with braces in the dirname:', function () {
          // assert.equal(parse('a/b/.{foo,bar}/foo.js').is.dotdir, true);
          assert.equal(parse('a/b/.{foo,bar}/foo.js').orig, 'a/b/.{foo,bar}/foo.js');
          assert.equal(parse('a/b/.{foo,bar}/foo.js').glob, '.{foo,bar}/foo.js');
          assert.equal(parse('a/b/.{foo,bar}/foo.js').base, 'a/b');
        });
      });
    });
  
  
    it('should match character classes:', function () {
      assert.equal(parse('[a-c]b*').glob, '[a-c]b*');
      assert.equal(parse('[a-j]*[^c]').glob, '[a-j]*[^c]');
      assert.equal(parse('[a-j]*[^c]').base, '.');
      assert.equal(parse('[a-j]*[^c]b/c').glob, '[a-j]*[^c]b/c');
      assert.equal(parse('[a-j]*[^c]bc').glob, '[a-j]*[^c]bc');
    });
  
    it('should work when a character class has trailing word characters:', function () {
      assert.equal(parse('[a-c]b*').glob, '[a-c]b*');
      assert.equal(parse('[a-c]b*').base, '.');
      assert.equal(parse('[a-j]*[^c]bc').base, '.');
    });
  });
  
  describe('when the glob has brace patterns:', function () {
    it('should extract the `base` from the glob:', function () {
      assert.equal(parse('a/b/{c,/.gitignore}').base, 'a/b');
      assert.equal(parse('a/b/{c,/.gitignore}').glob, '{c,/.gitignore}');
      assert.equal(parse('a/b/{c,/.gitignore}').orig, 'a/b/{c,/.gitignore}');
  
      assert.equal(parse('a/b/{c,/gitignore}').base, 'a/b');
      assert.equal(parse('a/b/{c,/gitignore}').glob, '{c,/gitignore}');
  
      assert.equal(parse('a/b/{c,.gitignore}').base, 'a/b');
      assert.equal(parse('a/b/{c,.gitignore}').glob, '{c,.gitignore}');
    });
  
    it('should work when the brace pattern has dots and slashes:', function () {
      assert.equal(parse('a/b/{c,/.gitignore}').orig, 'a/b/{c,/.gitignore}');
      assert.equal(parse('a/b/{c,/.gitignore}').glob, '{c,/.gitignore}');
      assert.equal(parse('a/b/{c,/.gitignore}').base, 'a/b');
      assert.equal(parse('a/b/{c,/.gitignore}').path.basename, '{c,/.gitignore}');
      assert.equal(parse('a/b/{c,/.gitignore}').path.filename, '{c,/.gitignore}');
      assert.equal(parse('a/b/{c,/.gitignore}').path.extname, '');
  
      assert.equal(parse('a/b/{c,/gitignore}').orig, 'a/b/{c,/gitignore}');
      assert.equal(parse('a/b/{c,/gitignore}').glob, '{c,/gitignore}');
      assert.equal(parse('a/b/{c,/gitignore}').base, 'a/b');
      assert.equal(parse('a/b/{c,/gitignore}').path.basename, '{c,/gitignore}');
      assert.equal(parse('a/b/{c,/gitignore}').path.filename, '{c,/gitignore}');
      assert.equal(parse('a/b/{c,/gitignore}').path.extname, '');
  
      assert.equal(parse('a/b/{c,.gitignore}').orig, 'a/b/{c,.gitignore}');
      assert.equal(parse('a/b/{c,.gitignore}').glob, '{c,.gitignore}');
      assert.equal(parse('a/b/{c,.gitignore}').base, 'a/b');
      assert.equal(parse('a/b/{c,.gitignore}').path.basename, '{c,.gitignore}');
      assert.equal(parse('a/b/{c,.gitignore}').path.filename, '{c,.gitignore}');
      assert.equal(parse('a/b/{c,.gitignore}').path.extname, '');
      parse('a/b/c/**/*.{yml,json}')
    });
  });
  