/**
 * 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('./');

function getBase(glob) {
  return parse(glob, true);
}

describe('`is` object:', function () {
  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);
  });

  it('should detect when a pattern does not have a globstar:', function () {
    assert.equal(parse('*/*').is.globstar, false);
    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 `dotdir` are defined:', function () {
    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 detect when `dotfile` are defined:', function () {
    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);
  });
});

describe('should get a base path:', function () {
  it('should extract a base path from a glob pattern:', function () {
    assert.equal(getBase('.*').base, '');
    assert.equal(getBase('.*').pattern, '.*');

    assert.equal(getBase('./*').base, '.');
    assert.equal(getBase('./*').pattern, '*');

    assert.equal(getBase('*').base, '');
    assert.equal(getBase('*').pattern, '*');

    assert.equal(getBase('**').base, '');
    assert.equal(getBase('**').pattern, '**');

    assert.equal(getBase('**/*.md').base, '');
    assert.equal(getBase('**/*.md').pattern, '**/*.md');

    assert.equal(getBase('**/*.min.js').base, '');
    assert.equal(getBase('**/*.min.js').pattern, '**/*.min.js');

    assert.equal(getBase('**/*foo.js').base, '');
    assert.equal(getBase('**/*foo.js').pattern, '**/*foo.js');

    assert.equal(getBase('**/.*').base, '');
    assert.equal(getBase('**/.*').pattern, '**/.*');

    assert.equal(getBase('**/d').base, '');
    assert.equal(getBase('**/d').pattern, '**/d');

    assert.equal(getBase('*.*').base, '');
    assert.equal(getBase('*.*').pattern, '*.*');

    assert.equal(getBase('*.js').base, '');
    assert.equal(getBase('*.js').pattern, '*.js');

    assert.equal(getBase('*.md').base, '');
    assert.equal(getBase('*.md').pattern, '*.md');

    assert.equal(getBase('*.min.js').base, '');
    assert.equal(getBase('*.min.js').pattern, '*.min.js');

    assert.equal(getBase('*/*').base, '');
    assert.equal(getBase('*/*').pattern, '*/*');

    assert.equal(getBase('*/*/*/*').base, '');
    assert.equal(getBase('*/*/*/*').pattern, '*/*/*/*');

    assert.equal(getBase('*/*/*/e').base, '');
    assert.equal(getBase('*/*/*/e').pattern, '*/*/*/e');

    assert.equal(getBase('*/b/*/e').base, '');
    assert.equal(getBase('*/b/*/e').pattern, '*/b/*/e');

    assert.equal(getBase('*b').base, '');
    assert.equal(getBase('*b').pattern, '*b');

    assert.equal(getBase('./a/**/j/**/z/*.md').base, 'a');
    assert.equal(getBase('./a/**/j/**/z/*.md').pattern, '**/j/**/z/*.md');

    assert.equal(getBase('./a/**/z/*.md').base, 'a');
    assert.equal(getBase('./a/**/z/*.md').pattern, '**/z/*.md');

    assert.equal(getBase('./{a/b/{c,/foo.js}/e.f.g}').base, '.');
    assert.equal(getBase('./{a/b/{c,/foo.js}/e.f.g}').pattern, '{a/b/{c,/foo.js}/e.f.g}');

    assert.equal(getBase('./node_modules/*-glob/**/*.js').base, 'node_modules');
    assert.equal(getBase('./node_modules/*-glob/**/*.js').pattern, '*-glob/**/*.js');

    assert.equal(getBase('a/b/{c,/.gitignore}').base, 'a/b');
    assert.equal(getBase('a/b/{c,/.gitignore}').pattern, '{c,/.gitignore}');

    assert.equal(getBase('a/b/.{foo,bar}').base, 'a/b');
    assert.equal(getBase('a/b/.{foo,bar}').pattern, '.{foo,bar}');

    assert.equal(getBase('a/b/*.{foo,bar}').base, 'a/b');
    assert.equal(getBase('a/b/*.{foo,bar}').pattern, '*.{foo,bar}');

    assert.equal(getBase('a/**/b/*.{foo,bar}').base, 'a');
    assert.equal(getBase('a/**/b/*.{foo,bar}').pattern, '**/b/*.{foo,bar}');

    assert.equal(getBase('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').base, 'a/b');
    assert.equal(getBase('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').pattern, '{c,.gitignore,{a,b}}/{a,b}/abc.foo.js');

    assert.equal(getBase('a/b/{c,d}/').base, 'a/b');
    assert.equal(getBase('a/b/{c,d}/').pattern, '{c,d}/');

    assert.equal(getBase('a/b/{c,d}/e/f.g').base, 'a/b');
    assert.equal(getBase('a/b/{c,d}/e/f.g').pattern, '{c,d}/e/f.g');

    assert.equal(getBase('.a*').base, '');
    assert.equal(getBase('.a*').pattern, '.a*');

    assert.equal(getBase('.b*').base, '');
    assert.equal(getBase('.b*').pattern, '.b*');

    assert.equal(getBase('/*').base, '');
    assert.equal(getBase('/*').pattern, '/*');

    assert.equal(getBase('a/***').base, 'a');
    assert.equal(getBase('a/***').pattern, '***');

    assert.equal(getBase('a/**/b/*.{foo,bar}').base, 'a');
    assert.equal(getBase('a/**/b/*.{foo,bar}').pattern, '**/b/*.{foo,bar}');

    assert.equal(getBase('a/**/c/*').base, 'a');
    assert.equal(getBase('a/**/c/*').pattern, '**/c/*');

    assert.equal(getBase('a/**/c/*.md').base, 'a');
    assert.equal(getBase('a/**/c/*.md').pattern, '**/c/*.md');

    assert.equal(getBase('a/**/e').base, 'a');
    assert.equal(getBase('a/**/e').pattern, '**/e');

    assert.equal(getBase('a/**/j/**/z/*.md').base, 'a');
    assert.equal(getBase('a/**/j/**/z/*.md').pattern, '**/j/**/z/*.md');

    assert.equal(getBase('a/**/z/*.md').base, 'a');
    assert.equal(getBase('a/**/z/*.md').pattern, '**/z/*.md');

    assert.equal(getBase('a/**c*').base, 'a');
    assert.equal(getBase('a/**c*').pattern, '**c*');

    assert.equal(getBase('a/**c/*').base, 'a');
    assert.equal(getBase('a/**c/*').pattern, '**c/*');

    assert.equal(getBase('a/*/*/e').base, 'a');
    assert.equal(getBase('a/*/*/e').pattern, '*/*/e');

    assert.equal(getBase('a/*/c/*.md').base, 'a');
    assert.equal(getBase('a/*/c/*.md').pattern, '*/c/*.md');

    assert.equal(getBase('a/b/**/c{d,e}/**/xyz.md').base, 'a/b');
    assert.equal(getBase('a/b/**/c{d,e}/**/xyz.md').pattern, '**/c{d,e}/**/xyz.md');

    assert.equal(getBase('a/b/**/e').base, 'a/b');
    assert.equal(getBase('a/b/**/e').pattern, '**/e');

    assert.equal(getBase('a/b/*.{foo,bar}').base, 'a/b');
    assert.equal(getBase('a/b/*.{foo,bar}').pattern, '*.{foo,bar}');

    assert.equal(getBase('a/b/*/e').base, 'a/b');
    assert.equal(getBase('a/b/*/e').pattern, '*/e');

    assert.equal(getBase('a/b/c/*').base, 'a/b/c');
    assert.equal(getBase('a/b/c/*').pattern, '*');

    assert.equal(getBase('a/b/c/*.md').base, 'a/b/c');
    assert.equal(getBase('a/b/c/*.md').pattern, '*.md');

    assert.equal(getBase('a/b/c/.*.md').base, 'a/b/c');
    assert.equal(getBase('a/b/c/.*.md').pattern, '.*.md');

    assert.equal(getBase('b/*/*/*').base, 'b');
    assert.equal(getBase('b/*/*/*').pattern, '*/*/*');
  });

  it('file extensions:', function () {
    assert.equal(getBase('.md').base, '');
    assert.equal(getBase('.md').pattern, '.md');
  });

  it('negation pattern:', function () {
    assert.equal(getBase('!*.min.js').base, '');
    assert.equal(getBase('!*.min.js').pattern, '!*.min.js');

    assert.equal(getBase('!foo').base, '');
    assert.equal(getBase('!foo').pattern, '!foo');

    assert.equal(getBase('a/b/c/!foo').base, 'a/b/c');
    assert.equal(getBase('a/b/c/!foo').pattern, '!foo');

    assert.equal(getBase('!foo/(a|b).min.js').base, '');
    assert.equal(getBase('!foo/(a|b).min.js').pattern, '!foo/(a|b).min.js');

    assert.equal(getBase('!foo/[a-b].min.js').base, '');
    assert.equal(getBase('!foo/[a-b].min.js').pattern, '!foo/[a-b].min.js');

    assert.equal(getBase('!foo/{a,b}.min.js').base, '');
    assert.equal(getBase('!foo/{a,b}.min.js').pattern, '!foo/{a,b}.min.js');
  });

  describe('braces:', function () {
    it('should know when a base cannot be extracted:', function () {
      assert.equal(getBase('/a/b/{c,/foo.js}/e.f.g/').base, '');
      assert.equal(getBase('/a/b/{c,/foo.js}/e.f.g/').pattern, '/a/b/{c,/foo.js}/e.f.g/');

      assert.equal(getBase('{a/b/c.js,/a/b/{c,/foo.js}/e.f.g/}').base, '');
      assert.equal(getBase('{a/b/c.js,/a/b/{c,/foo.js}/e.f.g/}').pattern, '{a/b/c.js,/a/b/{c,/foo.js}/e.f.g/}');

      assert.equal(getBase('/a/b/{c,d}/').base, '');
      assert.equal(getBase('/a/b/{c,d}/').pattern, '/a/b/{c,d}/');

      assert.equal(getBase('/a/b/{c,d}/*.js').base, '');
      assert.equal(getBase('/a/b/{c,d}/*.js').pattern, '/a/b/{c,d}/*.js');

      assert.equal(getBase('/a/b/{c,d}/*.min.js').base, '');
      assert.equal(getBase('/a/b/{c,d}/*.min.js').pattern, '/a/b/{c,d}/*.min.js');

      assert.equal(getBase('/a/b/{c,d}/e.f.g/').base, '');
      assert.equal(getBase('/a/b/{c,d}/e.f.g/').pattern, '/a/b/{c,d}/e.f.g/');

      assert.equal(getBase('{.,*}').base, '');
      assert.equal(getBase('{.,*}').pattern, '{.,*}');
    });

    it('should work when the filename has braces:', function () {
      assert.equal(getBase('a/b/.{c,.gitignore}').base, 'a/b');
      assert.equal(getBase('a/b/.{c,.gitignore}').pattern, '.{c,.gitignore}');

      assert.equal(getBase('a/b/.{c,/.gitignore}').base, 'a/b');
      assert.equal(getBase('a/b/.{c,/.gitignore}').pattern, '.{c,/.gitignore}');

      assert.equal(getBase('a/b/.{foo,bar}').base, 'a/b');
      assert.equal(getBase('a/b/.{foo,bar}').pattern, '.{foo,bar}');

      assert.equal(getBase('a/b/{c,.gitignore}').base, 'a/b');
      assert.equal(getBase('a/b/{c,.gitignore}').pattern, '{c,.gitignore}');

      assert.equal(getBase('a/b/{c,/.gitignore}').base, 'a/b');
      assert.equal(getBase('a/b/{c,/.gitignore}').pattern, '{c,/.gitignore}');

      assert.equal(getBase('a/b/{c,/gitignore}').base, 'a/b');
      assert.equal(getBase('a/b/{c,/gitignore}').pattern, '{c,/gitignore}');

      assert.equal(getBase('a/b/{c,d}').base, 'a/b');
      assert.equal(getBase('a/b/{c,d}').pattern, '{c,d}');
    });

    it('should work when the dirname has braces:', function () {
      assert.equal(getBase('a/b/{c,./d}/e/f.g').base, 'a/b');
      assert.equal(getBase('a/b/{c,./d}/e/f.g').pattern, '{c,./d}/e/f.g');

      assert.equal(getBase('a/b/{c,./d}/e/f.min.g').base, 'a/b');
      assert.equal(getBase('a/b/{c,./d}/e/f.min.g').pattern, '{c,./d}/e/f.min.g');

      assert.equal(getBase('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').base, 'a/b');
      assert.equal(getBase('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').pattern, '{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js');

      assert.equal(getBase('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').base, 'a/b');
      assert.equal(getBase('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').pattern, '{c,.gitignore,{a,b}}/{a,b}/*.foo.js');

      assert.equal(getBase('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').base, 'a/b');
      assert.equal(getBase('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').pattern, '{c,.gitignore,{a,b}}/{a,b}/abc.foo.js');

      assert.equal(getBase('a/b/{c,/d}/e/f.g').base, 'a/b');
      assert.equal(getBase('a/b/{c,/d}/e/f.g').pattern, '{c,/d}/e/f.g');

      assert.equal(getBase('a/b/{c,/d}/e/f.min.g').base, 'a/b');
      assert.equal(getBase('a/b/{c,/d}/e/f.min.g').pattern, '{c,/d}/e/f.min.g');

      assert.equal(getBase('a/b/{c,d}/').base, 'a/b');
      assert.equal(getBase('a/b/{c,d}/').pattern, '{c,d}/');

      assert.equal(getBase('a/b/{c,d}/*.js').base, 'a/b');
      assert.equal(getBase('a/b/{c,d}/*.js').pattern, '{c,d}/*.js');

      assert.equal(getBase('a/b/{c,d}/*.min.js').base, 'a/b');
      assert.equal(getBase('a/b/{c,d}/*.min.js').pattern, '{c,d}/*.min.js');

      assert.equal(getBase('a/b/{c,d}/e.f.g/').base, 'a/b');
      assert.equal(getBase('a/b/{c,d}/e.f.g/').pattern, '{c,d}/e.f.g/');

      assert.equal(getBase('a/b/{c,d}/e/f.g').base, 'a/b');
      assert.equal(getBase('a/b/{c,d}/e/f.g').pattern, '{c,d}/e/f.g');

      assert.equal(getBase('a/b/{c,d}/e/f.min.g').base, 'a/b');
      assert.equal(getBase('a/b/{c,d}/e/f.min.g').pattern, '{c,d}/e/f.min.g');

      assert.equal(getBase('foo/{a,b}.min.js').base, 'foo');
      assert.equal(getBase('foo/{a,b}.min.js').pattern, '{a,b}.min.js');
    });
  });

  it('character classes:', function () {
    assert.equal(getBase('[a-c]b*').base, '');
    assert.equal(getBase('[a-c]b*').pattern, '[a-c]b*');

    assert.equal(getBase('[a-j]*[^c]').base, '');
    assert.equal(getBase('[a-j]*[^c]').pattern, '[a-j]*[^c]');

    assert.equal(getBase('[a-j]*[^c]b/c').base, '');
    assert.equal(getBase('[a-j]*[^c]b/c').pattern, '[a-j]*[^c]b/c');

    assert.equal(getBase('[a-j]*[^c]bc').base, '');
    assert.equal(getBase('[a-j]*[^c]bc').pattern, '[a-j]*[^c]bc');

    assert.equal(getBase('[ab][ab]').base, '');
    assert.equal(getBase('[ab][ab]').pattern, '[ab][ab]');

    assert.equal(getBase('foo/[a-b].min.js').base, 'foo');
    assert.equal(getBase('foo/[a-b].min.js').pattern, '[a-b].min.js');
  });

  it('qmarks:', function () {
    assert.equal(getBase('?').base, '');
    assert.equal(getBase('?').pattern, '?');

    assert.equal(getBase('?/?').base, '');
    assert.equal(getBase('?/?').pattern, '?/?');

    assert.equal(getBase('??').base, '');
    assert.equal(getBase('??').pattern, '??');

    assert.equal(getBase('???').base, '');
    assert.equal(getBase('???').pattern, '???');

    assert.equal(getBase('?a').base, '');
    assert.equal(getBase('?a').pattern, '?a');

    assert.equal(getBase('?b').base, '');
    assert.equal(getBase('?b').pattern, '?b');

    assert.equal(getBase('a?b').base, '');
    assert.equal(getBase('a?b').pattern, 'a?b');

    assert.equal(getBase('a/?/c.js').base, 'a');
    assert.equal(getBase('a/?/c.js').pattern, '?/c.js');

    assert.equal(getBase('a/?/c.md').base, 'a');
    assert.equal(getBase('a/?/c.md').pattern, '?/c.md');

    assert.equal(getBase('a/?/c/?/*/f.js').base, 'a');
    assert.equal(getBase('a/?/c/?/*/f.js').pattern, '?/c/?/*/f.js');

    assert.equal(getBase('a/?/c/?/*/f.md').base, 'a');
    assert.equal(getBase('a/?/c/?/*/f.md').pattern, '?/c/?/*/f.md');

    assert.equal(getBase('a/?/c/?/e.js').base, 'a');
    assert.equal(getBase('a/?/c/?/e.js').pattern, '?/c/?/e.js');

    assert.equal(getBase('a/?/c/?/e.md').base, 'a');
    assert.equal(getBase('a/?/c/?/e.md').pattern, '?/c/?/e.md');

    assert.equal(getBase('a/?/c/???/e.js').base, 'a');
    assert.equal(getBase('a/?/c/???/e.js').pattern, '?/c/???/e.js');

    assert.equal(getBase('a/?/c/???/e.md').base, 'a');
    assert.equal(getBase('a/?/c/???/e.md').pattern, '?/c/???/e.md');

    assert.equal(getBase('a/??/c.js').base, 'a');
    assert.equal(getBase('a/??/c.js').pattern, '??/c.js');

    assert.equal(getBase('a/??/c.md').base, 'a');
    assert.equal(getBase('a/??/c.md').pattern, '??/c.md');

    assert.equal(getBase('a/???/c.js').base, 'a');
    assert.equal(getBase('a/???/c.js').pattern, '???/c.js');

    assert.equal(getBase('a/???/c.md').base, 'a');
    assert.equal(getBase('a/???/c.md').pattern, '???/c.md');

    assert.equal(getBase('a/????/c.js').base, 'a');
    assert.equal(getBase('a/????/c.js').pattern, '????/c.js');
  });

  it('non-glob pattern:', function () {
    assert.equal(getBase('').base, '');
    assert.equal(getBase('').pattern, '');

    assert.equal(getBase('.').base, '');
    assert.equal(getBase('.').pattern, '.');

    assert.equal(getBase('a').base, '');
    assert.equal(getBase('a').pattern, 'a');

    assert.equal(getBase('.a').base, '');
    assert.equal(getBase('.a').pattern, '.a');

    assert.equal(getBase('/a').base, '/');
    assert.equal(getBase('/a').pattern, 'a');

    assert.equal(getBase('/a/b/c').base, '/a/b/');
    assert.equal(getBase('/a/b/c').pattern, 'c');

    assert.equal(getBase('/a/b/c/').base, '/a/b/c/');
    assert.equal(getBase('/a/b/c/').pattern, '');

    assert.equal(getBase('a/b/c/').base, 'a/b/c/');
    assert.equal(getBase('a/b/c/').pattern, '');

    assert.equal(getBase('a.min.js').base, '');
    assert.equal(getBase('a.min.js').pattern, 'a.min.js');

    assert.equal(getBase('a/.x.md').base, 'a/');
    assert.equal(getBase('a/.x.md').pattern, '.x.md');

    assert.equal(getBase('a/b/.gitignore').base, 'a/b/');
    assert.equal(getBase('a/b/.gitignore').pattern, '.gitignore');

    assert.equal(getBase('a/b/c/d.md').base, 'a/b/c/');
    assert.equal(getBase('a/b/c/d.md').pattern, 'd.md');

    assert.equal(getBase('a/b/c/d.e.f/g.min.js').base, 'a/b/c/d.e.f/');
    assert.equal(getBase('a/b/c/d.e.f/g.min.js').pattern, 'g.min.js');

    assert.equal(getBase('a/b/.git').base, 'a/b/');
    assert.equal(getBase('a/b/.git').pattern, '.git');

    assert.equal(getBase('a/b/.git/').base, 'a/b/.git/');
    assert.equal(getBase('a/b/.git/').pattern, '');

    assert.equal(getBase('a/b/.gitignore').base, 'a/b/');
    assert.equal(getBase('a/b/.gitignore').pattern, '.gitignore');

    assert.equal(getBase('a/b/c').base, 'a/b/');
    assert.equal(getBase('a/b/c').pattern, 'c');

    assert.equal(getBase('a/b/c.d/e.md').base, 'a/b/c.d/');
    assert.equal(getBase('a/b/c.d/e.md').pattern, 'e.md');

    assert.equal(getBase('a/b/c.md').base, 'a/b/');
    assert.equal(getBase('a/b/c.md').pattern, 'c.md');

    assert.equal(getBase('a/b/c.min.js').base, 'a/b/');
    assert.equal(getBase('a/b/c.min.js').pattern, 'c.min.js');

    assert.equal(getBase('a/b/c/').base, 'a/b/c/');
    assert.equal(getBase('a/b/c/').pattern, '');

    assert.equal(getBase('a/b/c/d.e.f/g.min.js').base, 'a/b/c/d.e.f/');
    assert.equal(getBase('a/b/c/d.e.f/g.min.js').pattern, 'g.min.js');

    assert.equal(getBase('a/b/c/d.md').base, 'a/b/c/');
    assert.equal(getBase('a/b/c/d.md').pattern, 'd.md');

    assert.equal(getBase('a/b/git/').base, 'a/b/git/');
    assert.equal(getBase('a/b/git/').pattern, '');

    assert.equal(getBase('aa').base, '');
    assert.equal(getBase('aa').pattern, 'aa');

    assert.equal(getBase('ab').base, '');
    assert.equal(getBase('ab').pattern, 'ab');

    assert.equal(getBase('bb').base, '');
    assert.equal(getBase('bb').pattern, 'bb');

    assert.equal(getBase('c.md').base, '');
    assert.equal(getBase('c.md').pattern, 'c.md');

    assert.equal(getBase('foo').base, '');
    assert.equal(getBase('foo').pattern, 'foo');
  });
});

