CoCalc -- glob.test.ts

GitHub Repository: microsoft/vscode
Path: blob/main/src/vs/base/test/common/glob.test.ts
³²⁹⁶ views
1
/*---------------------------------------------------------------------------------------------
2
 *  Copyright (c) Microsoft Corporation. All rights reserved.
3
 *  Licensed under the MIT License. See License.txt in the project root for license information.
4
 *--------------------------------------------------------------------------------------------*/
5

6
import assert from 'assert';
7
import * as glob from '../../common/glob.js';
8
import { sep } from '../../common/path.js';
9
import { isLinux, isMacintosh, isWindows } from '../../common/platform.js';
10
import { URI } from '../../common/uri.js';
11
import { ensureNoDisposablesAreLeakedInTestSuite } from './utils.js';
12

13
suite('Glob', () => {
14

15
	// test('perf', () => {
16

17
	// 	let patterns = [
18
	// 		'{**/*.cs,**/*.json,**/*.csproj,**/*.sln}',
19
	// 		'{**/*.cs,**/*.csproj,**/*.sln}',
20
	// 		'{**/*.ts,**/*.tsx,**/*.js,**/*.jsx,**/*.es6,**/*.mjs,**/*.cjs}',
21
	// 		'**/*.go',
22
	// 		'{**/*.ps,**/*.ps1}',
23
	// 		'{**/*.c,**/*.cpp,**/*.h}',
24
	// 		'{**/*.fsx,**/*.fsi,**/*.fs,**/*.ml,**/*.mli}',
25
	// 		'{**/*.js,**/*.jsx,**/*.es6,**/*.mjs,**/*.cjs}',
26
	// 		'{**/*.ts,**/*.tsx}',
27
	// 		'{**/*.php}',
28
	// 		'{**/*.php}',
29
	// 		'{**/*.php}',
30
	// 		'{**/*.php}',
31
	// 		'{**/*.py}',
32
	// 		'{**/*.py}',
33
	// 		'{**/*.py}',
34
	// 		'{**/*.rs,**/*.rslib}',
35
	// 		'{**/*.cpp,**/*.cc,**/*.h}',
36
	// 		'{**/*.md}',
37
	// 		'{**/*.md}',
38
	// 		'{**/*.md}'
39
	// 	];
40

41
	// 	let paths = [
42
	// 		'/DNXConsoleApp/Program.cs',
43
	// 		'C:\\DNXConsoleApp\\foo\\Program.cs',
44
	// 		'test/qunit',
45
	// 		'test/test.txt',
46
	// 		'test/node_modules',
47
	// 		'.hidden.txt',
48
	// 		'/node_module/test/foo.js'
49
	// 	];
50

51
	// 	let results = 0;
52
	// 	let c = 1000;
53
	// 	console.profile('glob.match');
54
	// 	while (c-- > 0) {
55
	// 		for (let path of paths) {
56
	// 			for (let pattern of patterns) {
57
	// 				let r = glob.match(pattern, path);
58
	// 				if (r) {
59
	// 					results += 42;
60
	// 				}
61
	// 			}
62
	// 		}
63
	// 	}
64
	// 	console.profileEnd();
65
	// });
66

67
	function assertGlobMatch(pattern: string | glob.IRelativePattern, input: string) {
68
		assert(glob.match(pattern, input), `${JSON.stringify(pattern)} should match ${input}`);
69
		assert(glob.match(pattern, nativeSep(input)), `${pattern} should match ${nativeSep(input)}`);
70
	}
71

72
	function assertNoGlobMatch(pattern: string | glob.IRelativePattern, input: string) {
73
		assert(!glob.match(pattern, input), `${pattern} should not match ${input}`);
74
		assert(!glob.match(pattern, nativeSep(input)), `${pattern} should not match ${nativeSep(input)}`);
75
	}
76

77
	test('simple', () => {
78
		let p = 'node_modules';
79

80
		assertGlobMatch(p, 'node_modules');
81
		assertNoGlobMatch(p, 'node_module');
82
		assertNoGlobMatch(p, '/node_modules');
83
		assertNoGlobMatch(p, 'test/node_modules');
84

85
		p = 'test.txt';
86
		assertGlobMatch(p, 'test.txt');
87
		assertNoGlobMatch(p, 'test?txt');
88
		assertNoGlobMatch(p, '/text.txt');
89
		assertNoGlobMatch(p, 'test/test.txt');
90

91
		p = 'test(.txt';
92
		assertGlobMatch(p, 'test(.txt');
93
		assertNoGlobMatch(p, 'test?txt');
94

95
		p = 'qunit';
96

97
		assertGlobMatch(p, 'qunit');
98
		assertNoGlobMatch(p, 'qunit.css');
99
		assertNoGlobMatch(p, 'test/qunit');
100

101
		// Absolute
102

103
		p = '/DNXConsoleApp/**/*.cs';
104
		assertGlobMatch(p, '/DNXConsoleApp/Program.cs');
105
		assertGlobMatch(p, '/DNXConsoleApp/foo/Program.cs');
106

107
		p = 'C:/DNXConsoleApp/**/*.cs';
108
		assertGlobMatch(p, 'C:\\DNXConsoleApp\\Program.cs');
109
		assertGlobMatch(p, 'C:\\DNXConsoleApp\\foo\\Program.cs');
110

111
		p = '*';
112
		assertGlobMatch(p, '');
113
	});
114

115
	test('dot hidden', function () {
116
		let p = '.*';
117

118
		assertGlobMatch(p, '.git');
119
		assertGlobMatch(p, '.hidden.txt');
120
		assertNoGlobMatch(p, 'git');
121
		assertNoGlobMatch(p, 'hidden.txt');
122
		assertNoGlobMatch(p, 'path/.git');
123
		assertNoGlobMatch(p, 'path/.hidden.txt');
124

125
		p = '**/.*';
126
		assertGlobMatch(p, '.git');
127
		assertGlobMatch(p, '/.git');
128
		assertGlobMatch(p, '.hidden.txt');
129
		assertNoGlobMatch(p, 'git');
130
		assertNoGlobMatch(p, 'hidden.txt');
131
		assertGlobMatch(p, 'path/.git');
132
		assertGlobMatch(p, 'path/.hidden.txt');
133
		assertGlobMatch(p, '/path/.git');
134
		assertGlobMatch(p, '/path/.hidden.txt');
135
		assertNoGlobMatch(p, 'path/git');
136
		assertNoGlobMatch(p, 'pat.h/hidden.txt');
137

138
		p = '._*';
139

140
		assertGlobMatch(p, '._git');
141
		assertGlobMatch(p, '._hidden.txt');
142
		assertNoGlobMatch(p, 'git');
143
		assertNoGlobMatch(p, 'hidden.txt');
144
		assertNoGlobMatch(p, 'path/._git');
145
		assertNoGlobMatch(p, 'path/._hidden.txt');
146

147
		p = '**/._*';
148
		assertGlobMatch(p, '._git');
149
		assertGlobMatch(p, '._hidden.txt');
150
		assertNoGlobMatch(p, 'git');
151
		assertNoGlobMatch(p, 'hidden._txt');
152
		assertGlobMatch(p, 'path/._git');
153
		assertGlobMatch(p, 'path/._hidden.txt');
154
		assertGlobMatch(p, '/path/._git');
155
		assertGlobMatch(p, '/path/._hidden.txt');
156
		assertNoGlobMatch(p, 'path/git');
157
		assertNoGlobMatch(p, 'pat.h/hidden._txt');
158
	});
159

160
	test('file pattern', function () {
161
		let p = '*.js';
162

163
		assertGlobMatch(p, 'foo.js');
164
		assertNoGlobMatch(p, 'folder/foo.js');
165
		assertNoGlobMatch(p, '/node_modules/foo.js');
166
		assertNoGlobMatch(p, 'foo.jss');
167
		assertNoGlobMatch(p, 'some.js/test');
168

169
		p = 'html.*';
170
		assertGlobMatch(p, 'html.js');
171
		assertGlobMatch(p, 'html.txt');
172
		assertNoGlobMatch(p, 'htm.txt');
173

174
		p = '*.*';
175
		assertGlobMatch(p, 'html.js');
176
		assertGlobMatch(p, 'html.txt');
177
		assertGlobMatch(p, 'htm.txt');
178
		assertNoGlobMatch(p, 'folder/foo.js');
179
		assertNoGlobMatch(p, '/node_modules/foo.js');
180

181
		p = 'node_modules/test/*.js';
182
		assertGlobMatch(p, 'node_modules/test/foo.js');
183
		assertNoGlobMatch(p, 'folder/foo.js');
184
		assertNoGlobMatch(p, '/node_module/test/foo.js');
185
		assertNoGlobMatch(p, 'foo.jss');
186
		assertNoGlobMatch(p, 'some.js/test');
187
	});
188

189
	test('star', () => {
190
		let p = 'node*modules';
191

192
		assertGlobMatch(p, 'node_modules');
193
		assertGlobMatch(p, 'node_super_modules');
194
		assertNoGlobMatch(p, 'node_module');
195
		assertNoGlobMatch(p, '/node_modules');
196
		assertNoGlobMatch(p, 'test/node_modules');
197

198
		p = '*';
199
		assertGlobMatch(p, 'html.js');
200
		assertGlobMatch(p, 'html.txt');
201
		assertGlobMatch(p, 'htm.txt');
202
		assertNoGlobMatch(p, 'folder/foo.js');
203
		assertNoGlobMatch(p, '/node_modules/foo.js');
204
	});
205

206
	test('file / folder match', function () {
207
		const p = '**/node_modules/**';
208

209
		assertGlobMatch(p, 'node_modules');
210
		assertGlobMatch(p, 'node_modules/');
211
		assertGlobMatch(p, 'a/node_modules');
212
		assertGlobMatch(p, 'a/node_modules/');
213
		assertGlobMatch(p, 'node_modules/foo');
214
		assertGlobMatch(p, 'foo/node_modules/foo/bar');
215

216
		assertGlobMatch(p, '/node_modules');
217
		assertGlobMatch(p, '/node_modules/');
218
		assertGlobMatch(p, '/a/node_modules');
219
		assertGlobMatch(p, '/a/node_modules/');
220
		assertGlobMatch(p, '/node_modules/foo');
221
		assertGlobMatch(p, '/foo/node_modules/foo/bar');
222
	});
223

224
	test('questionmark', () => {
225
		let p = 'node?modules';
226

227
		assertGlobMatch(p, 'node_modules');
228
		assertNoGlobMatch(p, 'node_super_modules');
229
		assertNoGlobMatch(p, 'node_module');
230
		assertNoGlobMatch(p, '/node_modules');
231
		assertNoGlobMatch(p, 'test/node_modules');
232

233
		p = '?';
234
		assertGlobMatch(p, 'h');
235
		assertNoGlobMatch(p, 'html.txt');
236
		assertNoGlobMatch(p, 'htm.txt');
237
		assertNoGlobMatch(p, 'folder/foo.js');
238
		assertNoGlobMatch(p, '/node_modules/foo.js');
239
	});
240

241
	test('globstar', () => {
242
		let p = '**/*.js';
243

244
		assertGlobMatch(p, 'foo.js');
245
		assertGlobMatch(p, '/foo.js');
246
		assertGlobMatch(p, 'folder/foo.js');
247
		assertGlobMatch(p, '/node_modules/foo.js');
248
		assertNoGlobMatch(p, 'foo.jss');
249
		assertNoGlobMatch(p, 'some.js/test');
250
		assertNoGlobMatch(p, '/some.js/test');
251
		assertNoGlobMatch(p, '\\some.js\\test');
252

253
		p = '**/project.json';
254

255
		assertGlobMatch(p, 'project.json');
256
		assertGlobMatch(p, '/project.json');
257
		assertGlobMatch(p, 'some/folder/project.json');
258
		assertGlobMatch(p, '/some/folder/project.json');
259
		assertNoGlobMatch(p, 'some/folder/file_project.json');
260
		assertNoGlobMatch(p, 'some/folder/fileproject.json');
261
		assertNoGlobMatch(p, 'some/rrproject.json');
262
		assertNoGlobMatch(p, 'some\\rrproject.json');
263

264
		p = 'test/**';
265
		assertGlobMatch(p, 'test');
266
		assertGlobMatch(p, 'test/foo');
267
		assertGlobMatch(p, 'test/foo/');
268
		assertGlobMatch(p, 'test/foo.js');
269
		assertGlobMatch(p, 'test/other/foo.js');
270
		assertNoGlobMatch(p, 'est/other/foo.js');
271

272
		p = '**';
273
		assertGlobMatch(p, '/');
274
		assertGlobMatch(p, 'foo.js');
275
		assertGlobMatch(p, 'folder/foo.js');
276
		assertGlobMatch(p, 'folder/foo/');
277
		assertGlobMatch(p, '/node_modules/foo.js');
278
		assertGlobMatch(p, 'foo.jss');
279
		assertGlobMatch(p, 'some.js/test');
280

281
		p = 'test/**/*.js';
282
		assertGlobMatch(p, 'test/foo.js');
283
		assertGlobMatch(p, 'test/other/foo.js');
284
		assertGlobMatch(p, 'test/other/more/foo.js');
285
		assertNoGlobMatch(p, 'test/foo.ts');
286
		assertNoGlobMatch(p, 'test/other/foo.ts');
287
		assertNoGlobMatch(p, 'test/other/more/foo.ts');
288

289
		p = '**/**/*.js';
290

291
		assertGlobMatch(p, 'foo.js');
292
		assertGlobMatch(p, '/foo.js');
293
		assertGlobMatch(p, 'folder/foo.js');
294
		assertGlobMatch(p, '/node_modules/foo.js');
295
		assertNoGlobMatch(p, 'foo.jss');
296
		assertNoGlobMatch(p, 'some.js/test');
297

298
		p = '**/node_modules/**/*.js';
299

300
		assertNoGlobMatch(p, 'foo.js');
301
		assertNoGlobMatch(p, 'folder/foo.js');
302
		assertGlobMatch(p, 'node_modules/foo.js');
303
		assertGlobMatch(p, '/node_modules/foo.js');
304
		assertGlobMatch(p, 'node_modules/some/folder/foo.js');
305
		assertGlobMatch(p, '/node_modules/some/folder/foo.js');
306
		assertNoGlobMatch(p, 'node_modules/some/folder/foo.ts');
307
		assertNoGlobMatch(p, 'foo.jss');
308
		assertNoGlobMatch(p, 'some.js/test');
309

310
		p = '{**/node_modules/**,**/.git/**,**/bower_components/**}';
311

312
		assertGlobMatch(p, 'node_modules');
313
		assertGlobMatch(p, '/node_modules');
314
		assertGlobMatch(p, '/node_modules/more');
315
		assertGlobMatch(p, 'some/test/node_modules');
316
		assertGlobMatch(p, 'some\\test\\node_modules');
317
		assertGlobMatch(p, '/some/test/node_modules');
318
		assertGlobMatch(p, '\\some\\test\\node_modules');
319
		assertGlobMatch(p, 'C:\\\\some\\test\\node_modules');
320
		assertGlobMatch(p, 'C:\\\\some\\test\\node_modules\\more');
321

322
		assertGlobMatch(p, 'bower_components');
323
		assertGlobMatch(p, 'bower_components/more');
324
		assertGlobMatch(p, '/bower_components');
325
		assertGlobMatch(p, 'some/test/bower_components');
326
		assertGlobMatch(p, 'some\\test\\bower_components');
327
		assertGlobMatch(p, '/some/test/bower_components');
328
		assertGlobMatch(p, '\\some\\test\\bower_components');
329
		assertGlobMatch(p, 'C:\\\\some\\test\\bower_components');
330
		assertGlobMatch(p, 'C:\\\\some\\test\\bower_components\\more');
331

332
		assertGlobMatch(p, '.git');
333
		assertGlobMatch(p, '/.git');
334
		assertGlobMatch(p, 'some/test/.git');
335
		assertGlobMatch(p, 'some\\test\\.git');
336
		assertGlobMatch(p, '/some/test/.git');
337
		assertGlobMatch(p, '\\some\\test\\.git');
338
		assertGlobMatch(p, 'C:\\\\some\\test\\.git');
339

340
		assertNoGlobMatch(p, 'tempting');
341
		assertNoGlobMatch(p, '/tempting');
342
		assertNoGlobMatch(p, 'some/test/tempting');
343
		assertNoGlobMatch(p, 'some\\test\\tempting');
344
		assertNoGlobMatch(p, '/some/test/tempting');
345
		assertNoGlobMatch(p, '\\some\\test\\tempting');
346
		assertNoGlobMatch(p, 'C:\\\\some\\test\\tempting');
347

348
		p = '{**/package.json,**/project.json}';
349
		assertGlobMatch(p, 'package.json');
350
		assertGlobMatch(p, '/package.json');
351
		assertNoGlobMatch(p, 'xpackage.json');
352
		assertNoGlobMatch(p, '/xpackage.json');
353
	});
354

355
	test('issue 41724', function () {
356
		let p = 'some/**/*.js';
357

358
		assertGlobMatch(p, 'some/foo.js');
359
		assertGlobMatch(p, 'some/folder/foo.js');
360
		assertNoGlobMatch(p, 'something/foo.js');
361
		assertNoGlobMatch(p, 'something/folder/foo.js');
362

363
		p = 'some/**/*';
364

365
		assertGlobMatch(p, 'some/foo.js');
366
		assertGlobMatch(p, 'some/folder/foo.js');
367
		assertNoGlobMatch(p, 'something/foo.js');
368
		assertNoGlobMatch(p, 'something/folder/foo.js');
369
	});
370

371
	test('brace expansion', function () {
372
		let p = '*.{html,js}';
373

374
		assertGlobMatch(p, 'foo.js');
375
		assertGlobMatch(p, 'foo.html');
376
		assertNoGlobMatch(p, 'folder/foo.js');
377
		assertNoGlobMatch(p, '/node_modules/foo.js');
378
		assertNoGlobMatch(p, 'foo.jss');
379
		assertNoGlobMatch(p, 'some.js/test');
380

381
		p = '*.{html}';
382

383
		assertGlobMatch(p, 'foo.html');
384
		assertNoGlobMatch(p, 'foo.js');
385
		assertNoGlobMatch(p, 'folder/foo.js');
386
		assertNoGlobMatch(p, '/node_modules/foo.js');
387
		assertNoGlobMatch(p, 'foo.jss');
388
		assertNoGlobMatch(p, 'some.js/test');
389

390
		p = '{node_modules,testing}';
391
		assertGlobMatch(p, 'node_modules');
392
		assertGlobMatch(p, 'testing');
393
		assertNoGlobMatch(p, 'node_module');
394
		assertNoGlobMatch(p, 'dtesting');
395

396
		p = '**/{foo,bar}';
397
		assertGlobMatch(p, 'foo');
398
		assertGlobMatch(p, 'bar');
399
		assertGlobMatch(p, 'test/foo');
400
		assertGlobMatch(p, 'test/bar');
401
		assertGlobMatch(p, 'other/more/foo');
402
		assertGlobMatch(p, 'other/more/bar');
403
		assertGlobMatch(p, '/foo');
404
		assertGlobMatch(p, '/bar');
405
		assertGlobMatch(p, '/test/foo');
406
		assertGlobMatch(p, '/test/bar');
407
		assertGlobMatch(p, '/other/more/foo');
408
		assertGlobMatch(p, '/other/more/bar');
409

410
		p = '{foo,bar}/**';
411
		assertGlobMatch(p, 'foo');
412
		assertGlobMatch(p, 'bar');
413
		assertGlobMatch(p, 'bar/');
414
		assertGlobMatch(p, 'foo/test');
415
		assertGlobMatch(p, 'bar/test');
416
		assertGlobMatch(p, 'bar/test/');
417
		assertGlobMatch(p, 'foo/other/more');
418
		assertGlobMatch(p, 'bar/other/more');
419
		assertGlobMatch(p, 'bar/other/more/');
420

421
		p = '{**/*.d.ts,**/*.js}';
422

423
		assertGlobMatch(p, 'foo.js');
424
		assertGlobMatch(p, 'testing/foo.js');
425
		assertGlobMatch(p, 'testing\\foo.js');
426
		assertGlobMatch(p, '/testing/foo.js');
427
		assertGlobMatch(p, '\\testing\\foo.js');
428
		assertGlobMatch(p, 'C:\\testing\\foo.js');
429

430
		assertGlobMatch(p, 'foo.d.ts');
431
		assertGlobMatch(p, 'testing/foo.d.ts');
432
		assertGlobMatch(p, 'testing\\foo.d.ts');
433
		assertGlobMatch(p, '/testing/foo.d.ts');
434
		assertGlobMatch(p, '\\testing\\foo.d.ts');
435
		assertGlobMatch(p, 'C:\\testing\\foo.d.ts');
436

437
		assertNoGlobMatch(p, 'foo.d');
438
		assertNoGlobMatch(p, 'testing/foo.d');
439
		assertNoGlobMatch(p, 'testing\\foo.d');
440
		assertNoGlobMatch(p, '/testing/foo.d');
441
		assertNoGlobMatch(p, '\\testing\\foo.d');
442
		assertNoGlobMatch(p, 'C:\\testing\\foo.d');
443

444
		p = '{**/*.d.ts,**/*.js,path/simple.jgs}';
445

446
		assertGlobMatch(p, 'foo.js');
447
		assertGlobMatch(p, 'testing/foo.js');
448
		assertGlobMatch(p, 'testing\\foo.js');
449
		assertGlobMatch(p, '/testing/foo.js');
450
		assertGlobMatch(p, 'path/simple.jgs');
451
		assertNoGlobMatch(p, '/path/simple.jgs');
452
		assertGlobMatch(p, '\\testing\\foo.js');
453
		assertGlobMatch(p, 'C:\\testing\\foo.js');
454

455
		p = '{**/*.d.ts,**/*.js,foo.[0-9]}';
456

457
		assertGlobMatch(p, 'foo.5');
458
		assertGlobMatch(p, 'foo.8');
459
		assertNoGlobMatch(p, 'bar.5');
460
		assertNoGlobMatch(p, 'foo.f');
461
		assertGlobMatch(p, 'foo.js');
462

463
		p = 'prefix/{**/*.d.ts,**/*.js,foo.[0-9]}';
464

465
		assertGlobMatch(p, 'prefix/foo.5');
466
		assertGlobMatch(p, 'prefix/foo.8');
467
		assertNoGlobMatch(p, 'prefix/bar.5');
468
		assertNoGlobMatch(p, 'prefix/foo.f');
469
		assertGlobMatch(p, 'prefix/foo.js');
470
	});
471

472
	test('expression support (single)', function () {
473
		const siblings = ['test.html', 'test.txt', 'test.ts', 'test.js'];
474
		const hasSibling = (name: string) => siblings.indexOf(name) !== -1;
475

476
		// { "**/*.js": { "when": "$(basename).ts" } }
477
		let expression: glob.IExpression = {
478
			'**/*.js': {
479
				when: '$(basename).ts'
480
			}
481
		};
482

483
		assert.strictEqual('**/*.js', glob.match(expression, 'test.js', hasSibling));
484
		assert.strictEqual(glob.match(expression, 'test.js', () => false), null);
485
		assert.strictEqual(glob.match(expression, 'test.js', name => name === 'te.ts'), null);
486
		assert.strictEqual(glob.match(expression, 'test.js'), null);
487

488
		expression = {
489
			'**/*.js': {
490
				when: ''
491
			}
492
		};
493

494
		assert.strictEqual(glob.match(expression, 'test.js', hasSibling), null);
495

496
		expression = {
497
			'**/*.js': {
498
			} as any
499
		};
500

501
		assert.strictEqual('**/*.js', glob.match(expression, 'test.js', hasSibling));
502

503
		expression = {};
504

505
		assert.strictEqual(glob.match(expression, 'test.js', hasSibling), null);
506
	});
507

508
	test('expression support (multiple)', function () {
509
		const siblings = ['test.html', 'test.txt', 'test.ts', 'test.js'];
510
		const hasSibling = (name: string) => siblings.indexOf(name) !== -1;
511

512
		// { "**/*.js": { "when": "$(basename).ts" } }
513
		const expression: glob.IExpression = {
514
			'**/*.js': { when: '$(basename).ts' },
515
			'**/*.as': true,
516
			'**/*.foo': false,
517
			'**/*.bananas': { bananas: true } as any
518
		};
519

520
		assert.strictEqual('**/*.js', glob.match(expression, 'test.js', hasSibling));
521
		assert.strictEqual('**/*.as', glob.match(expression, 'test.as', hasSibling));
522
		assert.strictEqual('**/*.bananas', glob.match(expression, 'test.bananas', hasSibling));
523
		assert.strictEqual('**/*.bananas', glob.match(expression, 'test.bananas'));
524
		assert.strictEqual(glob.match(expression, 'test.foo', hasSibling), null);
525
	});
526

527
	test('brackets', () => {
528
		let p = 'foo.[0-9]';
529

530
		assertGlobMatch(p, 'foo.5');
531
		assertGlobMatch(p, 'foo.8');
532
		assertNoGlobMatch(p, 'bar.5');
533
		assertNoGlobMatch(p, 'foo.f');
534

535
		p = 'foo.[^0-9]';
536

537
		assertNoGlobMatch(p, 'foo.5');
538
		assertNoGlobMatch(p, 'foo.8');
539
		assertNoGlobMatch(p, 'bar.5');
540
		assertGlobMatch(p, 'foo.f');
541

542
		p = 'foo.[!0-9]';
543

544
		assertNoGlobMatch(p, 'foo.5');
545
		assertNoGlobMatch(p, 'foo.8');
546
		assertNoGlobMatch(p, 'bar.5');
547
		assertGlobMatch(p, 'foo.f');
548

549
		p = 'foo.[0!^*?]';
550

551
		assertNoGlobMatch(p, 'foo.5');
552
		assertNoGlobMatch(p, 'foo.8');
553
		assertGlobMatch(p, 'foo.0');
554
		assertGlobMatch(p, 'foo.!');
555
		assertGlobMatch(p, 'foo.^');
556
		assertGlobMatch(p, 'foo.*');
557
		assertGlobMatch(p, 'foo.?');
558

559
		p = 'foo[/]bar';
560

561
		assertNoGlobMatch(p, 'foo/bar');
562

563
		p = 'foo.[[]';
564

565
		assertGlobMatch(p, 'foo.[');
566

567
		p = 'foo.[]]';
568

569
		assertGlobMatch(p, 'foo.]');
570

571
		p = 'foo.[][!]';
572

573
		assertGlobMatch(p, 'foo.]');
574
		assertGlobMatch(p, 'foo.[');
575
		assertGlobMatch(p, 'foo.!');
576

577
		p = 'foo.[]-]';
578

579
		assertGlobMatch(p, 'foo.]');
580
		assertGlobMatch(p, 'foo.-');
581
	});
582

583
	test('full path', function () {
584
		assertGlobMatch('testing/this/foo.txt', 'testing/this/foo.txt');
585
	});
586

587
	test('ending path', function () {
588
		assertGlobMatch('**/testing/this/foo.txt', 'some/path/testing/this/foo.txt');
589
	});
590

591
	test('prefix agnostic', function () {
592
		let p = '**/*.js';
593

594
		assertGlobMatch(p, 'foo.js');
595
		assertGlobMatch(p, '/foo.js');
596
		assertGlobMatch(p, '\\foo.js');
597
		assertGlobMatch(p, 'testing/foo.js');
598
		assertGlobMatch(p, 'testing\\foo.js');
599
		assertGlobMatch(p, '/testing/foo.js');
600
		assertGlobMatch(p, '\\testing\\foo.js');
601
		assertGlobMatch(p, 'C:\\testing\\foo.js');
602

603
		assertNoGlobMatch(p, 'foo.ts');
604
		assertNoGlobMatch(p, 'testing/foo.ts');
605
		assertNoGlobMatch(p, 'testing\\foo.ts');
606
		assertNoGlobMatch(p, '/testing/foo.ts');
607
		assertNoGlobMatch(p, '\\testing\\foo.ts');
608
		assertNoGlobMatch(p, 'C:\\testing\\foo.ts');
609

610
		assertNoGlobMatch(p, 'foo.js.txt');
611
		assertNoGlobMatch(p, 'testing/foo.js.txt');
612
		assertNoGlobMatch(p, 'testing\\foo.js.txt');
613
		assertNoGlobMatch(p, '/testing/foo.js.txt');
614
		assertNoGlobMatch(p, '\\testing\\foo.js.txt');
615
		assertNoGlobMatch(p, 'C:\\testing\\foo.js.txt');
616

617
		assertNoGlobMatch(p, 'testing.js/foo');
618
		assertNoGlobMatch(p, 'testing.js\\foo');
619
		assertNoGlobMatch(p, '/testing.js/foo');
620
		assertNoGlobMatch(p, '\\testing.js\\foo');
621
		assertNoGlobMatch(p, 'C:\\testing.js\\foo');
622

623
		p = '**/foo.js';
624

625
		assertGlobMatch(p, 'foo.js');
626
		assertGlobMatch(p, '/foo.js');
627
		assertGlobMatch(p, '\\foo.js');
628
		assertGlobMatch(p, 'testing/foo.js');
629
		assertGlobMatch(p, 'testing\\foo.js');
630
		assertGlobMatch(p, '/testing/foo.js');
631
		assertGlobMatch(p, '\\testing\\foo.js');
632
		assertGlobMatch(p, 'C:\\testing\\foo.js');
633
	});
634

635
	test('cached properly', function () {
636
		const p = '**/*.js';
637

638
		assertGlobMatch(p, 'foo.js');
639
		assertGlobMatch(p, 'testing/foo.js');
640
		assertGlobMatch(p, 'testing\\foo.js');
641
		assertGlobMatch(p, '/testing/foo.js');
642
		assertGlobMatch(p, '\\testing\\foo.js');
643
		assertGlobMatch(p, 'C:\\testing\\foo.js');
644

645
		assertNoGlobMatch(p, 'foo.ts');
646
		assertNoGlobMatch(p, 'testing/foo.ts');
647
		assertNoGlobMatch(p, 'testing\\foo.ts');
648
		assertNoGlobMatch(p, '/testing/foo.ts');
649
		assertNoGlobMatch(p, '\\testing\\foo.ts');
650
		assertNoGlobMatch(p, 'C:\\testing\\foo.ts');
651

652
		assertNoGlobMatch(p, 'foo.js.txt');
653
		assertNoGlobMatch(p, 'testing/foo.js.txt');
654
		assertNoGlobMatch(p, 'testing\\foo.js.txt');
655
		assertNoGlobMatch(p, '/testing/foo.js.txt');
656
		assertNoGlobMatch(p, '\\testing\\foo.js.txt');
657
		assertNoGlobMatch(p, 'C:\\testing\\foo.js.txt');
658

659
		assertNoGlobMatch(p, 'testing.js/foo');
660
		assertNoGlobMatch(p, 'testing.js\\foo');
661
		assertNoGlobMatch(p, '/testing.js/foo');
662
		assertNoGlobMatch(p, '\\testing.js\\foo');
663
		assertNoGlobMatch(p, 'C:\\testing.js\\foo');
664

665
		// Run again and make sure the regex are properly reused
666

667
		assertGlobMatch(p, 'foo.js');
668
		assertGlobMatch(p, 'testing/foo.js');
669
		assertGlobMatch(p, 'testing\\foo.js');
670
		assertGlobMatch(p, '/testing/foo.js');
671
		assertGlobMatch(p, '\\testing\\foo.js');
672
		assertGlobMatch(p, 'C:\\testing\\foo.js');
673

674
		assertNoGlobMatch(p, 'foo.ts');
675
		assertNoGlobMatch(p, 'testing/foo.ts');
676
		assertNoGlobMatch(p, 'testing\\foo.ts');
677
		assertNoGlobMatch(p, '/testing/foo.ts');
678
		assertNoGlobMatch(p, '\\testing\\foo.ts');
679
		assertNoGlobMatch(p, 'C:\\testing\\foo.ts');
680

681
		assertNoGlobMatch(p, 'foo.js.txt');
682
		assertNoGlobMatch(p, 'testing/foo.js.txt');
683
		assertNoGlobMatch(p, 'testing\\foo.js.txt');
684
		assertNoGlobMatch(p, '/testing/foo.js.txt');
685
		assertNoGlobMatch(p, '\\testing\\foo.js.txt');
686
		assertNoGlobMatch(p, 'C:\\testing\\foo.js.txt');
687

688
		assertNoGlobMatch(p, 'testing.js/foo');
689
		assertNoGlobMatch(p, 'testing.js\\foo');
690
		assertNoGlobMatch(p, '/testing.js/foo');
691
		assertNoGlobMatch(p, '\\testing.js\\foo');
692
		assertNoGlobMatch(p, 'C:\\testing.js\\foo');
693
	});
694

695
	test('invalid glob', function () {
696
		const p = '**/*(.js';
697

698
		assertNoGlobMatch(p, 'foo.js');
699
	});
700

701
	test('split glob aware', function () {
702
		assert.deepStrictEqual(glob.splitGlobAware('foo,bar', ','), ['foo', 'bar']);
703
		assert.deepStrictEqual(glob.splitGlobAware('foo', ','), ['foo']);
704
		assert.deepStrictEqual(glob.splitGlobAware('{foo,bar}', ','), ['{foo,bar}']);
705
		assert.deepStrictEqual(glob.splitGlobAware('foo,bar,{foo,bar}', ','), ['foo', 'bar', '{foo,bar}']);
706
		assert.deepStrictEqual(glob.splitGlobAware('{foo,bar},foo,bar,{foo,bar}', ','), ['{foo,bar}', 'foo', 'bar', '{foo,bar}']);
707

708
		assert.deepStrictEqual(glob.splitGlobAware('[foo,bar]', ','), ['[foo,bar]']);
709
		assert.deepStrictEqual(glob.splitGlobAware('foo,bar,[foo,bar]', ','), ['foo', 'bar', '[foo,bar]']);
710
		assert.deepStrictEqual(glob.splitGlobAware('[foo,bar],foo,bar,[foo,bar]', ','), ['[foo,bar]', 'foo', 'bar', '[foo,bar]']);
711
	});
712

713
	test('expression with disabled glob', function () {
714
		const expr = { '**/*.js': false };
715

716
		assert.strictEqual(glob.match(expr, 'foo.js'), null);
717
	});
718

719
	test('expression with two non-trivia globs', function () {
720
		const expr = {
721
			'**/*.j?': true,
722
			'**/*.t?': true
723
		};
724

725
		assert.strictEqual(glob.match(expr, 'foo.js'), '**/*.j?');
726
		assert.strictEqual(glob.match(expr, 'foo.as'), null);
727
	});
728

729
	test('expression with non-trivia glob (issue 144458)', function () {
730
		const pattern = '**/p*';
731

732
		assert.strictEqual(glob.match(pattern, 'foo/barp'), false);
733
		assert.strictEqual(glob.match(pattern, 'foo/bar/ap'), false);
734
		assert.strictEqual(glob.match(pattern, 'ap'), false);
735

736
		assert.strictEqual(glob.match(pattern, 'foo/barp1'), false);
737
		assert.strictEqual(glob.match(pattern, 'foo/bar/ap1'), false);
738
		assert.strictEqual(glob.match(pattern, 'ap1'), false);
739

740
		assert.strictEqual(glob.match(pattern, '/foo/barp'), false);
741
		assert.strictEqual(glob.match(pattern, '/foo/bar/ap'), false);
742
		assert.strictEqual(glob.match(pattern, '/ap'), false);
743

744
		assert.strictEqual(glob.match(pattern, '/foo/barp1'), false);
745
		assert.strictEqual(glob.match(pattern, '/foo/bar/ap1'), false);
746
		assert.strictEqual(glob.match(pattern, '/ap1'), false);
747

748
		assert.strictEqual(glob.match(pattern, 'foo/pbar'), true);
749
		assert.strictEqual(glob.match(pattern, '/foo/pbar'), true);
750
		assert.strictEqual(glob.match(pattern, 'foo/bar/pa'), true);
751
		assert.strictEqual(glob.match(pattern, '/p'), true);
752
	});
753

754
	test('expression with empty glob', function () {
755
		const expr = { '': true };
756

757
		assert.strictEqual(glob.match(expr, 'foo.js'), null);
758
	});
759

760
	test('expression with other falsy value', function () {
761
		const expr = { '**/*.js': 0 } as any;
762

763
		assert.strictEqual(glob.match(expr, 'foo.js'), '**/*.js');
764
	});
765

766
	test('expression with two basename globs', function () {
767
		const expr = {
768
			'**/bar': true,
769
			'**/baz': true
770
		};
771

772
		assert.strictEqual(glob.match(expr, 'bar'), '**/bar');
773
		assert.strictEqual(glob.match(expr, 'foo'), null);
774
		assert.strictEqual(glob.match(expr, 'foo/bar'), '**/bar');
775
		assert.strictEqual(glob.match(expr, 'foo\\bar'), '**/bar');
776
		assert.strictEqual(glob.match(expr, 'foo/foo'), null);
777
	});
778

779
	test('expression with two basename globs and a siblings expression', function () {
780
		const expr = {
781
			'**/bar': true,
782
			'**/baz': true,
783
			'**/*.js': { when: '$(basename).ts' }
784
		};
785

786
		const siblings = ['foo.ts', 'foo.js', 'foo', 'bar'];
787
		const hasSibling = (name: string) => siblings.indexOf(name) !== -1;
788

789
		assert.strictEqual(glob.match(expr, 'bar', hasSibling), '**/bar');
790
		assert.strictEqual(glob.match(expr, 'foo', hasSibling), null);
791
		assert.strictEqual(glob.match(expr, 'foo/bar', hasSibling), '**/bar');
792
		if (isWindows) {
793
			// backslash is a valid file name character on posix
794
			assert.strictEqual(glob.match(expr, 'foo\\bar', hasSibling), '**/bar');
795
		}
796
		assert.strictEqual(glob.match(expr, 'foo/foo', hasSibling), null);
797
		assert.strictEqual(glob.match(expr, 'foo.js', hasSibling), '**/*.js');
798
		assert.strictEqual(glob.match(expr, 'bar.js', hasSibling), null);
799
	});
800

801
	test('expression with multipe basename globs', function () {
802
		const expr = {
803
			'**/bar': true,
804
			'{**/baz,**/foo}': true
805
		};
806

807
		assert.strictEqual(glob.match(expr, 'bar'), '**/bar');
808
		assert.strictEqual(glob.match(expr, 'foo'), '{**/baz,**/foo}');
809
		assert.strictEqual(glob.match(expr, 'baz'), '{**/baz,**/foo}');
810
		assert.strictEqual(glob.match(expr, 'abc'), null);
811
	});
812

813
	test('falsy expression/pattern', function () {
814
		assert.strictEqual(glob.match(null!, 'foo'), false);
815
		assert.strictEqual(glob.match('', 'foo'), false);
816
		assert.strictEqual(glob.parse(null!)('foo'), false);
817
		assert.strictEqual(glob.parse('')('foo'), false);
818
	});
819

820
	test('falsy path', function () {
821
		assert.strictEqual(glob.parse('foo')(null!), false);
822
		assert.strictEqual(glob.parse('foo')(''), false);
823
		assert.strictEqual(glob.parse('**/*.j?')(null!), false);
824
		assert.strictEqual(glob.parse('**/*.j?')(''), false);
825
		assert.strictEqual(glob.parse('**/*.foo')(null!), false);
826
		assert.strictEqual(glob.parse('**/*.foo')(''), false);
827
		assert.strictEqual(glob.parse('**/foo')(null!), false);
828
		assert.strictEqual(glob.parse('**/foo')(''), false);
829
		assert.strictEqual(glob.parse('{**/baz,**/foo}')(null!), false);
830
		assert.strictEqual(glob.parse('{**/baz,**/foo}')(''), false);
831
		assert.strictEqual(glob.parse('{**/*.baz,**/*.foo}')(null!), false);
832
		assert.strictEqual(glob.parse('{**/*.baz,**/*.foo}')(''), false);
833
	});
834

835
	test('expression/pattern basename', function () {
836
		assert.strictEqual(glob.parse('**/foo')('bar/baz', 'baz'), false);
837
		assert.strictEqual(glob.parse('**/foo')('bar/foo', 'foo'), true);
838

839
		assert.strictEqual(glob.parse('{**/baz,**/foo}')('baz/bar', 'bar'), false);
840
		assert.strictEqual(glob.parse('{**/baz,**/foo}')('baz/foo', 'foo'), true);
841

842
		const expr = { '**/*.js': { when: '$(basename).ts' } };
843
		const siblings = ['foo.ts', 'foo.js'];
844
		const hasSibling = (name: string) => siblings.indexOf(name) !== -1;
845

846
		assert.strictEqual(glob.parse(expr)('bar/baz.js', 'baz.js', hasSibling), null);
847
		assert.strictEqual(glob.parse(expr)('bar/foo.js', 'foo.js', hasSibling), '**/*.js');
848
	});
849

850
	test('expression/pattern basename terms', function () {
851
		assert.deepStrictEqual(glob.getBasenameTerms(glob.parse('**/*.foo')), []);
852
		assert.deepStrictEqual(glob.getBasenameTerms(glob.parse('**/foo')), ['foo']);
853
		assert.deepStrictEqual(glob.getBasenameTerms(glob.parse('**/foo/')), ['foo']);
854
		assert.deepStrictEqual(glob.getBasenameTerms(glob.parse('{**/baz,**/foo}')), ['baz', 'foo']);
855
		assert.deepStrictEqual(glob.getBasenameTerms(glob.parse('{**/baz/,**/foo/}')), ['baz', 'foo']);
856

857
		assert.deepStrictEqual(glob.getBasenameTerms(glob.parse({
858
			'**/foo': true,
859
			'{**/bar,**/baz}': true,
860
			'{**/bar2/,**/baz2/}': true,
861
			'**/bulb': false
862
		})), ['foo', 'bar', 'baz', 'bar2', 'baz2']);
863
		assert.deepStrictEqual(glob.getBasenameTerms(glob.parse({
864
			'**/foo': { when: '$(basename).zip' },
865
			'**/bar': true
866
		})), ['bar']);
867
	});
868

869
	test('expression/pattern optimization for basenames', function () {
870
		assert.deepStrictEqual(glob.getBasenameTerms(glob.parse('**/foo/**')), []);
871
		assert.deepStrictEqual(glob.getBasenameTerms(glob.parse('**/foo/**', { trimForExclusions: true })), ['foo']);
872

873
		testOptimizationForBasenames('**/*.foo/**', [], [['baz/bar.foo/bar/baz', true]]);
874
		testOptimizationForBasenames('**/foo/**', ['foo'], [['bar/foo', true], ['bar/foo/baz', false]]);
875
		testOptimizationForBasenames('{**/baz/**,**/foo/**}', ['baz', 'foo'], [['bar/baz', true], ['bar/foo', true]]);
876

877
		testOptimizationForBasenames({
878
			'**/foo/**': true,
879
			'{**/bar/**,**/baz/**}': true,
880
			'**/bulb/**': false
881
		}, ['foo', 'bar', 'baz'], [
882
			['bar/foo', '**/foo/**'],
883
			['foo/bar', '{**/bar/**,**/baz/**}'],
884
			['bar/nope', null!]
885
		]);
886

887
		const siblings = ['baz', 'baz.zip', 'nope'];
888
		const hasSibling = (name: string) => siblings.indexOf(name) !== -1;
889
		testOptimizationForBasenames({
890
			'**/foo/**': { when: '$(basename).zip' },
891
			'**/bar/**': true
892
		}, ['bar'], [
893
			['bar/foo', null!],
894
			['bar/foo/baz', null!],
895
			['bar/foo/nope', null!],
896
			['foo/bar', '**/bar/**'],
897
		], [
898
			null!,
899
			hasSibling,
900
			hasSibling
901
		]);
902
	});
903

904
	function testOptimizationForBasenames(pattern: string | glob.IExpression, basenameTerms: string[], matches: [string, string | boolean][], siblingsFns: ((name: string) => boolean)[] = []) {
905
		const parsed = glob.parse(<glob.IExpression>pattern, { trimForExclusions: true });
906
		assert.deepStrictEqual(glob.getBasenameTerms(parsed), basenameTerms);
907
		matches.forEach(([text, result], i) => {
908
			assert.strictEqual(parsed(text, null!, siblingsFns[i]), result);
909
		});
910
	}
911

912
	test('trailing slash', function () {
913
		// Testing existing (more or less intuitive) behavior
914
		assert.strictEqual(glob.parse('**/foo/')('bar/baz', 'baz'), false);
915
		assert.strictEqual(glob.parse('**/foo/')('bar/foo', 'foo'), true);
916
		assert.strictEqual(glob.parse('**/*.foo/')('bar/file.baz', 'file.baz'), false);
917
		assert.strictEqual(glob.parse('**/*.foo/')('bar/file.foo', 'file.foo'), true);
918
		assert.strictEqual(glob.parse('{**/foo/,**/abc/}')('bar/baz', 'baz'), false);
919
		assert.strictEqual(glob.parse('{**/foo/,**/abc/}')('bar/foo', 'foo'), true);
920
		assert.strictEqual(glob.parse('{**/foo/,**/abc/}')('bar/abc', 'abc'), true);
921
		assert.strictEqual(glob.parse('{**/foo/,**/abc/}', { trimForExclusions: true })('bar/baz', 'baz'), false);
922
		assert.strictEqual(glob.parse('{**/foo/,**/abc/}', { trimForExclusions: true })('bar/foo', 'foo'), true);
923
		assert.strictEqual(glob.parse('{**/foo/,**/abc/}', { trimForExclusions: true })('bar/abc', 'abc'), true);
924
	});
925

926
	test('expression/pattern path', function () {
927
		assert.strictEqual(glob.parse('**/foo/bar')(nativeSep('foo/baz'), 'baz'), false);
928
		assert.strictEqual(glob.parse('**/foo/bar')(nativeSep('foo/bar'), 'bar'), true);
929
		assert.strictEqual(glob.parse('**/foo/bar')(nativeSep('bar/foo/bar'), 'bar'), true);
930
		assert.strictEqual(glob.parse('**/foo/bar/**')(nativeSep('bar/foo/bar'), 'bar'), true);
931
		assert.strictEqual(glob.parse('**/foo/bar/**')(nativeSep('bar/foo/bar/baz'), 'baz'), true);
932
		assert.strictEqual(glob.parse('**/foo/bar/**', { trimForExclusions: true })(nativeSep('bar/foo/bar'), 'bar'), true);
933
		assert.strictEqual(glob.parse('**/foo/bar/**', { trimForExclusions: true })(nativeSep('bar/foo/bar/baz'), 'baz'), false);
934

935
		assert.strictEqual(glob.parse('foo/bar')(nativeSep('foo/baz'), 'baz'), false);
936
		assert.strictEqual(glob.parse('foo/bar')(nativeSep('foo/bar'), 'bar'), true);
937
		assert.strictEqual(glob.parse('foo/bar/baz')(nativeSep('foo/bar/baz'), 'baz'), true); // #15424
938
		assert.strictEqual(glob.parse('foo/bar')(nativeSep('bar/foo/bar'), 'bar'), false);
939
		assert.strictEqual(glob.parse('foo/bar/**')(nativeSep('foo/bar/baz'), 'baz'), true);
940
		assert.strictEqual(glob.parse('foo/bar/**', { trimForExclusions: true })(nativeSep('foo/bar'), 'bar'), true);
941
		assert.strictEqual(glob.parse('foo/bar/**', { trimForExclusions: true })(nativeSep('foo/bar/baz'), 'baz'), false);
942
	});
943

944
	test('expression/pattern paths', function () {
945
		assert.deepStrictEqual(glob.getPathTerms(glob.parse('**/*.foo')), []);
946
		assert.deepStrictEqual(glob.getPathTerms(glob.parse('**/foo')), []);
947
		assert.deepStrictEqual(glob.getPathTerms(glob.parse('**/foo/bar')), ['*/foo/bar']);
948
		assert.deepStrictEqual(glob.getPathTerms(glob.parse('**/foo/bar/')), ['*/foo/bar']);
949
		// Not supported
950
		// assert.deepStrictEqual(glob.getPathTerms(glob.parse('{**/baz/bar,**/foo/bar,**/bar}')), ['*/baz/bar', '*/foo/bar']);
951
		// assert.deepStrictEqual(glob.getPathTerms(glob.parse('{**/baz/bar/,**/foo/bar/,**/bar/}')), ['*/baz/bar', '*/foo/bar']);
952

953
		const parsed = glob.parse({
954
			'**/foo/bar': true,
955
			'**/foo2/bar2': true,
956
			// Not supported
957
			// '{**/bar/foo,**/baz/foo}': true,
958
			// '{**/bar2/foo/,**/baz2/foo/}': true,
959
			'**/bulb': true,
960
			'**/bulb2': true,
961
			'**/bulb/foo': false
962
		});
963
		assert.deepStrictEqual(glob.getPathTerms(parsed), ['*/foo/bar', '*/foo2/bar2']);
964
		assert.deepStrictEqual(glob.getBasenameTerms(parsed), ['bulb', 'bulb2']);
965
		assert.deepStrictEqual(glob.getPathTerms(glob.parse({
966
			'**/foo/bar': { when: '$(basename).zip' },
967
			'**/bar/foo': true,
968
			'**/bar2/foo2': true
969
		})), ['*/bar/foo', '*/bar2/foo2']);
970
	});
971

972
	test('expression/pattern optimization for paths', function () {
973
		assert.deepStrictEqual(glob.getPathTerms(glob.parse('**/foo/bar/**')), []);
974
		assert.deepStrictEqual(glob.getPathTerms(glob.parse('**/foo/bar/**', { trimForExclusions: true })), ['*/foo/bar']);
975

976
		testOptimizationForPaths('**/*.foo/bar/**', [], [[nativeSep('baz/bar.foo/bar/baz'), true]]);
977
		testOptimizationForPaths('**/foo/bar/**', ['*/foo/bar'], [[nativeSep('bar/foo/bar'), true], [nativeSep('bar/foo/bar/baz'), false]]);
978
		// Not supported
979
		// testOptimizationForPaths('{**/baz/bar/**,**/foo/bar/**}', ['*/baz/bar', '*/foo/bar'], [[nativeSep('bar/baz/bar'), true], [nativeSep('bar/foo/bar'), true]]);
980

981
		testOptimizationForPaths({
982
			'**/foo/bar/**': true,
983
			// Not supported
984
			// '{**/bar/bar/**,**/baz/bar/**}': true,
985
			'**/bulb/bar/**': false
986
		}, ['*/foo/bar'], [
987
			[nativeSep('bar/foo/bar'), '**/foo/bar/**'],
988
			// Not supported
989
			// [nativeSep('foo/bar/bar'), '{**/bar/bar/**,**/baz/bar/**}'],
990
			[nativeSep('/foo/bar/nope'), null!]
991
		]);
992

993
		const siblings = ['baz', 'baz.zip', 'nope'];
994
		const hasSibling = (name: string) => siblings.indexOf(name) !== -1;
995
		testOptimizationForPaths({
996
			'**/foo/123/**': { when: '$(basename).zip' },
997
			'**/bar/123/**': true
998
		}, ['*/bar/123'], [
999
			[nativeSep('bar/foo/123'), null!],
1000
			[nativeSep('bar/foo/123/baz'), null!],
1001
			[nativeSep('bar/foo/123/nope'), null!],
1002
			[nativeSep('foo/bar/123'), '**/bar/123/**'],
1003
		], [
1004
			null!,
1005
			hasSibling,
1006
			hasSibling
1007
		]);
1008
	});
1009

1010
	function testOptimizationForPaths(pattern: string | glob.IExpression, pathTerms: string[], matches: [string, string | boolean][], siblingsFns: ((name: string) => boolean)[] = []) {
1011
		const parsed = glob.parse(<glob.IExpression>pattern, { trimForExclusions: true });
1012
		assert.deepStrictEqual(glob.getPathTerms(parsed), pathTerms);
1013
		matches.forEach(([text, result], i) => {
1014
			assert.strictEqual(parsed(text, null!, siblingsFns[i]), result);
1015
		});
1016
	}
1017

1018
	function nativeSep(slashPath: string): string {
1019
		return slashPath.replace(/\//g, sep);
1020
	}
1021

1022
	test('relative pattern - glob star', function () {
1023
		if (isWindows) {
1024
			const p: glob.IRelativePattern = { base: 'C:\\DNXConsoleApp\\foo', pattern: '**/*.cs' };
1025
			assertGlobMatch(p, 'C:\\DNXConsoleApp\\foo\\Program.cs');
1026
			assertGlobMatch(p, 'C:\\DNXConsoleApp\\foo\\bar\\Program.cs');
1027
			assertNoGlobMatch(p, 'C:\\DNXConsoleApp\\foo\\Program.ts');
1028
			assertNoGlobMatch(p, 'C:\\DNXConsoleApp\\Program.cs');
1029
			assertNoGlobMatch(p, 'C:\\other\\DNXConsoleApp\\foo\\Program.ts');
1030
		} else {
1031
			const p: glob.IRelativePattern = { base: '/DNXConsoleApp/foo', pattern: '**/*.cs' };
1032
			assertGlobMatch(p, '/DNXConsoleApp/foo/Program.cs');
1033
			assertGlobMatch(p, '/DNXConsoleApp/foo/bar/Program.cs');
1034
			assertNoGlobMatch(p, '/DNXConsoleApp/foo/Program.ts');
1035
			assertNoGlobMatch(p, '/DNXConsoleApp/Program.cs');
1036
			assertNoGlobMatch(p, '/other/DNXConsoleApp/foo/Program.ts');
1037
		}
1038
	});
1039

1040
	test('relative pattern - single star', function () {
1041
		if (isWindows) {
1042
			const p: glob.IRelativePattern = { base: 'C:\\DNXConsoleApp\\foo', pattern: '*.cs' };
1043
			assertGlobMatch(p, 'C:\\DNXConsoleApp\\foo\\Program.cs');
1044
			assertNoGlobMatch(p, 'C:\\DNXConsoleApp\\foo\\bar\\Program.cs');
1045
			assertNoGlobMatch(p, 'C:\\DNXConsoleApp\\foo\\Program.ts');
1046
			assertNoGlobMatch(p, 'C:\\DNXConsoleApp\\Program.cs');
1047
			assertNoGlobMatch(p, 'C:\\other\\DNXConsoleApp\\foo\\Program.ts');
1048
		} else {
1049
			const p: glob.IRelativePattern = { base: '/DNXConsoleApp/foo', pattern: '*.cs' };
1050
			assertGlobMatch(p, '/DNXConsoleApp/foo/Program.cs');
1051
			assertNoGlobMatch(p, '/DNXConsoleApp/foo/bar/Program.cs');
1052
			assertNoGlobMatch(p, '/DNXConsoleApp/foo/Program.ts');
1053
			assertNoGlobMatch(p, '/DNXConsoleApp/Program.cs');
1054
			assertNoGlobMatch(p, '/other/DNXConsoleApp/foo/Program.ts');
1055
		}
1056
	});
1057

1058
	test('relative pattern - single star with path', function () {
1059
		if (isWindows) {
1060
			const p: glob.IRelativePattern = { base: 'C:\\DNXConsoleApp\\foo', pattern: 'something/*.cs' };
1061
			assertGlobMatch(p, 'C:\\DNXConsoleApp\\foo\\something\\Program.cs');
1062
			assertNoGlobMatch(p, 'C:\\DNXConsoleApp\\foo\\Program.cs');
1063
		} else {
1064
			const p: glob.IRelativePattern = { base: '/DNXConsoleApp/foo', pattern: 'something/*.cs' };
1065
			assertGlobMatch(p, '/DNXConsoleApp/foo/something/Program.cs');
1066
			assertNoGlobMatch(p, '/DNXConsoleApp/foo/Program.cs');
1067
		}
1068
	});
1069

1070
	test('relative pattern - single star alone', function () {
1071
		if (isWindows) {
1072
			const p: glob.IRelativePattern = { base: 'C:\\DNXConsoleApp\\foo\\something\\Program.cs', pattern: '*' };
1073
			assertGlobMatch(p, 'C:\\DNXConsoleApp\\foo\\something\\Program.cs');
1074
			assertNoGlobMatch(p, 'C:\\DNXConsoleApp\\foo\\Program.cs');
1075
		} else {
1076
			const p: glob.IRelativePattern = { base: '/DNXConsoleApp/foo/something/Program.cs', pattern: '*' };
1077
			assertGlobMatch(p, '/DNXConsoleApp/foo/something/Program.cs');
1078
			assertNoGlobMatch(p, '/DNXConsoleApp/foo/Program.cs');
1079
		}
1080
	});
1081

1082
	test('relative pattern - ignores case on macOS/Windows', function () {
1083
		if (isWindows) {
1084
			const p: glob.IRelativePattern = { base: 'C:\\DNXConsoleApp\\foo', pattern: 'something/*.cs' };
1085
			assertGlobMatch(p, 'C:\\DNXConsoleApp\\foo\\something\\Program.cs'.toLowerCase());
1086
		} else if (isMacintosh) {
1087
			const p: glob.IRelativePattern = { base: '/DNXConsoleApp/foo', pattern: 'something/*.cs' };
1088
			assertGlobMatch(p, '/DNXConsoleApp/foo/something/Program.cs'.toLowerCase());
1089
		} else if (isLinux) {
1090
			const p: glob.IRelativePattern = { base: '/DNXConsoleApp/foo', pattern: 'something/*.cs' };
1091
			assertNoGlobMatch(p, '/DNXConsoleApp/foo/something/Program.cs'.toLowerCase());
1092
		}
1093
	});
1094

1095
	test('relative pattern - trailing slash / backslash (#162498)', function () {
1096
		if (isWindows) {
1097
			let p: glob.IRelativePattern = { base: 'C:\\', pattern: 'foo.cs' };
1098
			assertGlobMatch(p, 'C:\\foo.cs');
1099

1100
			p = { base: 'C:\\bar\\', pattern: 'foo.cs' };
1101
			assertGlobMatch(p, 'C:\\bar\\foo.cs');
1102
		} else {
1103
			let p: glob.IRelativePattern = { base: '/', pattern: 'foo.cs' };
1104
			assertGlobMatch(p, '/foo.cs');
1105

1106
			p = { base: '/bar/', pattern: 'foo.cs' };
1107
			assertGlobMatch(p, '/bar/foo.cs');
1108
		}
1109
	});
1110

1111
	test('pattern with "base" does not explode - #36081', function () {
1112
		assert.ok(glob.match({ 'base': true }, 'base'));
1113
	});
1114

1115
	test('relative pattern - #57475', function () {
1116
		if (isWindows) {
1117
			const p: glob.IRelativePattern = { base: 'C:\\DNXConsoleApp\\foo', pattern: 'styles/style.css' };
1118
			assertGlobMatch(p, 'C:\\DNXConsoleApp\\foo\\styles\\style.css');
1119
			assertNoGlobMatch(p, 'C:\\DNXConsoleApp\\foo\\Program.cs');
1120
		} else {
1121
			const p: glob.IRelativePattern = { base: '/DNXConsoleApp/foo', pattern: 'styles/style.css' };
1122
			assertGlobMatch(p, '/DNXConsoleApp/foo/styles/style.css');
1123
			assertNoGlobMatch(p, '/DNXConsoleApp/foo/Program.cs');
1124
		}
1125
	});
1126

1127
	test('URI match', () => {
1128
		const p = 'scheme:/**/*.md';
1129
		assertGlobMatch(p, URI.file('super/duper/long/some/file.md').with({ scheme: 'scheme' }).toString());
1130
	});
1131

1132
	test('expression fails when siblings use promises (https://github.com/microsoft/vscode/issues/146294)', async function () {
1133
		const siblings = ['test.html', 'test.txt', 'test.ts'];
1134
		const hasSibling = (name: string) => Promise.resolve(siblings.indexOf(name) !== -1);
1135

1136
		// { "**/*.js": { "when": "$(basename).ts" } }
1137
		const expression: glob.IExpression = {
1138
			'**/test.js': { when: '$(basename).js' },
1139
			'**/*.js': { when: '$(basename).ts' }
1140
		};
1141

1142
		const parsedExpression = glob.parse(expression);
1143

1144
		assert.strictEqual('**/*.js', await parsedExpression('test.js', undefined, hasSibling));
1145
	});
1146

1147
	test('patternsEquals', () => {
1148
		assert.ok(glob.patternsEquals(['a'], ['a']));
1149
		assert.ok(!glob.patternsEquals(['a'], ['b']));
1150

1151
		assert.ok(glob.patternsEquals(['a', 'b', 'c'], ['a', 'b', 'c']));
1152
		assert.ok(!glob.patternsEquals(['1', '2'], ['1', '3']));
1153

1154
		assert.ok(glob.patternsEquals([{ base: 'a', pattern: '*' }, 'b', 'c'], [{ base: 'a', pattern: '*' }, 'b', 'c']));
1155

1156
		assert.ok(glob.patternsEquals(undefined, undefined));
1157
		assert.ok(!glob.patternsEquals(undefined, ['b']));
1158
		assert.ok(!glob.patternsEquals(['a'], undefined));
1159
	});
1160

1161
	test('isEmptyPattern', () => {
1162
		assert.ok(glob.isEmptyPattern(glob.parse('')));
1163
		assert.ok(glob.isEmptyPattern(glob.parse(undefined!)));
1164
		assert.ok(glob.isEmptyPattern(glob.parse(null!)));
1165

1166
		assert.ok(glob.isEmptyPattern(glob.parse({})));
1167
		assert.ok(glob.isEmptyPattern(glob.parse({ '': true })));
1168
		assert.ok(glob.isEmptyPattern(glob.parse({ '**/*.js': false })));
1169
	});
1170

1171
	ensureNoDisposablesAreLeakedInTestSuite();
1172
});
1173

1174
Product

Resources

Company
