Merge from vscode cfc1ab4c5f816765b91fb7ead3c3427a7c8581a3

src/vs/base/test/browser/markdownRenderer.test.ts

@@ -6,7 +6,9 @@
 import * as assert from 'assert';
 import * as marked from 'vs/base/common/marked/marked';
 import { renderMarkdown } from 'vs/base/browser/markdownRenderer';
-import { MarkdownString } from 'vs/base/common/htmlContent';
+import { MarkdownString, IMarkdownString } from 'vs/base/common/htmlContent';
+import { URI } from 'vs/base/common/uri';
+import { parse } from 'vs/base/common/marshalling';
 
 suite('MarkdownRenderer', () => {
 	suite('Images', () => {
@@ -98,4 +100,21 @@ suite('MarkdownRenderer', () => {
 
 	});
 
+	test('npm Hover Run Script not working #90855', function () {
+
+		const md: IMarkdownString = JSON.parse('{"value":"[Run Script](command:npm.runScriptFromHover?%7B%22documentUri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22c%3A%5C%5CUsers%5C%5Cjrieken%5C%5CCode%5C%5C_sample%5C%5Cfoo%5C%5Cpackage.json%22%2C%22_sep%22%3A1%2C%22external%22%3A%22file%3A%2F%2F%2Fc%253A%2FUsers%2Fjrieken%2FCode%2F_sample%2Ffoo%2Fpackage.json%22%2C%22path%22%3A%22%2Fc%3A%2FUsers%2Fjrieken%2FCode%2F_sample%2Ffoo%2Fpackage.json%22%2C%22scheme%22%3A%22file%22%7D%2C%22script%22%3A%22echo%22%7D \\"Run the script as a task\\")","supportThemeIcons":false,"isTrusted":true,"uris":{"__uri_e49443":{"$mid":1,"fsPath":"c:\\\\Users\\\\jrieken\\\\Code\\\\_sample\\\\foo\\\\package.json","_sep":1,"external":"file:///c%3A/Users/jrieken/Code/_sample/foo/package.json","path":"/c:/Users/jrieken/Code/_sample/foo/package.json","scheme":"file"},"command:npm.runScriptFromHover?%7B%22documentUri%22%3A%7B%22%24mid%22%3A1%2C%22fsPath%22%3A%22c%3A%5C%5CUsers%5C%5Cjrieken%5C%5CCode%5C%5C_sample%5C%5Cfoo%5C%5Cpackage.json%22%2C%22_sep%22%3A1%2C%22external%22%3A%22file%3A%2F%2F%2Fc%253A%2FUsers%2Fjrieken%2FCode%2F_sample%2Ffoo%2Fpackage.json%22%2C%22path%22%3A%22%2Fc%3A%2FUsers%2Fjrieken%2FCode%2F_sample%2Ffoo%2Fpackage.json%22%2C%22scheme%22%3A%22file%22%7D%2C%22script%22%3A%22echo%22%7D":{"$mid":1,"path":"npm.runScriptFromHover","scheme":"command","query":"{\\"documentUri\\":\\"__uri_e49443\\",\\"script\\":\\"echo\\"}"}}}');
+		const element = renderMarkdown(md);
+
+		const anchor = element.querySelector('a')!;
+		assert.ok(anchor);
+		assert.ok(anchor.dataset['href']);
+
+		const uri = URI.parse(anchor.dataset['href']!);
+
+		const data = <{ script: string, documentUri: URI }>parse(decodeURIComponent(uri.query));
+		assert.ok(data);
+		assert.equal(data.script, 'echo');
+		assert.ok(data.documentUri.toString().startsWith('file:///c%3A/'));
+	});
+
 });

src/vs/base/test/common/extpath.test.ts

@@ -6,6 +6,7 @@
 import * as assert from 'assert';
 import * as extpath from 'vs/base/common/extpath';
 import * as platform from 'vs/base/common/platform';
+import { CharCode } from 'vs/base/common/charCode';
 
 suite('Paths', () => {
 
@@ -114,4 +115,19 @@ suite('Paths', () => {
 			assert.ok(!extpath.isRootOrDriveLetter('/path'));
 		}
 	});
+
+	test('isWindowsDriveLetter', () => {
+		assert.ok(!extpath.isWindowsDriveLetter(0));
+		assert.ok(!extpath.isWindowsDriveLetter(-1));
+		assert.ok(extpath.isWindowsDriveLetter(CharCode.A));
+		assert.ok(extpath.isWindowsDriveLetter(CharCode.z));
+	});
+
+	test('indexOfPath', () => {
+		assert.equal(extpath.indexOfPath('/foo', '/bar', true), -1);
+		assert.equal(extpath.indexOfPath('/foo', '/FOO', false), -1);
+		assert.equal(extpath.indexOfPath('/foo', '/FOO', true), 0);
+		assert.equal(extpath.indexOfPath('/some/long/path', '/some/long', false), 0);
+		assert.equal(extpath.indexOfPath('/some/long/path', '/PATH', true), 10);
+	});
 });

src/vs/base/test/common/fuzzyScorer.test.ts

@@ -0,0 +1,836 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import * as scorer from 'vs/base/common/fuzzyScorer';
+import { URI } from 'vs/base/common/uri';
+import { basename, dirname, sep } from 'vs/base/common/path';
+import { isWindows } from 'vs/base/common/platform';
+
+class ResourceAccessorClass implements scorer.IItemAccessor<URI> {
+
+	getItemLabel(resource: URI): string {
+		return basename(resource.fsPath);
+	}
+
+	getItemDescription(resource: URI): string {
+		return dirname(resource.fsPath);
+	}
+
+	getItemPath(resource: URI): string {
+		return resource.fsPath;
+	}
+}
+
+const ResourceAccessor = new ResourceAccessorClass();
+
+class NullAccessorClass implements scorer.IItemAccessor<URI> {
+
+	getItemLabel(resource: URI): string {
+		return undefined!;
+	}
+
+	getItemDescription(resource: URI): string {
+		return undefined!;
+	}
+
+	getItemPath(resource: URI): string {
+		return undefined!;
+	}
+}
+
+function _doScore(target: string, query: string, fuzzy: boolean): scorer.Score {
+	return scorer.score(target, query, query.toLowerCase(), fuzzy);
+}
+
+function scoreItem<T>(item: T, query: string, fuzzy: boolean, accessor: scorer.IItemAccessor<T>, cache: scorer.ScorerCache): scorer.IItemScore {
+	return scorer.scoreItem(item, scorer.prepareQuery(query), fuzzy, accessor, cache);
+}
+
+function compareItemsByScore<T>(itemA: T, itemB: T, query: string, fuzzy: boolean, accessor: scorer.IItemAccessor<T>, cache: scorer.ScorerCache, fallbackComparer?: (itemA: T, itemB: T, query: scorer.IPreparedQuery, accessor: scorer.IItemAccessor<T>) => number): number {
+	return scorer.compareItemsByScore(itemA, itemB, scorer.prepareQuery(query), fuzzy, accessor, cache, fallbackComparer as any);
+}
+
+const NullAccessor = new NullAccessorClass();
+let cache: scorer.ScorerCache = Object.create(null);
+
+suite('Fuzzy Scorer', () => {
+
+	setup(() => {
+		cache = Object.create(null);
+	});
+
+	test('score (fuzzy)', function () {
+		const target = 'HeLlo-World';
+
+		const scores: scorer.Score[] = [];
+		scores.push(_doScore(target, 'HelLo-World', true)); // direct case match
+		scores.push(_doScore(target, 'hello-world', true)); // direct mix-case match
+		scores.push(_doScore(target, 'HW', true)); // direct case prefix (multiple)
+		scores.push(_doScore(target, 'hw', true)); // direct mix-case prefix (multiple)
+		scores.push(_doScore(target, 'H', true)); // direct case prefix
+		scores.push(_doScore(target, 'h', true)); // direct mix-case prefix
+		scores.push(_doScore(target, 'ld', true)); // in-string mix-case match (consecutive, avoids scattered hit)
+		scores.push(_doScore(target, 'W', true)); // direct case word prefix
+		scores.push(_doScore(target, 'w', true)); // direct mix-case word prefix
+		scores.push(_doScore(target, 'Ld', true)); // in-string case match (multiple)
+		scores.push(_doScore(target, 'L', true)); // in-string case match
+		scores.push(_doScore(target, 'l', true)); // in-string mix-case match
+		scores.push(_doScore(target, '4', true)); // no match
+
+		// Assert scoring order
+		let sortedScores = scores.concat().sort((a, b) => b[0] - a[0]);
+		assert.deepEqual(scores, sortedScores);
+
+		// Assert scoring positions
+		let positions = scores[0][1];
+		assert.equal(positions.length, 'HelLo-World'.length);
+
+		positions = scores[2][1];
+		assert.equal(positions.length, 'HW'.length);
+		assert.equal(positions[0], 0);
+		assert.equal(positions[1], 6);
+	});
+
+	test('score (non fuzzy)', function () {
+		const target = 'HeLlo-World';
+
+		assert.ok(_doScore(target, 'HelLo-World', false)[0] > 0);
+		assert.equal(_doScore(target, 'HelLo-World', false)[1].length, 'HelLo-World'.length);
+
+		assert.ok(_doScore(target, 'hello-world', false)[0] > 0);
+		assert.equal(_doScore(target, 'HW', false)[0], 0);
+		assert.ok(_doScore(target, 'h', false)[0] > 0);
+		assert.ok(_doScore(target, 'ello', false)[0] > 0);
+		assert.ok(_doScore(target, 'ld', false)[0] > 0);
+		assert.equal(_doScore(target, 'eo', false)[0], 0);
+	});
+
+	test('scoreItem - matches are proper', function () {
+		let res = scoreItem(null, 'something', true, ResourceAccessor, cache);
+		assert.ok(!res.score);
+
+		const resource = URI.file('/xyz/some/path/someFile123.txt');
+
+		res = scoreItem(resource, 'something', true, NullAccessor, cache);
+		assert.ok(!res.score);
+
+		// Path Identity
+		const identityRes = scoreItem(resource, ResourceAccessor.getItemPath(resource), true, ResourceAccessor, cache);
+		assert.ok(identityRes.score);
+		assert.equal(identityRes.descriptionMatch!.length, 1);
+		assert.equal(identityRes.labelMatch!.length, 1);
+		assert.equal(identityRes.descriptionMatch![0].start, 0);
+		assert.equal(identityRes.descriptionMatch![0].end, ResourceAccessor.getItemDescription(resource).length);
+		assert.equal(identityRes.labelMatch![0].start, 0);
+		assert.equal(identityRes.labelMatch![0].end, ResourceAccessor.getItemLabel(resource).length);
+
+		// Basename Prefix
+		const basenamePrefixRes = scoreItem(resource, 'som', true, ResourceAccessor, cache);
+		assert.ok(basenamePrefixRes.score);
+		assert.ok(!basenamePrefixRes.descriptionMatch);
+		assert.equal(basenamePrefixRes.labelMatch!.length, 1);
+		assert.equal(basenamePrefixRes.labelMatch![0].start, 0);
+		assert.equal(basenamePrefixRes.labelMatch![0].end, 'som'.length);
+
+		// Basename Camelcase
+		const basenameCamelcaseRes = scoreItem(resource, 'sF', true, ResourceAccessor, cache);
+		assert.ok(basenameCamelcaseRes.score);
+		assert.ok(!basenameCamelcaseRes.descriptionMatch);
+		assert.equal(basenameCamelcaseRes.labelMatch!.length, 2);
+		assert.equal(basenameCamelcaseRes.labelMatch![0].start, 0);
+		assert.equal(basenameCamelcaseRes.labelMatch![0].end, 1);
+		assert.equal(basenameCamelcaseRes.labelMatch![1].start, 4);
+		assert.equal(basenameCamelcaseRes.labelMatch![1].end, 5);
+
+		// Basename Match
+		const basenameRes = scoreItem(resource, 'of', true, ResourceAccessor, cache);
+		assert.ok(basenameRes.score);
+		assert.ok(!basenameRes.descriptionMatch);
+		assert.equal(basenameRes.labelMatch!.length, 2);
+		assert.equal(basenameRes.labelMatch![0].start, 1);
+		assert.equal(basenameRes.labelMatch![0].end, 2);
+		assert.equal(basenameRes.labelMatch![1].start, 4);
+		assert.equal(basenameRes.labelMatch![1].end, 5);
+
+		// Path Match
+		const pathRes = scoreItem(resource, 'xyz123', true, ResourceAccessor, cache);
+		assert.ok(pathRes.score);
+		assert.ok(pathRes.descriptionMatch);
+		assert.ok(pathRes.labelMatch);
+		assert.equal(pathRes.labelMatch!.length, 1);
+		assert.equal(pathRes.labelMatch![0].start, 8);
+		assert.equal(pathRes.labelMatch![0].end, 11);
+		assert.equal(pathRes.descriptionMatch!.length, 1);
+		assert.equal(pathRes.descriptionMatch![0].start, 1);
+		assert.equal(pathRes.descriptionMatch![0].end, 4);
+
+		// No Match
+		const noRes = scoreItem(resource, '987', true, ResourceAccessor, cache);
+		assert.ok(!noRes.score);
+		assert.ok(!noRes.labelMatch);
+		assert.ok(!noRes.descriptionMatch);
+
+		// Verify Scores
+		assert.ok(identityRes.score > basenamePrefixRes.score);
+		assert.ok(basenamePrefixRes.score > basenameRes.score);
+		assert.ok(basenameRes.score > pathRes.score);
+		assert.ok(pathRes.score > noRes.score);
+	});
+
+	test('scoreItem - invalid input', function () {
+
+		let res = scoreItem(null, null!, true, ResourceAccessor, cache);
+		assert.equal(res.score, 0);
+
+		res = scoreItem(null, 'null', true, ResourceAccessor, cache);
+		assert.equal(res.score, 0);
+	});
+
+	test('scoreItem - optimize for file paths', function () {
+		const resource = URI.file('/xyz/others/spath/some/xsp/file123.txt');
+
+		// xsp is more relevant to the end of the file path even though it matches
+		// fuzzy also in the beginning. we verify the more relevant match at the
+		// end gets returned.
+		const pathRes = scoreItem(resource, 'xspfile123', true, ResourceAccessor, cache);
+		assert.ok(pathRes.score);
+		assert.ok(pathRes.descriptionMatch);
+		assert.ok(pathRes.labelMatch);
+		assert.equal(pathRes.labelMatch!.length, 1);
+		assert.equal(pathRes.labelMatch![0].start, 0);
+		assert.equal(pathRes.labelMatch![0].end, 7);
+		assert.equal(pathRes.descriptionMatch!.length, 1);
+		assert.equal(pathRes.descriptionMatch![0].start, 23);
+		assert.equal(pathRes.descriptionMatch![0].end, 26);
+	});
+
+	test('scoreItem - avoid match scattering (bug #36119)', function () {
+		const resource = URI.file('projects/ui/cula/ats/target.mk');
+
+		const pathRes = scoreItem(resource, 'tcltarget.mk', true, ResourceAccessor, cache);
+		assert.ok(pathRes.score);
+		assert.ok(pathRes.descriptionMatch);
+		assert.ok(pathRes.labelMatch);
+		assert.equal(pathRes.labelMatch!.length, 1);
+		assert.equal(pathRes.labelMatch![0].start, 0);
+		assert.equal(pathRes.labelMatch![0].end, 9);
+	});
+
+	test('scoreItem - prefers more compact matches', function () {
+		const resource = URI.file('/1a111d1/11a1d1/something.txt');
+
+		// expect "ad" to be matched towards the end of the file because the
+		// match is more compact
+		const res = scoreItem(resource, 'ad', true, ResourceAccessor, cache);
+		assert.ok(res.score);
+		assert.ok(res.descriptionMatch);
+		assert.ok(!res.labelMatch!.length);
+		assert.equal(res.descriptionMatch!.length, 2);
+		assert.equal(res.descriptionMatch![0].start, 11);
+		assert.equal(res.descriptionMatch![0].end, 12);
+		assert.equal(res.descriptionMatch![1].start, 13);
+		assert.equal(res.descriptionMatch![1].end, 14);
+	});
+
+	test('scoreItem - proper target offset', function () {
+		const resource = URI.file('etem');
+
+		const res = scoreItem(resource, 'teem', true, ResourceAccessor, cache);
+		assert.ok(!res.score);
+	});
+
+	test('scoreItem - proper target offset #2', function () {
+		const resource = URI.file('ede');
+
+		const res = scoreItem(resource, 'de', true, ResourceAccessor, cache);
+
+		assert.equal(res.labelMatch!.length, 1);
+		assert.equal(res.labelMatch![0].start, 1);
+		assert.equal(res.labelMatch![0].end, 3);
+	});
+
+	test('scoreItem - proper target offset #3', function () {
+		const resource = URI.file('/src/vs/editor/browser/viewParts/lineNumbers/flipped-cursor-2x.svg');
+
+		const res = scoreItem(resource, 'debug', true, ResourceAccessor, cache);
+
+		assert.equal(res.descriptionMatch!.length, 3);
+		assert.equal(res.descriptionMatch![0].start, 9);
+		assert.equal(res.descriptionMatch![0].end, 10);
+		assert.equal(res.descriptionMatch![1].start, 36);
+		assert.equal(res.descriptionMatch![1].end, 37);
+		assert.equal(res.descriptionMatch![2].start, 40);
+		assert.equal(res.descriptionMatch![2].end, 41);
+
+		assert.equal(res.labelMatch!.length, 2);
+		assert.equal(res.labelMatch![0].start, 9);
+		assert.equal(res.labelMatch![0].end, 10);
+		assert.equal(res.labelMatch![1].start, 20);
+		assert.equal(res.labelMatch![1].end, 21);
+	});
+
+	test('scoreItem - no match unless query contained in sequence', function () {
+		const resource = URI.file('abcde');
+
+		const res = scoreItem(resource, 'edcda', true, ResourceAccessor, cache);
+		assert.ok(!res.score);
+	});
+
+	test('compareItemsByScore - identity', function () {
+		const resourceA = URI.file('/some/path/fileA.txt');
+		const resourceB = URI.file('/some/path/other/fileB.txt');
+		const resourceC = URI.file('/unrelated/some/path/other/fileC.txt');
+
+		// Full resource A path
+		let query = ResourceAccessor.getItemPath(resourceA);
+
+		let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceB);
+		assert.equal(res[2], resourceC);
+
+		res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceB);
+		assert.equal(res[2], resourceC);
+
+		// Full resource B path
+		query = ResourceAccessor.getItemPath(resourceB);
+
+		res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+		assert.equal(res[2], resourceC);
+
+		res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+		assert.equal(res[2], resourceC);
+	});
+
+	test('compareFilesByScore - basename prefix', function () {
+		const resourceA = URI.file('/some/path/fileA.txt');
+		const resourceB = URI.file('/some/path/other/fileB.txt');
+		const resourceC = URI.file('/unrelated/some/path/other/fileC.txt');
+
+		// Full resource A basename
+		let query = ResourceAccessor.getItemLabel(resourceA);
+
+		let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceB);
+		assert.equal(res[2], resourceC);
+
+		res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceB);
+		assert.equal(res[2], resourceC);
+
+		// Full resource B basename
+		query = ResourceAccessor.getItemLabel(resourceB);
+
+		res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+		assert.equal(res[2], resourceC);
+
+		res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+		assert.equal(res[2], resourceC);
+	});
+
+	test('compareFilesByScore - basename camelcase', function () {
+		const resourceA = URI.file('/some/path/fileA.txt');
+		const resourceB = URI.file('/some/path/other/fileB.txt');
+		const resourceC = URI.file('/unrelated/some/path/other/fileC.txt');
+
+		// resource A camelcase
+		let query = 'fA';
+
+		let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceB);
+		assert.equal(res[2], resourceC);
+
+		res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceB);
+		assert.equal(res[2], resourceC);
+
+		// resource B camelcase
+		query = 'fB';
+
+		res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+		assert.equal(res[2], resourceC);
+
+		res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+		assert.equal(res[2], resourceC);
+	});
+
+	test('compareFilesByScore - basename scores', function () {
+		const resourceA = URI.file('/some/path/fileA.txt');
+		const resourceB = URI.file('/some/path/other/fileB.txt');
+		const resourceC = URI.file('/unrelated/some/path/other/fileC.txt');
+
+		// Resource A part of basename
+		let query = 'fileA';
+
+		let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceB);
+		assert.equal(res[2], resourceC);
+
+		res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceB);
+		assert.equal(res[2], resourceC);
+
+		// Resource B part of basename
+		query = 'fileB';
+
+		res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+		assert.equal(res[2], resourceC);
+
+		res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+		assert.equal(res[2], resourceC);
+	});
+
+	test('compareFilesByScore - path scores', function () {
+		const resourceA = URI.file('/some/path/fileA.txt');
+		const resourceB = URI.file('/some/path/other/fileB.txt');
+		const resourceC = URI.file('/unrelated/some/path/other/fileC.txt');
+
+		// Resource A part of path
+		let query = 'pathfileA';
+
+		let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceB);
+		assert.equal(res[2], resourceC);
+
+		res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceB);
+		assert.equal(res[2], resourceC);
+
+		// Resource B part of path
+		query = 'pathfileB';
+
+		res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+		assert.equal(res[2], resourceC);
+
+		res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+		assert.equal(res[2], resourceC);
+	});
+
+	test('compareFilesByScore - prefer shorter basenames', function () {
+		const resourceA = URI.file('/some/path/fileA.txt');
+		const resourceB = URI.file('/some/path/other/fileBLonger.txt');
+		const resourceC = URI.file('/unrelated/the/path/other/fileC.txt');
+
+		// Resource A part of path
+		let query = 'somepath';
+
+		let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceB);
+		assert.equal(res[2], resourceC);
+
+		res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceB);
+		assert.equal(res[2], resourceC);
+	});
+
+	test('compareFilesByScore - prefer shorter basenames (match on basename)', function () {
+		const resourceA = URI.file('/some/path/fileA.txt');
+		const resourceB = URI.file('/some/path/other/fileBLonger.txt');
+		const resourceC = URI.file('/unrelated/the/path/other/fileC.txt');
+
+		// Resource A part of path
+		let query = 'file';
+
+		let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceC);
+		assert.equal(res[2], resourceB);
+
+		res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceC);
+		assert.equal(res[2], resourceB);
+	});
+
+	test('compareFilesByScore - prefer shorter paths', function () {
+		const resourceA = URI.file('/some/path/fileA.txt');
+		const resourceB = URI.file('/some/path/other/fileB.txt');
+		const resourceC = URI.file('/unrelated/some/path/other/fileC.txt');
+
+		// Resource A part of path
+		let query = 'somepath';
+
+		let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceB);
+		assert.equal(res[2], resourceC);
+
+		res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceB);
+		assert.equal(res[2], resourceC);
+	});
+
+	test('compareFilesByScore - prefer shorter paths (bug #17443)', function () {
+		const resourceA = URI.file('config/test/t1.js');
+		const resourceB = URI.file('config/test.js');
+		const resourceC = URI.file('config/test/t2.js');
+
+		let query = 'co/te';
+
+		let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+		assert.equal(res[2], resourceC);
+	});
+
+	test('compareFilesByScore - allow to provide fallback sorter (bug #31591)', function () {
+		const resourceA = URI.file('virtual/vscode.d.ts');
+		const resourceB = URI.file('vscode/src/vs/vscode.d.ts');
+
+		let query = 'vscode';
+
+		let res = [resourceA, resourceB].sort((r1, r2) => {
+			return compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache, (r1, r2, query, ResourceAccessor) => {
+				if (r1 as any /* TS fail */ === resourceA) {
+					return -1;
+				}
+
+				return 1;
+			});
+		});
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceB);
+
+		res = [resourceB, resourceA].sort((r1, r2) => {
+			return compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache, (r1, r2, query, ResourceAccessor) => {
+				if (r1 as any /* TS fail */ === resourceB) {
+					return -1;
+				}
+
+				return 1;
+			});
+		});
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+	});
+
+	test('compareFilesByScore - prefer more compact camel case matches', function () {
+		const resourceA = URI.file('config/test/openthisAnythingHandler.js');
+		const resourceB = URI.file('config/test/openthisisnotsorelevantforthequeryAnyHand.js');
+
+		let query = 'AH';
+
+		let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+
+		res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+	});
+
+	test('compareFilesByScore - prefer more compact matches (label)', function () {
+		const resourceA = URI.file('config/test/examasdaple.js');
+		const resourceB = URI.file('config/test/exampleasdaasd.ts');
+
+		let query = 'xp';
+
+		let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+
+		res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+	});
+
+	test('compareFilesByScore - prefer more compact matches (path)', function () {
+		const resourceA = URI.file('config/test/examasdaple/file.js');
+		const resourceB = URI.file('config/test/exampleasdaasd/file.ts');
+
+		let query = 'xp';
+
+		let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+
+		res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+	});
+
+	test('compareFilesByScore - prefer more compact matches (label and path)', function () {
+		const resourceA = URI.file('config/example/thisfile.ts');
+		const resourceB = URI.file('config/24234243244/example/file.js');
+
+		let query = 'exfile';
+
+		let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+
+		res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+		assert.equal(res[1], resourceA);
+	});
+
+	test('compareFilesByScore - avoid match scattering (bug #34210)', function () {
+		const resourceA = URI.file('node_modules1/bundle/lib/model/modules/ot1/index.js');
+		const resourceB = URI.file('node_modules1/bundle/lib/model/modules/un1/index.js');
+		const resourceC = URI.file('node_modules1/bundle/lib/model/modules/modu1/index.js');
+		const resourceD = URI.file('node_modules1/bundle/lib/model/modules/oddl1/index.js');
+
+		let query = isWindows ? 'modu1\\index.js' : 'modu1/index.js';
+
+		let res = [resourceA, resourceB, resourceC, resourceD].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceC);
+
+		res = [resourceC, resourceB, resourceA, resourceD].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceC);
+
+		query = isWindows ? 'un1\\index.js' : 'un1/index.js';
+
+		res = [resourceA, resourceB, resourceC, resourceD].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+
+		res = [resourceC, resourceB, resourceA, resourceD].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+	});
+
+	test('compareFilesByScore - avoid match scattering (bug #21019 1.)', function () {
+		const resourceA = URI.file('app/containers/Services/NetworkData/ServiceDetails/ServiceLoad/index.js');
+		const resourceB = URI.file('app/containers/Services/NetworkData/ServiceDetails/ServiceDistribution/index.js');
+		const resourceC = URI.file('app/containers/Services/NetworkData/ServiceDetailTabs/ServiceTabs/StatVideo/index.js');
+
+		let query = 'StatVideoindex';
+
+		let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceC);
+
+		res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceC);
+	});
+
+	test('compareFilesByScore - avoid match scattering (bug #21019 2.)', function () {
+		const resourceA = URI.file('src/build-helper/store/redux.ts');
+		const resourceB = URI.file('src/repository/store/redux.ts');
+
+		let query = 'reproreduxts';
+
+		let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+
+		res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+	});
+
+	test('compareFilesByScore - avoid match scattering (bug #26649)', function () {
+		const resourceA = URI.file('photobook/src/components/AddPagesButton/index.js');
+		const resourceB = URI.file('photobook/src/components/ApprovalPageHeader/index.js');
+		const resourceC = URI.file('photobook/src/canvasComponents/BookPage/index.js');
+
+		let query = 'bookpageIndex';
+
+		let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceC);
+
+		res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceC);
+	});
+
+	test('compareFilesByScore - avoid match scattering (bug #33247)', function () {
+		const resourceA = URI.file('ui/src/utils/constants.js');
+		const resourceB = URI.file('ui/src/ui/Icons/index.js');
+
+		let query = isWindows ? 'ui\\icons' : 'ui/icons';
+
+		let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+
+		res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+	});
+
+	test('compareFilesByScore - avoid match scattering (bug #33247 comment)', function () {
+		const resourceA = URI.file('ui/src/components/IDInput/index.js');
+		const resourceB = URI.file('ui/src/ui/Input/index.js');
+
+		let query = isWindows ? 'ui\\input\\index' : 'ui/input/index';
+
+		let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+
+		res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+	});
+
+	test('compareFilesByScore - avoid match scattering (bug #36166)', function () {
+		const resourceA = URI.file('django/contrib/sites/locale/ga/LC_MESSAGES/django.mo');
+		const resourceB = URI.file('django/core/signals.py');
+
+		let query = 'djancosig';
+
+		let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+
+		res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+	});
+
+	test('compareFilesByScore - avoid match scattering (bug #32918)', function () {
+		const resourceA = URI.file('adsys/protected/config.php');
+		const resourceB = URI.file('adsys/protected/framework/smarty/sysplugins/smarty_internal_config.php');
+		const resourceC = URI.file('duowanVideo/wap/protected/config.php');
+
+		let query = 'protectedconfig.php';
+
+		let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceC);
+		assert.equal(res[2], resourceB);
+
+		res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceA);
+		assert.equal(res[1], resourceC);
+		assert.equal(res[2], resourceB);
+	});
+
+	test('compareFilesByScore - avoid match scattering (bug #14879)', function () {
+		const resourceA = URI.file('pkg/search/gradient/testdata/constraint_attrMatchString.yml');
+		const resourceB = URI.file('cmd/gradient/main.go');
+
+		let query = 'gradientmain';
+
+		let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+
+		res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+	});
+
+	test('compareFilesByScore - avoid match scattering (bug #14727 1)', function () {
+		const resourceA = URI.file('alpha-beta-cappa.txt');
+		const resourceB = URI.file('abc.txt');
+
+		let query = 'abc';
+
+		let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+
+		res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+	});
+
+	test('compareFilesByScore - avoid match scattering (bug #14727 2)', function () {
+		const resourceA = URI.file('xerxes-yak-zubba/index.js');
+		const resourceB = URI.file('xyz/index.js');
+
+		let query = 'xyz';
+
+		let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+
+		res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+	});
+
+	test('compareFilesByScore - avoid match scattering (bug #18381)', function () {
+		const resourceA = URI.file('AssymblyInfo.cs');
+		const resourceB = URI.file('IAsynchronousTask.java');
+
+		let query = 'async';
+
+		let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+
+		res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+	});
+
+	test('compareFilesByScore - avoid match scattering (bug #35572)', function () {
+		const resourceA = URI.file('static/app/source/angluar/-admin/-organization/-settings/layout/layout.js');
+		const resourceB = URI.file('static/app/source/angular/-admin/-project/-settings/_settings/settings.js');
+
+		let query = 'partisettings';
+
+		let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+
+		res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+	});
+
+	test('compareFilesByScore - avoid match scattering (bug #36810)', function () {
+		const resourceA = URI.file('Trilby.TrilbyTV.Web.Portal/Views/Systems/Index.cshtml');
+		const resourceB = URI.file('Trilby.TrilbyTV.Web.Portal/Areas/Admins/Views/Tips/Index.cshtml');
+
+		let query = 'tipsindex.cshtml';
+
+		let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+
+		res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+	});
+
+	test('compareFilesByScore - prefer shorter hit (bug #20546)', function () {
+		const resourceA = URI.file('editor/core/components/tests/list-view-spec.js');
+		const resourceB = URI.file('editor/core/components/list-view.js');
+
+		let query = 'listview';
+
+		let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+
+		res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+	});
+
+	test('compareFilesByScore - avoid match scattering (bug #12095)', function () {
+		const resourceA = URI.file('src/vs/workbench/contrib/files/common/explorerViewModel.ts');
+		const resourceB = URI.file('src/vs/workbench/contrib/files/browser/views/explorerView.ts');
+		const resourceC = URI.file('src/vs/workbench/contrib/files/browser/views/explorerViewer.ts');
+
+		let query = 'filesexplorerview.ts';
+
+		let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+
+		res = [resourceA, resourceC, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
+		assert.equal(res[0], resourceB);
+	});
+
+	test('prepareSearchForScoring', () => {
+		assert.equal(scorer.prepareQuery(' f*a ').value, 'fa');
+		assert.equal(scorer.prepareQuery('model Tester.ts').value, 'modelTester.ts');
+		assert.equal(scorer.prepareQuery('Model Tester.ts').lowercase, 'modeltester.ts');
+		assert.equal(scorer.prepareQuery('ModelTester.ts').containsPathSeparator, false);
+		assert.equal(scorer.prepareQuery('Model' + sep + 'Tester.ts').containsPathSeparator, true);
+	});
+});

