ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-17 02:51:36 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge from vscode 073a24de05773f2261f89172987002dc0ae2f1cd (#9711)

Browse Source
This commit is contained in:
Anthony Dresser
2020-03-24 00:24:15 -07:00
committed by GitHub
parent 29741d684e
commit 89ef1b0c2e
226 changed files with 6161 additions and 3288 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
src/vs/base/test/common/fuzzyScorer.test.ts
View File

@@ -8,6 +8,7 @@ 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';
import { Schemas } from 'vs/base/common/network';
class ResourceAccessorClass implements scorer.IItemAccessor<URI> {
@@ -49,8 +50,8 @@ function scoreItem<T>(item: T, query: string, fuzzy: boolean, accessor: scorer.I
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);
function compareItemsByScore<T>(itemA: T, itemB: T, query: string, fuzzy: boolean, accessor: scorer.IItemAccessor<T>, cache: scorer.ScorerCache): number {
return scorer.compareItemsByScore(itemA, itemB, scorer.prepareQuery(query), fuzzy, accessor, cache);
}
const NullAccessor = new NullAccessorClass();
@@ -279,6 +280,19 @@ suite('Fuzzy Scorer', () => {
assert.ok(!res.score);
});
test('scoreItem - match if using slash or backslash (local, remote resource)', function () {
const localResource = URI.file('abcde/super/duper');
const remoteResource = URI.from({ scheme: Schemas.vscodeRemote, path: 'abcde/super/duper' });
for (const resource of [localResource, remoteResource]) {
let res = scoreItem(resource, 'abcde\\super\\duper', true, ResourceAccessor, cache);
assert.ok(res.score);
res = scoreItem(resource, 'abcde/super/duper', 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');
@@ -509,33 +523,13 @@ suite('Fuzzy Scorer', () => {
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');
test('compareFilesByScore - prefer matches in label over description if scores are otherwise equal', function () {
const resourceA = URI.file('parts/quick/arrow-left-dark.svg');
const resourceB = URI.file('parts/quickopen/quickopen.ts');
let query = 'vscode';
let query = 'partsquick';
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;
});
});
let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor, cache));
assert.equal(res[0], resourceB);
assert.equal(res[1], resourceA);
});

58
src/vs/base/test/common/resources.test.ts
View File

@@ -3,7 +3,7 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
import { dirname, basename, distinctParents, joinPath, isEqual, isEqualOrParent, hasToIgnoreCase, normalizePath, isAbsolutePath, relativePath, removeTrailingPathSeparator, hasTrailingPathSeparator, resolvePath, addTrailingPathSeparator } from 'vs/base/common/resources';
import { dirname, basename, distinctParents, joinPath, isEqual, isEqualOrParent, hasToIgnoreCase, normalizePath, isAbsolutePath, relativePath, removeTrailingPathSeparator, hasTrailingPathSeparator, resolvePath, addTrailingPathSeparator, getComparisonKey } from 'vs/base/common/resources';
import { URI } from 'vs/base/common/uri';
import { isWindows } from 'vs/base/common/platform';
import { toSlashes } from 'vs/base/common/extpath';
@@ -66,6 +66,8 @@ suite('Resources', () => {
// does not explode (https://github.com/Microsoft/vscode/issues/41987)
dirname(URI.from({ scheme: 'file', authority: '/users/someone/portal.h' }));
assert.equal(dirname(URI.parse('foo://a/b/c?q')).toString(), 'foo://a/b?q');
});
test('basename', () => {
@@ -156,6 +158,7 @@ suite('Resources', () => {
assert.equal(normalizePath(URI.parse('foo://a/foo/foo/./../some/../bar')).toString(), 'foo://a/foo/bar');
assert.equal(normalizePath(URI.parse('foo://a')).toString(), 'foo://a');
assert.equal(normalizePath(URI.parse('foo://a/')).toString(), 'foo://a/');
assert.equal(normalizePath(URI.parse('foo://a/foo/./bar?q=1')).toString(), URI.parse('foo://a/foo/bar?q%3D1').toString());
});
test('isAbsolute', () => {
@@ -233,7 +236,7 @@ suite('Resources', () => {
});
function assertEqualURI(actual: URI, expected: URI, message?: string) {
if (!isEqual(expected, actual)) {
if (!isEqual(expected, actual, hasToIgnoreCase(expected), false)) {
assert.equal(actual.toString(), expected.toString(), message);
}
}
@@ -259,7 +262,7 @@ suite('Resources', () => {
assertRelativePath(URI.parse('foo://a'), URI.parse('foo://a'), '');
assertRelativePath(URI.parse('foo://a/'), URI.parse('foo://a/'), '');
assertRelativePath(URI.parse('foo://a/'), URI.parse('foo://a'), '');
assertRelativePath(URI.parse('foo://a/foo?q'), URI.parse('foo://a/foo/bar#h'), 'bar');
assertRelativePath(URI.parse('foo://a/foo?q'), URI.parse('foo://a/foo/bar#h'), 'bar', true);
assertRelativePath(URI.parse('foo://'), URI.parse('foo://a/b'), undefined);
assertRelativePath(URI.parse('foo://a2/b'), URI.parse('foo://a/b'), undefined);
assertRelativePath(URI.parse('goo://a/b'), URI.parse('foo://a/b'), undefined);
@@ -343,26 +346,44 @@ suite('Resources', () => {
});
function assertIsEqual(u1: URI, u2: URI, ignoreCase: boolean, expected: boolean) {
assert.equal(isEqual(u1, u2, ignoreCase), expected, `${u1.toString()}${expected ? '===' : '!=='}${u2.toString()}`);
assert.equal(getComparisonKey(u1, ignoreCase) === getComparisonKey(u2, ignoreCase), expected, `comparison keys ${u1.toString()}, ${u2.toString()}`);
assert.equal(isEqualOrParent(u1, u2, ignoreCase), expected, `isEqualOrParent ${u1.toString()}, ${u2.toString()}`);
}
test('isEqual', () => {
let fileURI = isWindows ? URI.file('c:\\foo\\bar') : URI.file('/foo/bar');
let fileURI2 = isWindows ? URI.file('C:\\foo\\Bar') : URI.file('/foo/Bar');
assert.equal(isEqual(fileURI, fileURI, true), true);
assert.equal(isEqual(fileURI, fileURI, false), true);
assert.equal(isEqual(fileURI, fileURI, hasToIgnoreCase(fileURI)), true);
assert.equal(isEqual(fileURI, fileURI2, true), true);
assert.equal(isEqual(fileURI, fileURI2, false), false);
assertIsEqual(fileURI, fileURI, true, true);
assertIsEqual(fileURI, fileURI, false, true);
assertIsEqual(fileURI, fileURI, hasToIgnoreCase(fileURI), true);
assertIsEqual(fileURI, fileURI2, true, true);
assertIsEqual(fileURI, fileURI2, false, false);
let fileURI3 = URI.parse('foo://server:453/foo/bar');
let fileURI4 = URI.parse('foo://server:453/foo/Bar');
assert.equal(isEqual(fileURI3, fileURI3, true), true);
assert.equal(isEqual(fileURI3, fileURI3, false), true);
assert.equal(isEqual(fileURI3, fileURI3, hasToIgnoreCase(fileURI3)), true);
assert.equal(isEqual(fileURI3, fileURI4, true), true);
assert.equal(isEqual(fileURI3, fileURI4, false), false);
assertIsEqual(fileURI3, fileURI3, true, true);
assertIsEqual(fileURI3, fileURI3, false, true);
assertIsEqual(fileURI3, fileURI3, hasToIgnoreCase(fileURI3), true);
assertIsEqual(fileURI3, fileURI4, true, true);
assertIsEqual(fileURI3, fileURI4, false, false);
assert.equal(isEqual(fileURI, fileURI3, true), false);
assertIsEqual(fileURI, fileURI3, true, false);
assert.equal(isEqual(URI.parse('foo://server'), URI.parse('foo://server/')), true);
assertIsEqual(URI.parse('foo://server'), URI.parse('foo://server/'), true, true);
assertIsEqual(URI.parse('foo://server/foo'), URI.parse('foo://server/foo/'), true, false);
assertIsEqual(URI.parse('foo://server/foo'), URI.parse('foo://server/foo?'), true, true);
let fileURI5 = URI.parse('foo://server:453/foo/bar?q=1');
let fileURI6 = URI.parse('foo://server:453/foo/bar#xy');
assertIsEqual(fileURI5, fileURI5, true, true);
assertIsEqual(fileURI5, fileURI3, true, false);
assertIsEqual(fileURI6, fileURI6, true, true);
assertIsEqual(fileURI6, fileURI5, true, false);
assertIsEqual(fileURI6, fileURI3, true, true);
});
test('isEqualOrParent', () => {
@@ -388,5 +409,12 @@ suite('Resources', () => {
assert.equal(isEqualOrParent(fileURI3, fileURI4, false), true, '14');
assert.equal(isEqualOrParent(fileURI3, fileURI, true), false, '15');
assert.equal(isEqualOrParent(fileURI5, fileURI5, true), true, '16');
let fileURI6 = URI.parse('foo://server:453/foo?q=1');
let fileURI7 = URI.parse('foo://server:453/foo/bar?q=1');
assert.equal(isEqualOrParent(fileURI6, fileURI5, true), false, '17');
assert.equal(isEqualOrParent(fileURI6, fileURI6, true), true, '18');
assert.equal(isEqualOrParent(fileURI7, fileURI6, true), true, '19');
assert.equal(isEqualOrParent(fileURI7, fileURI5, true), false, '20');
});
});