Merge from vscode 7eaf220cafb9d9e901370ffce02229171cbf3ea6

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

@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { renderCodiconsAsElement } from 'vs/base/browser/codicons';
+import * as assert from 'assert';
+
+suite('renderCodicons', () => {
+
+	test('no codicons', () => {
+		const result = renderCodiconsAsElement(' hello World .');
+
+		assert.equal(elementsToString(result), ' hello World .');
+	});
+
+	test('codicon only', () => {
+		const result = renderCodiconsAsElement('$(alert)');
+
+		assert.equal(elementsToString(result), '<span class="codicon codicon-alert"></span>');
+	});
+
+	test('codicon and non-codicon strings', () => {
+		const result = renderCodiconsAsElement(` $(alert) Unresponsive`);
+
+		assert.equal(elementsToString(result), ' <span class="codicon codicon-alert"></span> Unresponsive');
+	});
+
+	test('multiple codicons', () => {
+		const result = renderCodiconsAsElement('$(check)$(error)');
+
+		assert.equal(elementsToString(result), '<span class="codicon codicon-check"></span><span class="codicon codicon-error"></span>');
+	});
+
+	test('escaped codicon', () => {
+		const result = renderCodiconsAsElement('\\$(escaped)');
+
+		assert.equal(elementsToString(result), '$(escaped)');
+	});
+
+	test('codicon with animation', () => {
+		const result = renderCodiconsAsElement('$(zip~anim)');
+
+		assert.equal(elementsToString(result), '<span class="codicon codicon-zip codicon-animation-anim"></span>');
+	});
+
+	const elementsToString = (elements: Array<HTMLElement | string>): string => {
+		return elements
+			.map(elem => elem instanceof HTMLElement ? elem.outerHTML : elem)
+			.reduce((a, b) => a + b, '');
+	};
+});

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

@@ -688,4 +688,22 @@ suite('Async', () => {
 		assert.ok(Date.now() - now < 100);
 		assert.equal(timedout, false);
 	});
+
+	test('SequencerByKey', async () => {
+		const s = new async.SequencerByKey<string>();
+
+		const r1 = await s.queue('key1', () => Promise.resolve('hello'));
+		assert.equal(r1, 'hello');
+
+		await s.queue('key2', () => Promise.reject(new Error('failed'))).then(() => {
+			throw new Error('should not be resolved');
+		}, err => {
+			// Expected error
+			assert.equal(err.message, 'failed');
+		});
+
+		// Still works after a queued promise is rejected
+		const r3 = await s.queue('key2', () => Promise.resolve('hello'));
+		assert.equal(r3, 'hello');
+	});
 });

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

@@ -57,6 +57,13 @@ suite('Paths', () => {
 			assert.ok(!extpath.isValidBasename('aux'));
 			assert.ok(!extpath.isValidBasename('Aux'));
 			assert.ok(!extpath.isValidBasename('LPT0'));
+			assert.ok(!extpath.isValidBasename('aux.txt'));
+			assert.ok(!extpath.isValidBasename('com0.abc'));
+			assert.ok(extpath.isValidBasename('LPT00'));
+			assert.ok(extpath.isValidBasename('aux1'));
+			assert.ok(extpath.isValidBasename('aux1.txt'));
+			assert.ok(extpath.isValidBasename('aux1.aux.txt'));
+
 			assert.ok(!extpath.isValidBasename('test.txt.'));
 			assert.ok(!extpath.isValidBasename('test.txt..'));
 			assert.ok(!extpath.isValidBasename('test.txt '));

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

@@ -1025,6 +1025,51 @@ suite('Fuzzy Scorer', () => {
 		assert.equal(res[1], resourceB);
 	});
 
+	test('compareFilesByScore - boost better prefix match if multiple queries are used', function () {
+		const resourceA = URI.file('src/vs/workbench/services/host/browser/browserHostService.ts');
+		const resourceB = URI.file('src/vs/workbench/browser/workbench.ts');
+
+		for (const query of ['workbench.ts browser', 'browser workbench.ts', 'browser workbench', 'workbench browser']) {
+			let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor));
+			assert.equal(res[0], resourceB);
+			assert.equal(res[1], resourceA);
+
+			res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor));
+			assert.equal(res[0], resourceB);
+			assert.equal(res[1], resourceA);
+		}
+	});
+
+	test('compareFilesByScore - boost shorter prefix match if multiple queries are used', function () {
+		const resourceA = URI.file('src/vs/workbench/browser/actions/windowActions.ts');
+		const resourceB = URI.file('src/vs/workbench/electron-browser/window.ts');
+
+		for (const query of ['window browser', 'window.ts browser']) {
+			let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor));
+			assert.equal(res[0], resourceB);
+			assert.equal(res[1], resourceA);
+
+			res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor));
+			assert.equal(res[0], resourceB);
+			assert.equal(res[1], resourceA);
+		}
+	});
+
+	test('compareFilesByScore - boost shorter prefix match if multiple queries are used (#99171)', function () {
+		const resourceA = URI.file('mesh_editor_lifetime_job.h');
+		const resourceB = URI.file('lifetime_job.h');
+
+		for (const query of ['m life, life m']) {
+			let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor));
+			assert.equal(res[0], resourceB);
+			assert.equal(res[1], resourceA);
+
+			res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor));
+			assert.equal(res[0], resourceB);
+			assert.equal(res[1], resourceA);
+		}
+	});
+
 	test('prepareQuery', () => {
 		assert.equal(scorer.prepareQuery(' f*a ').normalized, 'fa');
 		assert.equal(scorer.prepareQuery('model Tester.ts').original, 'model Tester.ts');