src/vs/base/test/common/iterator.test.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as assert from 'assert';
-import { Iterator } from 'vs/base/common/iterator';
+import { Iterator, Iterable } from 'vs/base/common/iterator';
 
 suite('Iterator', () => {
 	test('concat', () => {
@@ -16,4 +16,25 @@ suite('Iterator', () => {
 
 		assert.deepEqual(actual, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
 	});
-});
+});
+
+suite('Iterable', function () {
+
+	const customIterable = new class {
+
+		*[Symbol.iterator]() {
+			yield 'one';
+			yield 'two';
+			yield 'three';
+		}
+	};
+
+	test('first', function () {
+
+		assert.equal(Iterable.first([]), undefined);
+		assert.equal(Iterable.first([1]), 1);
+		assert.equal(Iterable.first(customIterable), 'one');
+		assert.equal(Iterable.first(customIterable), 'one'); // fresh
+	});
+
+});

src/vs/base/test/common/linkedList.test.ts

@@ -16,9 +16,12 @@ suite('LinkedList', function () {
 		// assert toArray
 		assert.deepEqual(list.toArray(), elements);
 
-		// assert iterator
-		for (let iter = list.iterator(), element = iter.next(); !element.done; element = iter.next()) {
-			assert.equal(elements.shift(), element.value);
+		// assert Symbol.iterator (1)
+		assert.deepEqual([...list], elements);
+
+		// assert Symbol.iterator (2)
+		for (const item of list) {
+			assert.equal(item, elements.shift());
 		}
 		assert.equal(elements.length, 0);
 	}

src/vs/base/test/common/map.test.ts

@@ -6,7 +6,6 @@
 import { ResourceMap, TernarySearchTree, PathIterator, StringIterator, LinkedMap, Touch, LRUCache, mapToSerializable, serializableToMap } from 'vs/base/common/map';
 import * as assert from 'assert';
 import { URI } from 'vs/base/common/uri';
-import { IteratorResult } from 'vs/base/common/iterator';
 
 suite('Map', () => {
 

src/vs/base/test/common/normalization.test.ts

@@ -0,0 +1,65 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { removeAccents } from 'vs/base/common/normalization';
+
+suite('Normalization', () => {
+
+	test('removeAccents', function () {
+		assert.equal(removeAccents('joào'), 'joao');
+		assert.equal(removeAccents('joáo'), 'joao');
+		assert.equal(removeAccents('joâo'), 'joao');
+		assert.equal(removeAccents('joäo'), 'joao');
+		// assert.equal(strings.removeAccents('joæo'), 'joao'); // not an accent
+		assert.equal(removeAccents('joão'), 'joao');
+		assert.equal(removeAccents('joåo'), 'joao');
+		assert.equal(removeAccents('joåo'), 'joao');
+		assert.equal(removeAccents('joāo'), 'joao');
+
+		assert.equal(removeAccents('fôo'), 'foo');
+		assert.equal(removeAccents('föo'), 'foo');
+		assert.equal(removeAccents('fòo'), 'foo');
+		assert.equal(removeAccents('fóo'), 'foo');
+		// assert.equal(strings.removeAccents('fœo'), 'foo');
+		// assert.equal(strings.removeAccents('føo'), 'foo');
+		assert.equal(removeAccents('fōo'), 'foo');
+		assert.equal(removeAccents('fõo'), 'foo');
+
+		assert.equal(removeAccents('andrè'), 'andre');
+		assert.equal(removeAccents('andré'), 'andre');
+		assert.equal(removeAccents('andrê'), 'andre');
+		assert.equal(removeAccents('andrë'), 'andre');
+		assert.equal(removeAccents('andrē'), 'andre');
+		assert.equal(removeAccents('andrė'), 'andre');
+		assert.equal(removeAccents('andrę'), 'andre');
+
+		assert.equal(removeAccents('hvîc'), 'hvic');
+		assert.equal(removeAccents('hvïc'), 'hvic');
+		assert.equal(removeAccents('hvíc'), 'hvic');
+		assert.equal(removeAccents('hvīc'), 'hvic');
+		assert.equal(removeAccents('hvįc'), 'hvic');
+		assert.equal(removeAccents('hvìc'), 'hvic');
+
+		assert.equal(removeAccents('ûdo'), 'udo');
+		assert.equal(removeAccents('üdo'), 'udo');
+		assert.equal(removeAccents('ùdo'), 'udo');
+		assert.equal(removeAccents('údo'), 'udo');
+		assert.equal(removeAccents('ūdo'), 'udo');
+
+		assert.equal(removeAccents('heÿ'), 'hey');
+
+		// assert.equal(strings.removeAccents('gruß'), 'grus');
+		assert.equal(removeAccents('gruś'), 'grus');
+		assert.equal(removeAccents('gruš'), 'grus');
+
+		assert.equal(removeAccents('çool'), 'cool');
+		assert.equal(removeAccents('ćool'), 'cool');
+		assert.equal(removeAccents('čool'), 'cool');
+
+		assert.equal(removeAccents('ñice'), 'nice');
+		assert.equal(removeAccents('ńice'), 'nice');
+	});
+});

src/vs/base/test/common/strings.test.ts

@@ -92,15 +92,6 @@ suite('Strings', () => {
 		assert.strictEqual(strings.format('Foo {0} Bar. {1}', '(foo)', '.test'), 'Foo (foo) Bar. .test');
 	});
 
-	test('overlap', () => {
-		assert.equal(strings.overlap('foobar', 'arr, I am a priate'), 2);
-		assert.equal(strings.overlap('no', 'overlap'), 1);
-		assert.equal(strings.overlap('no', '0verlap'), 0);
-		assert.equal(strings.overlap('nothing', ''), 0);
-		assert.equal(strings.overlap('', 'nothing'), 0);
-		assert.equal(strings.overlap('full', 'full'), 4);
-		assert.equal(strings.overlap('full', 'fulloverlap'), 4);
-	});
 	test('lcut', () => {
 		assert.strictEqual(strings.lcut('foo bar', 0), '');
 		assert.strictEqual(strings.lcut('foo bar', 1), 'bar');
@@ -404,61 +395,6 @@ suite('Strings', () => {
 		assert.equal(strings.getNLines('foo', 0), '');
 	});
 
-	test('removeAccents', function () {
-		assert.equal(strings.removeAccents('joào'), 'joao');
-		assert.equal(strings.removeAccents('joáo'), 'joao');
-		assert.equal(strings.removeAccents('joâo'), 'joao');
-		assert.equal(strings.removeAccents('joäo'), 'joao');
-		// assert.equal(strings.removeAccents('joæo'), 'joao'); // not an accent
-		assert.equal(strings.removeAccents('joão'), 'joao');
-		assert.equal(strings.removeAccents('joåo'), 'joao');
-		assert.equal(strings.removeAccents('joåo'), 'joao');
-		assert.equal(strings.removeAccents('joāo'), 'joao');
-
-		assert.equal(strings.removeAccents('fôo'), 'foo');
-		assert.equal(strings.removeAccents('föo'), 'foo');
-		assert.equal(strings.removeAccents('fòo'), 'foo');
-		assert.equal(strings.removeAccents('fóo'), 'foo');
-		// assert.equal(strings.removeAccents('fœo'), 'foo');
-		// assert.equal(strings.removeAccents('føo'), 'foo');
-		assert.equal(strings.removeAccents('fōo'), 'foo');
-		assert.equal(strings.removeAccents('fõo'), 'foo');
-
-		assert.equal(strings.removeAccents('andrè'), 'andre');
-		assert.equal(strings.removeAccents('andré'), 'andre');
-		assert.equal(strings.removeAccents('andrê'), 'andre');
-		assert.equal(strings.removeAccents('andrë'), 'andre');
-		assert.equal(strings.removeAccents('andrē'), 'andre');
-		assert.equal(strings.removeAccents('andrė'), 'andre');
-		assert.equal(strings.removeAccents('andrę'), 'andre');
-
-		assert.equal(strings.removeAccents('hvîc'), 'hvic');
-		assert.equal(strings.removeAccents('hvïc'), 'hvic');
-		assert.equal(strings.removeAccents('hvíc'), 'hvic');
-		assert.equal(strings.removeAccents('hvīc'), 'hvic');
-		assert.equal(strings.removeAccents('hvįc'), 'hvic');
-		assert.equal(strings.removeAccents('hvìc'), 'hvic');
-
-		assert.equal(strings.removeAccents('ûdo'), 'udo');
-		assert.equal(strings.removeAccents('üdo'), 'udo');
-		assert.equal(strings.removeAccents('ùdo'), 'udo');
-		assert.equal(strings.removeAccents('údo'), 'udo');
-		assert.equal(strings.removeAccents('ūdo'), 'udo');
-
-		assert.equal(strings.removeAccents('heÿ'), 'hey');
-
-		// assert.equal(strings.removeAccents('gruß'), 'grus');
-		assert.equal(strings.removeAccents('gruś'), 'grus');
-		assert.equal(strings.removeAccents('gruš'), 'grus');
-
-		assert.equal(strings.removeAccents('çool'), 'cool');
-		assert.equal(strings.removeAccents('ćool'), 'cool');
-		assert.equal(strings.removeAccents('čool'), 'cool');
-
-		assert.equal(strings.removeAccents('ñice'), 'nice');
-		assert.equal(strings.removeAccents('ńice'), 'nice');
-	});
-
 	test('encodeUTF8', function () {
 		function assertEncodeUTF8(str: string, expected: number[]): void {
 			const actual = strings.encodeUTF8(str);

src/vs/base/test/common/uuid.test.ts

@@ -7,16 +7,17 @@ import * as uuid from 'vs/base/common/uuid';
 
 suite('UUID', () => {
 	test('generation', () => {
-		const asHex = uuid.v4().asHex();
+		const asHex = uuid.generateUuid();
 		assert.equal(asHex.length, 36);
 		assert.equal(asHex[14], '4');
 		assert.ok(asHex[19] === '8' || asHex[19] === '9' || asHex[19] === 'a' || asHex[19] === 'b');
 	});
 
-	test('parse', () => {
-		const id = uuid.v4();
-		const asHext = id.asHex();
-		const id2 = uuid.parse(asHext);
-		assert.equal(id.asHex(), id2.asHex());
+	test('self-check', function () {
+		const t1 = Date.now();
+		while (Date.now() - t1 < 50) {
+			const value = uuid.generateUuid();
+			assert.ok(uuid.isUUID(value));
+		}
 	});
 });

src/vs/base/test/node/glob.test.ts

@@ -239,10 +239,7 @@ suite('Glob', () => {
 		assertGlobMatch(p, 'some/folder/project.json');
 		assertNoGlobMatch(p, 'some/folder/file_project.json');
 		assertNoGlobMatch(p, 'some/folder/fileproject.json');
-		// assertNoGlobMatch(p, '/rrproject.json'); TODO@ben this still fails if T1-3 are disabled
 		assertNoGlobMatch(p, 'some/rrproject.json');
-		// assertNoGlobMatch(p, 'rrproject.json');
-		// assertNoGlobMatch(p, '\\rrproject.json');
 		assertNoGlobMatch(p, 'some\\rrproject.json');
 
 		p = 'test/**';