describe('path parts:', function () {
  describe('complex patterns:', function () {
    it('should get a dirname:', function () {
      assert.equal(parse('*.min.js').path.dirname, '');
      assert.equal(parse('/a/b/c').path.dirname, '/a/b/');
      assert.equal(parse('/a/b/c/').path.dirname, '/a/b/c/');
      assert.equal(parse('/a/b/{c,d}/').path.dirname, '/a/b/{c,d}/');
      assert.equal(parse('/a/b/{c,d}/*.js').path.dirname, '/a/b/{c,d}/');
      assert.equal(parse('/a/b/{c,d}/*.min.js').path.dirname, '/a/b/{c,d}/');
      assert.equal(parse('/a/b/{c,d}/e.f.g/').path.dirname, '/a/b/{c,d}/e.f.g/');
      assert.equal(parse('/a/b/{c,/foo.js}/e.f.g/').path.dirname, '/a/b/{c,/foo.js}/e.f.g/');
      assert.equal(parse('./{a/b/{c,/foo.js}/e.f.g}').path.dirname, './{a/b/{c,/foo.js}/e.f.g}');
      assert.equal(parse('[a-c]b*').path.dirname, '');
      assert.equal(parse('[a-j]*[^c]').path.dirname, '');
      assert.equal(parse('[a-j]*[^c]b/c').path.dirname, '[a-j]*[^c]b/');
      assert.equal(parse('[a-j]*[^c]bc').path.dirname, '');
      assert.equal(parse('a/b/{c,./d}/e/f.g').path.dirname, 'a/b/{c,./d}/e/');
      assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').path.dirname, 'a/b/{c,.gitignore,{a,./b}}/{a,b}/');
      assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').path.dirname, 'a/b/{c,.gitignore,{a,b}}/{a,b}/');
      assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').path.dirname, 'a/b/{c,.gitignore,{a,b}}/{a,b}/');
      assert.equal(parse('a/b/{c,.gitignore}').path.dirname, 'a/b/');
      assert.equal(parse('a/b/{c,/.gitignore}').path.dirname, 'a/b/');
      assert.equal(parse('a/b/{c,/d}/e/f.g').path.dirname, 'a/b/{c,/d}/e/');
      assert.equal(parse('a/b/{c,/gitignore}').path.dirname, 'a/b/');
      assert.equal(parse('a/b/{c,d}').path.dirname, 'a/b/');
      assert.equal(parse('a/b/{c,d}/').path.dirname, 'a/b/{c,d}/');
      assert.equal(parse('a/b/{c,d}/*.js').path.dirname, 'a/b/{c,d}/');
      assert.equal(parse('a/b/{c,d}/*.min.js').path.dirname, 'a/b/{c,d}/');
      assert.equal(parse('a/b/{c,d}/e.f.g/').path.dirname, 'a/b/{c,d}/e.f.g/');
      assert.equal(parse('a/b/{c,d}/e/f.g').path.dirname, 'a/b/{c,d}/e/');
      assert.equal(parse('a').path.dirname, '');
      assert.equal(parse('a/**/b/*.{foo,bar}').path.dirname, 'a/**/b/');
      assert.equal(parse('a/b/*.{foo,bar}').path.dirname, 'a/b/');
      assert.equal(parse('a/b/.gitignore').path.dirname, 'a/b/');
      assert.equal(parse('a/b/.{c,.gitignore}').path.dirname, 'a/b/');
      assert.equal(parse('a/b/.{c,/.gitignore}').path.dirname, 'a/b/');
      assert.equal(parse('a/b/.{foo,bar}').path.dirname, 'a/b/');
      assert.equal(parse('a/b/c').path.dirname, 'a/b/');
      assert.equal(parse('a/b/c.d/e.md').path.dirname, 'a/b/c.d/');
      assert.equal(parse('a/b/c.md').path.dirname, 'a/b/');
      assert.equal(parse('a/b/c.min.js').path.dirname, 'a/b/');
      assert.equal(parse('a/b/c/').path.dirname, 'a/b/c/');
      assert.equal(parse('a/b/c/d.e.f/g.min.js').path.dirname, 'a/b/c/d.e.f/');
      assert.equal(parse('a/b/c/d.md').path.dirname, 'a/b/c/');
      assert.equal(parse('c.md').path.dirname, '');
    });

    it('should get a filename:', function () {
      assert.equal(parse('*.min.js').path.filename, '*.min.js');
      assert.equal(parse('/a/b/{c,d}/').path.filename, '');
      assert.equal(parse('/a/b/{c,d}/*.js').path.filename, '*.js');
      assert.equal(parse('/a/b/{c,d}/*.min.js').path.filename, '*.min.js');
      assert.equal(parse('/a/b/{c,d}/e.f.g/').path.filename, '');
      assert.equal(parse('[a-j]*[^c]').path.filename, '[a-j]*[^c]');
      assert.equal(parse('[a-j]*[^c]bc').path.filename, '[a-j]*[^c]bc');
      assert.equal(parse('a/**/b/*.{foo,bar}').path.filename, '*.{foo,bar}');
      assert.equal(parse('a/b/*.{foo,bar}').path.filename, '*.{foo,bar}');
      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/.{foo,bar}').path.filename, '.{foo,bar}');
      assert.equal(parse('a/b/{c,./d}/e/f.g').path.filename, 'f.g');
      assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').path.filename, 'abc.foo.js');
      assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').path.filename, '*.foo.js');
      assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').path.filename, 'abc.foo.js');
      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.g');
      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, '*.js');
      assert.equal(parse('a/b/{c,d}/*.min.js').path.filename, '*.min.js');
      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.g');
    });

    it('should get a basename:', function () {
      assert.equal(parse('*.min.js').path.basename, '*');
      assert.equal(parse('/a/b/c').path.basename, 'c');
      assert.equal(parse('/a/b/c/').path.basename, '');
      assert.equal(parse('/a/b/{c,d}/').path.basename, '');
      assert.equal(parse('/a/b/{c,d}/*.js').path.basename, '*');
      assert.equal(parse('/a/b/{c,d}/*.min.js').path.basename, '*');
      assert.equal(parse('/a/b/{c,d}/e.f.g/').path.basename, '');
      assert.equal(parse('[a-c]b*').path.basename, '[a-c]b*');
      assert.equal(parse('a').path.basename, 'a');
      assert.equal(parse('a/**/b/*.{foo,bar}').path.basename, '*');
      assert.equal(parse('a/b/*.{foo,bar}').path.basename, '*');
      assert.equal(parse('a/b/.gitignore').path.basename, '');
      assert.equal(parse('a/b/.{c,.gitignore}').path.basename, '');
      assert.equal(parse('a/b/.{c,/.gitignore}').path.basename, '');
      assert.equal(parse('a/b/.{foo,bar}').path.basename, '');
      assert.equal(parse('a/b/c').path.basename, 'c');
      assert.equal(parse('a/b/c.d/e.md').path.basename, 'e');
      assert.equal(parse('a/b/c.md').path.basename, 'c');
      assert.equal(parse('a/b/c.min.js').path.basename, 'c');
      assert.equal(parse('a/b/c/').path.basename, '');
      assert.equal(parse('a/b/c/d.e.f/g.min.js').path.basename, 'g');
      assert.equal(parse('a/b/c/d.md').path.basename, 'd');
      assert.equal(parse('a/b/{c,./d}/e/f.g').path.basename, 'f');
      assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').path.basename, 'abc');
      assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').path.basename, '*');
      assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').path.basename, 'abc');
      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');
      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, '*');
      assert.equal(parse('a/b/{c,d}/*.min.js').path.basename, '*');
      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');
      assert.equal(parse('c.md').path.basename, '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');
    });
  });

  describe('should parse a glob:', function () {
    it('ending with a brace pattern:', function () {
      assert.equal(parse('a/b/{c,d}').pattern, 'a/b/{c,d}');
      assert.equal(parse('a/b/{c,d}').path.dirname, 'a/b/');
      assert.equal(parse('a/b/{c,d}').path.filename, '{c,d}');
      assert.equal(parse('a/b/{c,d}').path.basename, '{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').pattern, 'a/b/{c,d}/*.js');
      assert.equal(parse('a/b/{c,d}/*.js').path.dirname, 'a/b/{c,d}/');
      assert.equal(parse('a/b/{c,d}/*.js').path.filename, '*.js');
      assert.equal(parse('a/b/{c,d}/*.js').path.basename, '*');
      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}/').pattern, 'a/b/{c,d}/');
      assert.equal(parse('a/b/{c,d}/').path.dirname, 'a/b/{c,d}/');
      assert.equal(parse('a/b/{c,d}/').path.filename, '');
      assert.equal(parse('a/b/{c,d}/').path.basename, '');
      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/').pattern, 'a/b/{c,d}/e.f.g/');
      assert.equal(parse('a/b/{c,d}/e.f.g/').path.dirname, 'a/b/{c,d}/e.f.g/');
      assert.equal(parse('a/b/{c,d}/e.f.g/').path.filename, '');
      assert.equal(parse('a/b/{c,d}/e.f.g/').path.basename, '');
      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/').pattern, '/a/b/{c,d}/e.f.g/');
      assert.equal(parse('/a/b/{c,d}/e.f.g/').path.dirname, '/a/b/{c,d}/e.f.g/');
      assert.equal(parse('/a/b/{c,d}/e.f.g/').path.filename, '');
      assert.equal(parse('/a/b/{c,d}/e.f.g/').path.basename, '');
      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').pattern, 'a/b/{c,d}/*.min.js');
      assert.equal(parse('a/b/{c,d}/*.min.js').path.dirname, 'a/b/{c,d}/');
      assert.equal(parse('a/b/{c,d}/*.min.js').path.filename, '*.min.js');
      assert.equal(parse('a/b/{c,d}/*.min.js').path.basename, '*');
      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').pattern, '*.min.js');
      assert.equal(parse('*.min.js').path.dirname, '');
      assert.equal(parse('*.min.js').path.filename, '*.min.js');
      assert.equal(parse('*.min.js').path.basename, '*');
      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]').pattern, '[a-j]*[^c]');
      assert.equal(parse('[a-j]*[^c]').path.dirname, '');
      assert.equal(parse('[a-j]*[^c]').path.filename, '[a-j]*[^c]');
      assert.equal(parse('[a-j]*[^c]b/c').pattern, '[a-j]*[^c]b/c');
      assert.equal(parse('[a-j]*[^c]b/c').path.dirname, '[a-j]*[^c]b/');
      assert.equal(parse('[a-j]*[^c]bc').pattern, '[a-j]*[^c]bc');
      assert.equal(parse('[a-j]*[^c]bc').path.dirname, '');
      assert.equal(parse('[a-j]*[^c]bc').path.filename, '[a-j]*[^c]bc');
    });

    it('ending with a slash:', function () {
      assert.equal(parse('a/b/{c,d}/').pattern, 'a/b/{c,d}/');
      assert.equal(parse('a/b/{c,d}/').path.dirname, 'a/b/{c,d}/');
      assert.equal(parse('a/b/{c,d}/').path.filename, '');
      assert.equal(parse('a/b/{c,d}/').path.basename, '');
      assert.equal(parse('a/b/{c,d}/').path.extname, '');
    });

    it('beginning with a slash:', function () {
      assert.equal(parse('/a/b/{c,d}/').pattern, '/a/b/{c,d}/');
      assert.equal(parse('/a/b/{c,d}/').path.dirname, '/a/b/{c,d}/');
      assert.equal(parse('/a/b/{c,d}/').path.filename, '');
      assert.equal(parse('/a/b/{c,d}/').path.basename, '');
      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').pattern, 'a/b/{c,d}/e/f.g');
      assert.equal(parse('a/b/{c,d}/e/f.g').path.dirname, 'a/b/{c,d}/e/');
      assert.equal(parse('a/b/{c,d}/e/f.g').path.filename, 'f.g');
      assert.equal(parse('a/b/{c,d}/e/f.g').path.basename, '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').pattern, 'a/b/{c,./d}/e/f.g');
      assert.equal(parse('a/b/{c,./d}/e/f.g').path.dirname, 'a/b/{c,./d}/e/');
      assert.equal(parse('a/b/{c,./d}/e/f.g').path.filename, 'f.g');
      assert.equal(parse('a/b/{c,./d}/e/f.g').path.basename, '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').pattern, 'a/b/{c,/d}/e/f.g');
      assert.equal(parse('a/b/{c,/d}/e/f.g').path.dirname, 'a/b/{c,/d}/e/');
      assert.equal(parse('a/b/{c,/d}/e/f.g').path.filename, 'f.g');
      assert.equal(parse('a/b/{c,/d}/e/f.g').path.basename, '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').original, '/a/b/{c,d}/*.js');
      assert.equal(parse('/a/b/{c,d}/*.js').original, '/a/b/{c,d}/*.js');
    });

    it('should extract the dirname', function () {
      assert.equal(parse('/a/b/{c,d}/*.js').path.dirname, '/a/b/{c,d}/');
      assert.equal(parse('/a/b/{c,d}/*.min.js').path.dirname, '/a/b/{c,d}/');
    });

    it('should extract the filename', function () {
      assert.equal(parse('/a/b/{c,d}/*.js').path.filename, '*.js');
      assert.equal(parse('/a/b/{c,d}/*.min.js').path.filename, '*.min.js');
    });

    it('should extract the basename', function () {
      assert.equal(parse('/a/b/{c,d}/*.js').path.basename, '*');
      assert.equal(parse('/a/b/{c,d}/*.min.js').path.basename, '*');
    });

    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');
    });
  });

  it('should match when the filename starts with a star:', function () {
    assert.equal(parse('a/b/*.{foo,bar}').pattern, 'a/b/*.{foo,bar}');
    assert.equal(parse('a/b/*.{foo,bar}').path.dirname, 'a/b/');
    assert.equal(parse('a/b/*.{foo,bar}').path.filename, '*.{foo,bar}');
    assert.equal(parse('a/b/*.{foo,bar}').path.basename, '*');
    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}').pattern, 'a/**/b/*.{foo,bar}');
    assert.equal(parse('a/**/b/*.{foo,bar}').path.dirname, 'a/**/b/');
    assert.equal(parse('a/**/b/*.{foo,bar}').path.filename, '*.{foo,bar}');
    assert.equal(parse('a/**/b/*.{foo,bar}').path.basename, '*');
    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').pattern, 'a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js');
    assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').path.dirname, 'a/b/{c,.gitignore,{a,b}}/{a,b}/');
    assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').path.filename, 'abc.foo.js');
    assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/abc.foo.js').path.basename, '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').pattern, 'a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js');
    assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').path.dirname, 'a/b/{c,.gitignore,{a,b}}/{a,b}/');
    assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').path.filename, '*.foo.js');
    assert.equal(parse('a/b/{c,.gitignore,{a,b}}/{a,b}/*.foo.js').path.basename, '*');
    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').pattern, 'a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js');
    assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').path.dirname, 'a/b/{c,.gitignore,{a,./b}}/{a,b}/');
    assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').path.filename, 'abc.foo.js');
    assert.equal(parse('a/b/{c,.gitignore,{a,./b}}/{a,b}/abc.foo.js').path.basename, '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');
  });

  it('should match a path with an extension:', function () {
    assert.equal(parse('a/b/c.md').pattern, 'a/b/c.md');
    assert.equal(parse('a/b/c.md').path.dirname, 'a/b/');
    assert.equal(parse('a/b/c.md').path.filename, 'c.md');
    assert.equal(parse('a/b/c.md').path.basename, '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').pattern, 'c.md');
    assert.equal(parse('c.md').path.dirname, '');
    assert.equal(parse('c.md').path.filename, 'c.md');
    assert.equal(parse('c.md').path.basename, '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').pattern, 'a/b/c.min.js');
    assert.equal(parse('a/b/c.min.js').path.dirname, 'a/b/');
    assert.equal(parse('a/b/c.min.js').path.filename, 'c.min.js');
    assert.equal(parse('a/b/c.min.js').path.basename, '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').pattern, 'a/b/c/d.e.f/g.min.js');
    assert.equal(parse('a/b/c/d.e.f/g.min.js').path.dirname, 'a/b/c/d.e.f/');
    assert.equal(parse('a/b/c/d.e.f/g.min.js').path.filename, 'g.min.js');
    assert.equal(parse('a/b/c/d.e.f/g.min.js').path.basename, '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').pattern, 'a');
    assert.equal(parse('a').path.dirname, '');
    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').pattern, 'a/b/c/d.md');
    assert.equal(parse('a/b/c/d.md').path.dirname, 'a/b/c/');
    assert.equal(parse('a/b/c/d.md').path.filename, 'd.md');
    assert.equal(parse('a/b/c/d.md').path.basename, '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').pattern, 'a/b/c.d/e.md');
    assert.equal(parse('a/b/c.d/e.md').path.dirname, 'a/b/c.d/');
    assert.equal(parse('a/b/c.d/e.md').path.filename, 'e.md');
    assert.equal(parse('a/b/c.d/e.md').path.basename, '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('trailing and leading slashs:', function () {
    it('should work without a trailing slash:', function () {
      assert.equal(parse('a/b/c').pattern, 'a/b/c');
      assert.equal(parse('a/b/c').path.dirname, '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/').pattern, 'a/b/c/');
      assert.equal(parse('a/b/c/').path.dirname, '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').pattern, '/a/b/c');
      assert.equal(parse('/a/b/c').path.dirname, '/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/').pattern, '/a/b/c/');
      assert.equal(parse('/a/b/c/').path.dirname, '/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 () {
    it('should know when the file is dotfile:', function () {
      assert.equal(parse('a/b/.gitignore').path.dirname, 'a/b/');
      assert.equal(parse('a/b/.gitignore').path.filename, '.gitignore');
      assert.equal(parse('a/b/.gitignore').path.basename, '');
      assert.equal(parse('a/b/.gitignore').path.extname, '.gitignore');
      assert.equal(parse('a/b/.gitignore').path.ext, 'gitignore');
    });
  });


  it('should match character classes:', function () {
    assert.equal(parse('[a-c]b*').pattern, '[a-c]b*');
    assert.equal(parse('[a-j]*[^c]').pattern, '[a-j]*[^c]');
    assert.equal(parse('[a-j]*[^c]').path.dirname, '');
    assert.equal(parse('[a-j]*[^c]').path.filename, '[a-j]*[^c]');
    assert.equal(parse('[a-j]*[^c]b/c').pattern, '[a-j]*[^c]b/c');
    assert.equal(parse('[a-j]*[^c]bc').pattern, '[a-j]*[^c]bc');
  });

  it('should work when a character class has trailing word characters:', function () {
    assert.equal(parse('[a-c]b*').pattern, '[a-c]b*');
    assert.equal(parse('[a-c]b*').path.dirname, '');
    assert.equal(parse('[a-c]b*').path.filename, '[a-c]b*');
    assert.equal(parse('[a-c]b*').path.basename, '[a-c]b*');
    assert.equal(parse('[a-c]b*').path.extname, '');
    assert.equal(parse('[a-j]*[^c]bc').path.dirname, '');
    assert.equal(parse('[a-j]*[^c]bc').path.filename, '[a-j]*[^c]bc');
    assert.equal(parse('[a-j]*[^c]bc').path.basename, '[a-j]*[^c]bc');
    assert.equal(parse('[a-j]*[^c]bc').path.extname, '');
  });
});

