Merge from vscode 1ec43773e37997841c5af42b33ddb180e9735bf2

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

@@ -0,0 +1,27 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { Separator, prepareActions } from 'vs/base/browser/ui/actionbar/actionbar';
+import { Action } from 'vs/base/common/actions';
+
+suite('Actionbar', () => {
+
+	test('prepareActions()', function () {
+		let a1 = new Separator();
+		let a2 = new Separator();
+		let a3 = new Action('a3');
+		let a4 = new Separator();
+		let a5 = new Separator();
+		let a6 = new Action('a6');
+		let a7 = new Separator();
+
+		let actions = prepareActions([a1, a2, a3, a4, a5, a6, a7]);
+		assert.strictEqual(actions.length, 3); // duplicate separators get removed
+		assert(actions[0] === a3);
+		assert(actions[1] === a5);
+		assert(actions[2] === a6);
+	});
+});

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

@@ -2,9 +2,11 @@
  *  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 { IMatch } from 'vs/base/common/filters';
 import { matchesFuzzyCodiconAware, parseCodicons, IParsedCodicons } from 'vs/base/common/codicon';
+import { stripCodicons } from 'vs/base/common/codicons';
 
 export interface ICodiconFilter {
 	// Returns null if word doesn't match.
@@ -64,3 +66,13 @@ suite('Codicon', () => {
 		]);
 	});
 });
+
+suite('Codicons', () => {
+
+	test('stripCodicons', () => {
+		assert.equal(stripCodicons('Hello World'), 'Hello World');
+		assert.equal(stripCodicons('$(Hello World'), '$(Hello World');
+		assert.equal(stripCodicons('$(Hello) World'), ' World');
+		assert.equal(stripCodicons('$(Hello) W$(oi)rld'), ' Wrld');
+	});
+});

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

@@ -43,7 +43,7 @@ class NullAccessorClass implements scorer.IItemAccessor<URI> {
 }
 
 function _doScore(target: string, query: string, fuzzy: boolean): scorer.Score {
-	return scorer.score(target, query, query.toLowerCase(), fuzzy);
+	return scorer.score(target, scorer.prepareQuery(query), fuzzy);
 }
 
 function scoreItem<T>(item: T, query: string, fuzzy: boolean, accessor: scorer.IItemAccessor<T>, cache: scorer.ScorerCache): scorer.IItemScore {
@@ -109,6 +109,42 @@ suite('Fuzzy Scorer', () => {
 		assert.equal(_doScore(target, 'eo', false)[0], 0);
 	});
 
+	test('score (fuzzy, multiple)', function () {
+		const target = 'HeLlo-World';
+
+		const [firstSingleScore, firstSinglePositions] = _doScore(target, 'HelLo', true);
+		const [secondSingleScore, secondSinglePositions] = _doScore(target, 'World', true);
+		const firstAndSecondSinglePositions = [...firstSinglePositions, ...secondSinglePositions];
+
+		let [multiScore, multiPositions] = _doScore(target, 'HelLo World', true);
+
+		function assertScore() {
+			assert.ok(multiScore >= firstSingleScore + secondSingleScore);
+			for (let i = 0; i < multiPositions.length; i++) {
+				assert.equal(multiPositions[i], firstAndSecondSinglePositions[i]);
+			}
+		}
+
+		function assertNoScore() {
+			assert.equal(multiScore, 0);
+			assert.equal(multiPositions.length, 0);
+		}
+
+		assertScore();
+
+		[multiScore, multiPositions] = _doScore(target, 'World HelLo', true);
+		assertScore();
+
+		[multiScore, multiPositions] = _doScore(target, 'World HelLo World', true);
+		assertScore();
+
+		[multiScore, multiPositions] = _doScore(target, 'World HelLo Nothing', true);
+		assertNoScore();
+
+		[multiScore, multiPositions] = _doScore(target, 'More Nothing', true);
+		assertNoScore();
+	});
+
 	test('scoreItem - matches are proper', function () {
 		let res = scoreItem(null, 'something', true, ResourceAccessor, cache);
 		assert.ok(!res.score);
@@ -820,11 +856,42 @@ suite('Fuzzy Scorer', () => {
 		assert.equal(res[0], resourceB);
 	});
 
-	test('prepareSearchForScoring', () => {
+	test('prepareQuery', () => {
 		assert.equal(scorer.prepareQuery(' f*a ').value, 'fa');
+		assert.equal(scorer.prepareQuery('model Tester.ts').original, 'model Tester.ts');
+		assert.equal(scorer.prepareQuery('model Tester.ts').originalLowercase, 'model Tester.ts'.toLowerCase());
 		assert.equal(scorer.prepareQuery('model Tester.ts').value, 'modelTester.ts');
-		assert.equal(scorer.prepareQuery('Model Tester.ts').lowercase, 'modeltester.ts');
+		assert.equal(scorer.prepareQuery('Model Tester.ts').valueLowercase, 'modeltester.ts');
 		assert.equal(scorer.prepareQuery('ModelTester.ts').containsPathSeparator, false);
 		assert.equal(scorer.prepareQuery('Model' + sep + 'Tester.ts').containsPathSeparator, true);
+
+		// with spaces
+		let query = scorer.prepareQuery('He*llo World');
+		assert.equal(query.original, 'He*llo World');
+		assert.equal(query.value, 'HelloWorld');
+		assert.equal(query.valueLowercase, 'HelloWorld'.toLowerCase());
+		assert.equal(query.values?.length, 2);
+		assert.equal(query.values?.[0].original, 'He*llo');
+		assert.equal(query.values?.[0].value, 'Hello');
+		assert.equal(query.values?.[0].valueLowercase, 'Hello'.toLowerCase());
+		assert.equal(query.values?.[1].original, 'World');
+		assert.equal(query.values?.[1].value, 'World');
+		assert.equal(query.values?.[1].valueLowercase, 'World'.toLowerCase());
+
+		// with spaces that are empty
+		query = scorer.prepareQuery(' Hello   World  	');
+		assert.equal(query.original, ' Hello   World  	');
+		assert.equal(query.originalLowercase, ' Hello   World  	'.toLowerCase());
+		assert.equal(query.value, 'HelloWorld');
+		assert.equal(query.valueLowercase, 'HelloWorld'.toLowerCase());
+		assert.equal(query.values?.length, 2);
+		assert.equal(query.values?.[0].original, 'Hello');
+		assert.equal(query.values?.[0].originalLowercase, 'Hello'.toLowerCase());
+		assert.equal(query.values?.[0].value, 'Hello');
+		assert.equal(query.values?.[0].valueLowercase, 'Hello'.toLowerCase());
+		assert.equal(query.values?.[1].original, 'World');
+		assert.equal(query.values?.[1].originalLowercase, 'World'.toLowerCase());
+		assert.equal(query.values?.[1].value, 'World');
+		assert.equal(query.values?.[1].valueLowercase, 'World'.toLowerCase());
 	});
 });