OCram85/code-server
Archived
1
0
Fork 0
Code Pull Requests 2 Activity

chore(vscode): update to 1.53.2

Browse Source 
These conflicts will be resolved in the following commits. We do it this way so
that PR review is possible.
This commit is contained in:
Joe Previte
2021-02-25 11:27:27 -07:00
parent db3a13ba06 89b6e0164f
commit eae5d8c807
1900 changed files with 83066 additions and 64589 deletions
Download Patch File Download Diff File Expand all files Collapse all files

174
lib/vscode/src/vs/base/test/common/arrays.test.ts
View File

@ -10,25 +10,25 @@ suite('Arrays', () => {
const array = [1, 4, 5, 7, 55, 59, 60, 61, 64, 69];
let idx = arrays.findFirstInSorted(array, e => e >= 0);
assert.equal(array[idx], 1);
assert.strictEqual(array[idx], 1);
idx = arrays.findFirstInSorted(array, e => e > 1);
assert.equal(array[idx], 4);
assert.strictEqual(array[idx], 4);
idx = arrays.findFirstInSorted(array, e => e >= 8);
assert.equal(array[idx], 55);
assert.strictEqual(array[idx], 55);
idx = arrays.findFirstInSorted(array, e => e >= 61);
assert.equal(array[idx], 61);
assert.strictEqual(array[idx], 61);
idx = arrays.findFirstInSorted(array, e => e >= 69);
assert.equal(array[idx], 69);
assert.strictEqual(array[idx], 69);
idx = arrays.findFirstInSorted(array, e => e >= 70);
assert.equal(idx, array.length);
assert.strictEqual(idx, array.length);
idx = arrays.findFirstInSorted([], e => e >= 0);
assert.equal(array[idx], 1);
assert.strictEqual(array[idx], 1);
});
test('quickSelect', () => {
@ -36,10 +36,10 @@ suite('Arrays', () => {
function assertMedian(expexted: number, data: number[], nth: number = Math.floor(data.length / 2)) {
const compare = (a: number, b: number) => a - b;
let actual1 = arrays.quickSelect(nth, data, compare);
assert.equal(actual1, expexted);
assert.strictEqual(actual1, expexted);
let actual2 = data.slice().sort(compare)[nth];
assert.equal(actual2, expexted);
assert.strictEqual(actual2, expexted);
}
assertMedian(5, [9, 1, 0, 2, 3, 4, 6, 8, 7, 10, 5]);
@ -72,18 +72,18 @@ suite('Arrays', () => {
test('mergeSort', () => {
let data = arrays.mergeSort([6, 5, 3, 1, 8, 7, 2, 4], (a, b) => a - b);
assert.deepEqual(data, [1, 2, 3, 4, 5, 6, 7, 8]);
assert.deepStrictEqual(data, [1, 2, 3, 4, 5, 6, 7, 8]);
});
test('mergeSort, sorted array', function () {
let data = arrays.mergeSort([1, 2, 3, 4, 5, 6], (a, b) => a - b);
assert.deepEqual(data, [1, 2, 3, 4, 5, 6]);
assert.deepStrictEqual(data, [1, 2, 3, 4, 5, 6]);
});
test('mergeSort, is stable', function () {
let numbers = arrays.mergeSort([33, 22, 11, 4, 99, 1], (a, b) => 0);
assert.deepEqual(numbers, [33, 22, 11, 4, 99, 1]);
assert.deepStrictEqual(numbers, [33, 22, 11, 4, 99, 1]);
});
test('mergeSort, many random numbers', function () {
@ -129,40 +129,40 @@ suite('Arrays', () => {
}
let d = arrays.sortedDiff([1, 2, 4], [], compare);
assert.deepEqual(d, [
assert.deepStrictEqual(d, [
{ start: 0, deleteCount: 3, toInsert: [] }
]);
d = arrays.sortedDiff([], [1, 2, 4], compare);
assert.deepEqual(d, [
assert.deepStrictEqual(d, [
{ start: 0, deleteCount: 0, toInsert: [1, 2, 4] }
]);
d = arrays.sortedDiff([1, 2, 4], [1, 2, 4], compare);
assert.deepEqual(d, []);
assert.deepStrictEqual(d, []);
d = arrays.sortedDiff([1, 2, 4], [2, 3, 4, 5], compare);
assert.deepEqual(d, [
assert.deepStrictEqual(d, [
{ start: 0, deleteCount: 1, toInsert: [] },
{ start: 2, deleteCount: 0, toInsert: [3] },
{ start: 3, deleteCount: 0, toInsert: [5] },
]);
d = arrays.sortedDiff([2, 3, 4, 5], [1, 2, 4], compare);
assert.deepEqual(d, [
assert.deepStrictEqual(d, [
{ start: 0, deleteCount: 0, toInsert: [1] },
{ start: 1, deleteCount: 1, toInsert: [] },
{ start: 3, deleteCount: 1, toInsert: [] },
]);
d = arrays.sortedDiff([1, 3, 5, 7], [5, 9, 11], compare);
assert.deepEqual(d, [
assert.deepStrictEqual(d, [
{ start: 0, deleteCount: 2, toInsert: [] },
{ start: 3, deleteCount: 1, toInsert: [9, 11] }
]);
d = arrays.sortedDiff([1, 3, 7], [5, 9, 11], compare);
assert.deepEqual(d, [
assert.deepStrictEqual(d, [
{ start: 0, deleteCount: 3, toInsert: [5, 9, 11] }
]);
});
@ -173,32 +173,32 @@ suite('Arrays', () => {
}
let d = arrays.delta([1, 2, 4], [], compare);
assert.deepEqual(d.removed, [1, 2, 4]);
assert.deepEqual(d.added, []);
assert.deepStrictEqual(d.removed, [1, 2, 4]);
assert.deepStrictEqual(d.added, []);
d = arrays.delta([], [1, 2, 4], compare);
assert.deepEqual(d.removed, []);
assert.deepEqual(d.added, [1, 2, 4]);
assert.deepStrictEqual(d.removed, []);
assert.deepStrictEqual(d.added, [1, 2, 4]);
d = arrays.delta([1, 2, 4], [1, 2, 4], compare);
assert.deepEqual(d.removed, []);
assert.deepEqual(d.added, []);
assert.deepStrictEqual(d.removed, []);
assert.deepStrictEqual(d.added, []);
d = arrays.delta([1, 2, 4], [2, 3, 4, 5], compare);
assert.deepEqual(d.removed, [1]);
assert.deepEqual(d.added, [3, 5]);
assert.deepStrictEqual(d.removed, [1]);
assert.deepStrictEqual(d.added, [3, 5]);
d = arrays.delta([2, 3, 4, 5], [1, 2, 4], compare);
assert.deepEqual(d.removed, [3, 5]);
assert.deepEqual(d.added, [1]);
assert.deepStrictEqual(d.removed, [3, 5]);
assert.deepStrictEqual(d.added, [1]);
d = arrays.delta([1, 3, 5, 7], [5, 9, 11], compare);
assert.deepEqual(d.removed, [1, 3, 7]);
assert.deepEqual(d.added, [9, 11]);
assert.deepStrictEqual(d.removed, [1, 3, 7]);
assert.deepStrictEqual(d.added, [9, 11]);
d = arrays.delta([1, 3, 7], [5, 9, 11], compare);
assert.deepEqual(d.removed, [1, 3, 7]);
assert.deepEqual(d.added, [5, 9, 11]);
assert.deepStrictEqual(d.removed, [1, 3, 7]);
assert.deepStrictEqual(d.added, [5, 9, 11]);
});
test('binarySearch', () => {
@ -207,13 +207,13 @@ suite('Arrays', () => {
}
const array = [1, 4, 5, 7, 55, 59, 60, 61, 64, 69];
assert.equal(arrays.binarySearch(array, 1, compare), 0);
assert.equal(arrays.binarySearch(array, 5, compare), 2);
assert.strictEqual(arrays.binarySearch(array, 1, compare), 0);
assert.strictEqual(arrays.binarySearch(array, 5, compare), 2);
// insertion point
assert.equal(arrays.binarySearch(array, 0, compare), ~0);
assert.equal(arrays.binarySearch(array, 6, compare), ~3);
assert.equal(arrays.binarySearch(array, 70, compare), ~10);
assert.strictEqual(arrays.binarySearch(array, 0, compare), ~0);
assert.strictEqual(arrays.binarySearch(array, 6, compare), ~3);
assert.strictEqual(arrays.binarySearch(array, 70, compare), ~10);
});
@ -222,11 +222,11 @@ suite('Arrays', () => {
return a;
}
assert.deepEqual(arrays.distinct(['32', '4', '5'], compare), ['32', '4', '5']);
assert.deepEqual(arrays.distinct(['32', '4', '5', '4'], compare), ['32', '4', '5']);
assert.deepEqual(arrays.distinct(['32', 'constructor', '5', '1'], compare), ['32', 'constructor', '5', '1']);
assert.deepEqual(arrays.distinct(['32', 'constructor', 'proto', 'proto', 'constructor'], compare), ['32', 'constructor', 'proto']);
assert.deepEqual(arrays.distinct(['32', '4', '5', '32', '4', '5', '32', '4', '5', '5'], compare), ['32', '4', '5']);
assert.deepStrictEqual(arrays.distinct(['32', '4', '5'], compare), ['32', '4', '5']);
assert.deepStrictEqual(arrays.distinct(['32', '4', '5', '4'], compare), ['32', '4', '5']);
assert.deepStrictEqual(arrays.distinct(['32', 'constructor', '5', '1'], compare), ['32', 'constructor', '5', '1']);
assert.deepStrictEqual(arrays.distinct(['32', 'constructor', 'proto', 'proto', 'constructor'], compare), ['32', 'constructor', 'proto']);
assert.deepStrictEqual(arrays.distinct(['32', '4', '5', '32', '4', '5', '32', '4', '5', '5'], compare), ['32', '4', '5']);
});
test('top', () => {
@ -236,13 +236,13 @@ suite('Arrays', () => {
return a - b;
};
assert.deepEqual(arrays.top([], cmp, 1), []);
assert.deepEqual(arrays.top([1], cmp, 0), []);
assert.deepEqual(arrays.top([1, 2], cmp, 1), [1]);
assert.deepEqual(arrays.top([2, 1], cmp, 1), [1]);
assert.deepEqual(arrays.top([1, 3, 2], cmp, 2), [1, 2]);
assert.deepEqual(arrays.top([3, 2, 1], cmp, 3), [1, 2, 3]);
assert.deepEqual(arrays.top([4, 6, 2, 7, 8, 3, 5, 1], cmp, 3), [1, 2, 3]);
assert.deepStrictEqual(arrays.top([], cmp, 1), []);
assert.deepStrictEqual(arrays.top([1], cmp, 0), []);
assert.deepStrictEqual(arrays.top([1, 2], cmp, 1), [1]);
assert.deepStrictEqual(arrays.top([2, 1], cmp, 1), [1]);
assert.deepStrictEqual(arrays.top([1, 3, 2], cmp, 2), [1, 2]);
assert.deepStrictEqual(arrays.top([3, 2, 1], cmp, 3), [1, 2, 3]);
assert.deepStrictEqual(arrays.top([4, 6, 2, 7, 8, 3, 5, 1], cmp, 3), [1, 2, 3]);
});
test('topAsync', async () => {
@ -259,56 +259,56 @@ suite('Arrays', () => {
async function testTopAsync(cmp: any, m: number) {
{
const result = await arrays.topAsync([], cmp, 1, m);
assert.deepEqual(result, []);
assert.deepStrictEqual(result, []);
}
{
const result = await arrays.topAsync([1], cmp, 0, m);
assert.deepEqual(result, []);
assert.deepStrictEqual(result, []);
}
{
const result = await arrays.topAsync([1, 2], cmp, 1, m);
assert.deepEqual(result, [1]);
assert.deepStrictEqual(result, [1]);
}
{
const result = await arrays.topAsync([2, 1], cmp, 1, m);
assert.deepEqual(result, [1]);
assert.deepStrictEqual(result, [1]);
}
{
const result = await arrays.topAsync([1, 3, 2], cmp, 2, m);
assert.deepEqual(result, [1, 2]);
assert.deepStrictEqual(result, [1, 2]);
}
{
const result = await arrays.topAsync([3, 2, 1], cmp, 3, m);
assert.deepEqual(result, [1, 2, 3]);
assert.deepStrictEqual(result, [1, 2, 3]);
}
{
const result = await arrays.topAsync([4, 6, 2, 7, 8, 3, 5, 1], cmp, 3, m);
assert.deepEqual(result, [1, 2, 3]);
assert.deepStrictEqual(result, [1, 2, 3]);
}
}
test('coalesce', () => {
let a: Array<number | null> = arrays.coalesce([null, 1, null, 2, 3]);
assert.equal(a.length, 3);
assert.equal(a[0], 1);
assert.equal(a[1], 2);
assert.equal(a[2], 3);
assert.strictEqual(a.length, 3);
assert.strictEqual(a[0], 1);
assert.strictEqual(a[1], 2);
assert.strictEqual(a[2], 3);
arrays.coalesce([null, 1, null, undefined, undefined, 2, 3]);
assert.equal(a.length, 3);
assert.equal(a[0], 1);
assert.equal(a[1], 2);
assert.equal(a[2], 3);
assert.strictEqual(a.length, 3);
assert.strictEqual(a[0], 1);
assert.strictEqual(a[1], 2);
assert.strictEqual(a[2], 3);
let b: number[] = [];
b[10] = 1;
b[20] = 2;
b[30] = 3;
b = arrays.coalesce(b);
assert.equal(b.length, 3);
assert.equal(b[0], 1);
assert.equal(b[1], 2);
assert.equal(b[2], 3);
assert.strictEqual(b.length, 3);
assert.strictEqual(b[0], 1);
assert.strictEqual(b[1], 2);
assert.strictEqual(b[2], 3);
let sparse: number[] = [];
sparse[0] = 1;
@ -317,36 +317,36 @@ suite('Arrays', () => {
sparse[1000] = 1;
sparse[1001] = 1;
assert.equal(sparse.length, 1002);
assert.strictEqual(sparse.length, 1002);
sparse = arrays.coalesce(sparse);
assert.equal(sparse.length, 5);
assert.strictEqual(sparse.length, 5);
});
test('coalesce - inplace', function () {
let a: Array<number | null> = [null, 1, null, 2, 3];
arrays.coalesceInPlace(a);
assert.equal(a.length, 3);
assert.equal(a[0], 1);
assert.equal(a[1], 2);
assert.equal(a[2], 3);
assert.strictEqual(a.length, 3);
assert.strictEqual(a[0], 1);
assert.strictEqual(a[1], 2);
assert.strictEqual(a[2], 3);
a = [null, 1, null, undefined!, undefined!, 2, 3];
arrays.coalesceInPlace(a);
assert.equal(a.length, 3);
assert.equal(a[0], 1);
assert.equal(a[1], 2);
assert.equal(a[2], 3);
assert.strictEqual(a.length, 3);
assert.strictEqual(a[0], 1);
assert.strictEqual(a[1], 2);
assert.strictEqual(a[2], 3);
let b: number[] = [];
b[10] = 1;
b[20] = 2;
b[30] = 3;
arrays.coalesceInPlace(b);
assert.equal(b.length, 3);
assert.equal(b[0], 1);
assert.equal(b[1], 2);
assert.equal(b[2], 3);
assert.strictEqual(b.length, 3);
assert.strictEqual(b[0], 1);
assert.strictEqual(b[1], 2);
assert.strictEqual(b[2], 3);
let sparse: number[] = [];
sparse[0] = 1;
@ -355,18 +355,18 @@ suite('Arrays', () => {
sparse[1000] = 1;
sparse[1001] = 1;
assert.equal(sparse.length, 1002);
assert.strictEqual(sparse.length, 1002);
arrays.coalesceInPlace(sparse);
assert.equal(sparse.length, 5);
assert.strictEqual(sparse.length, 5);
});
test('insert, remove', function () {
const array: string[] = [];
const remove = arrays.insert(array, 'foo');
assert.equal(array[0], 'foo');
assert.strictEqual(array[0], 'foo');
remove();
assert.equal(array.length, 0);
assert.strictEqual(array.length, 0);
});
});