describe('when the glob has brace patterns:', function () {
  it('should extract the `base` from the glob:', function () {
    assert.equal(getBase('a/b/{c,/.gitignore}').base, 'a/b');
    assert.equal(getBase('a/b/{c,/.gitignore}').pattern, '{c,/.gitignore}');

    assert.equal(getBase('a/b/{c,/gitignore}').base, 'a/b');
    assert.equal(getBase('a/b/{c,/gitignore}').pattern, '{c,/gitignore}');

    assert.equal(getBase('a/b/{c,.gitignore}').base, 'a/b');
    assert.equal(getBase('a/b/{c,.gitignore}').pattern, '{c,.gitignore}');
  });

  it('should work when the brace pattern has dots and slashes:', function () {
    assert.equal(parse('a/b/{c,/.gitignore}').pattern, 'a/b/{c,/.gitignore}');
    assert.equal(parse('a/b/{c,/.gitignore}').path.dirname, 'a/b/');
    assert.equal(parse('a/b/{c,/.gitignore}').path.filename, '{c,/.gitignore}');
    assert.equal(parse('a/b/{c,/.gitignore}').path.basename, '{c,/.gitignore}');
    assert.equal(parse('a/b/{c,/.gitignore}').path.extname, '');

    assert.equal(parse('a/b/{c,/gitignore}').pattern, 'a/b/{c,/gitignore}');
    assert.equal(parse('a/b/{c,/gitignore}').path.dirname, 'a/b/');
    assert.equal(parse('a/b/{c,/gitignore}').path.filename, '{c,/gitignore}');
    assert.equal(parse('a/b/{c,/gitignore}').path.basename, '{c,/gitignore}');
    assert.equal(parse('a/b/{c,/gitignore}').path.extname, '');

    assert.equal(parse('a/b/{c,.gitignore}').pattern, 'a/b/{c,.gitignore}');
    assert.equal(parse('a/b/{c,.gitignore}').path.dirname, 'a/b/');
    assert.equal(parse('a/b/{c,.gitignore}').path.filename, '{c,.gitignore}');
    assert.equal(parse('a/b/{c,.gitignore}').path.basename, '{c,.gitignore}');
    assert.equal(parse('a/b/{c,.gitignore}').path.extname, '');
  });

  it('should work when the brace pattern has a leading dot in the dirname:', function () {
    assert.equal(parse('a/b/.{foo,bar}/foo.js').pattern, 'a/b/.{foo,bar}/foo.js');
    assert.equal(parse('a/b/.{foo,bar}/foo.js').path.dirname, 'a/b/.{foo,bar}/');
    assert.equal(parse('a/b/.{foo,bar}/foo.js').path.filename, 'foo.js');
    assert.equal(parse('a/b/.{foo,bar}/foo.js').path.basename, 'foo');
    assert.equal(parse('a/b/.{foo,bar}/foo.js').path.extname, '.js');
    assert.equal(parse('a/b/.{foo,bar}/foo.js').path.ext, 'js');
  });

  it('should work when the brace pattern has a leading dot in the filename:', function () {
    assert.equal(parse('a/b/.{foo,bar}').pattern, 'a/b/.{foo,bar}');
    assert.equal(parse('a/b/.{foo,bar}').path.dirname, 'a/b/');
    assert.equal(parse('a/b/.{foo,bar}').path.filename, '.{foo,bar}');
    assert.equal(parse('a/b/.{foo,bar}').path.basename, '');
    assert.equal(parse('a/b/.{foo,bar}').path.extname, '.{foo,bar}');
    assert.equal(parse('a/b/.{foo,bar}').path.ext, '{foo,bar}');

    assert.equal(parse('a/b/.{c,/.gitignore}').pattern, 'a/b/.{c,/.gitignore}');
    assert.equal(parse('a/b/.{c,/.gitignore}').path.dirname, 'a/b/');
    assert.equal(parse('a/b/.{c,/.gitignore}').path.filename, '.{c,/.gitignore}');
    assert.equal(parse('a/b/.{c,/.gitignore}').path.basename, '');
    assert.equal(parse('a/b/.{c,/.gitignore}').path.extname, '.{c,/.gitignore}');

    assert.equal(parse('a/b/.{c,.gitignore}').pattern, 'a/b/.{c,.gitignore}');
    assert.equal(parse('a/b/.{c,.gitignore}').path.dirname, 'a/b/');
    assert.equal(parse('a/b/.{c,.gitignore}').path.filename, '.{c,.gitignore}');
    assert.equal(parse('a/b/.{c,.gitignore}').path.basename, '');
    assert.equal(parse('a/b/.{c,.gitignore}').path.extname, '.{c,.gitignore}');
    assert.equal(parse('a/b/.{c,.gitignore}').path.ext, '{c,.gitignore}');
  });
});