TheLanc3/code-server
1
0
Fork 0
mirror of https://github.com/coder/code-server.git synced 2026-05-06 20:41:59 +02:00
Code Issues Packages Projects Releases Wiki 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

488
lib/vscode/src/vs/base/test/common/map.test.ts
View File

@@ -16,8 +16,8 @@ suite('Map', () => {
map.set('bk', 'bv');
assert.deepStrictEqual([...map.keys()], ['ak', 'bk']);
assert.deepStrictEqual([...map.values()], ['av', 'bv']);
assert.equal(map.first, 'av');
assert.equal(map.last, 'bv');
assert.strictEqual(map.first, 'av');
assert.strictEqual(map.last, 'bv');
});
test('LinkedMap - Touch Old one', () => {
@@ -77,7 +77,7 @@ suite('Map', () => {
test('LinkedMap - basics', function () {
const map = new LinkedMap<string, any>();
assert.equal(map.size, 0);
assert.strictEqual(map.size, 0);
map.set('1', 1);
map.set('2', '2');
@@ -89,23 +89,23 @@ suite('Map', () => {
const date = Date.now();
map.set('5', date);
assert.equal(map.size, 5);
assert.equal(map.get('1'), 1);
assert.equal(map.get('2'), '2');
assert.equal(map.get('3'), true);
assert.equal(map.get('4'), obj);
assert.equal(map.get('5'), date);
assert.strictEqual(map.size, 5);
assert.strictEqual(map.get('1'), 1);
assert.strictEqual(map.get('2'), '2');
assert.strictEqual(map.get('3'), true);
assert.strictEqual(map.get('4'), obj);
assert.strictEqual(map.get('5'), date);
assert.ok(!map.get('6'));
map.delete('6');
assert.equal(map.size, 5);
assert.equal(map.delete('1'), true);
assert.equal(map.delete('2'), true);
assert.equal(map.delete('3'), true);
assert.equal(map.delete('4'), true);
assert.equal(map.delete('5'), true);
assert.strictEqual(map.size, 5);
assert.strictEqual(map.delete('1'), true);
assert.strictEqual(map.delete('2'), true);
assert.strictEqual(map.delete('3'), true);
assert.strictEqual(map.delete('4'), true);
assert.strictEqual(map.delete('5'), true);
assert.equal(map.size, 0);
assert.strictEqual(map.size, 0);
assert.ok(!map.get('5'));
assert.ok(!map.get('4'));
assert.ok(!map.get('3'));
@@ -117,13 +117,13 @@ suite('Map', () => {
map.set('3', true);
assert.ok(map.has('1'));
assert.equal(map.get('1'), 1);
assert.equal(map.get('2'), '2');
assert.equal(map.get('3'), true);
assert.strictEqual(map.get('1'), 1);
assert.strictEqual(map.get('2'), '2');
assert.strictEqual(map.get('3'), true);
map.clear();
assert.equal(map.size, 0);
assert.strictEqual(map.size, 0);
assert.ok(!map.get('1'));
assert.ok(!map.get('2'));
assert.ok(!map.get('3'));
@@ -231,7 +231,7 @@ suite('Map', () => {
for (let i = 11; i <= 20; i++) {
cache.set(i, i);
}
assert.deepEqual(cache.size, 15);
assert.deepStrictEqual(cache.size, 15);
let values: number[] = [];
for (let i = 6; i <= 20; i++) {
values.push(cache.get(i)!);
@@ -269,14 +269,14 @@ suite('Map', () => {
let i = 0;
map.forEach((value, key) => {
if (i === 0) {
assert.equal(key, 'ak');
assert.equal(value, 'av');
assert.strictEqual(key, 'ak');
assert.strictEqual(value, 'av');
} else if (i === 1) {
assert.equal(key, 'bk');
assert.equal(value, 'bv');
assert.strictEqual(key, 'bk');
assert.strictEqual(value, 'bv');
} else if (i === 2) {
assert.equal(key, 'ck');
assert.equal(value, 'cv');
assert.strictEqual(key, 'ck');
assert.strictEqual(value, 'cv');
}
i++;
});
@@ -285,44 +285,44 @@ suite('Map', () => {
test('LinkedMap - delete Head and Tail', function () {
const map = new LinkedMap<string, number>();
assert.equal(map.size, 0);
assert.strictEqual(map.size, 0);
map.set('1', 1);
assert.equal(map.size, 1);
assert.strictEqual(map.size, 1);
map.delete('1');
assert.equal(map.get('1'), undefined);
assert.equal(map.size, 0);
assert.equal([...map.keys()].length, 0);
assert.strictEqual(map.get('1'), undefined);
assert.strictEqual(map.size, 0);
assert.strictEqual([...map.keys()].length, 0);
});
test('LinkedMap - delete Head', function () {
const map = new LinkedMap<string, number>();
assert.equal(map.size, 0);
assert.strictEqual(map.size, 0);
map.set('1', 1);
map.set('2', 2);
assert.equal(map.size, 2);
assert.strictEqual(map.size, 2);
map.delete('1');
assert.equal(map.get('2'), 2);
assert.equal(map.size, 1);
assert.equal([...map.keys()].length, 1);
assert.equal([...map.keys()][0], 2);
assert.strictEqual(map.get('2'), 2);
assert.strictEqual(map.size, 1);
assert.strictEqual([...map.keys()].length, 1);
assert.strictEqual([...map.keys()][0], '2');
});
test('LinkedMap - delete Tail', function () {
const map = new LinkedMap<string, number>();
assert.equal(map.size, 0);
assert.strictEqual(map.size, 0);
map.set('1', 1);
map.set('2', 2);
assert.equal(map.size, 2);
assert.strictEqual(map.size, 2);
map.delete('2');
assert.equal(map.get('1'), 1);
assert.equal(map.size, 1);
assert.equal([...map.keys()].length, 1);
assert.equal([...map.keys()][0], 1);
assert.strictEqual(map.get('1'), 1);
assert.strictEqual(map.size, 1);
assert.strictEqual([...map.keys()].length, 1);
assert.strictEqual([...map.keys()][0], '1');
});
@@ -330,100 +330,100 @@ suite('Map', () => {
const iter = new PathIterator();
iter.reset('file:///usr/bin/file.txt');
assert.equal(iter.value(), 'file:');
assert.equal(iter.hasNext(), true);
assert.equal(iter.cmp('file:'), 0);
assert.strictEqual(iter.value(), 'file:');
assert.strictEqual(iter.hasNext(), true);
assert.strictEqual(iter.cmp('file:'), 0);
assert.ok(iter.cmp('a') < 0);
assert.ok(iter.cmp('aile:') < 0);
assert.ok(iter.cmp('z') > 0);
assert.ok(iter.cmp('zile:') > 0);
iter.next();
assert.equal(iter.value(), 'usr');
assert.equal(iter.hasNext(), true);
assert.strictEqual(iter.value(), 'usr');
assert.strictEqual(iter.hasNext(), true);
iter.next();
assert.equal(iter.value(), 'bin');
assert.equal(iter.hasNext(), true);
assert.strictEqual(iter.value(), 'bin');
assert.strictEqual(iter.hasNext(), true);
iter.next();
assert.equal(iter.value(), 'file.txt');
assert.equal(iter.hasNext(), false);
assert.strictEqual(iter.value(), 'file.txt');
assert.strictEqual(iter.hasNext(), false);
iter.next();
assert.equal(iter.value(), '');
assert.equal(iter.hasNext(), false);
assert.strictEqual(iter.value(), '');
assert.strictEqual(iter.hasNext(), false);
iter.next();
assert.equal(iter.value(), '');
assert.equal(iter.hasNext(), false);
assert.strictEqual(iter.value(), '');
assert.strictEqual(iter.hasNext(), false);
//
iter.reset('/foo/bar/');
assert.equal(iter.value(), 'foo');
assert.equal(iter.hasNext(), true);
assert.strictEqual(iter.value(), 'foo');
assert.strictEqual(iter.hasNext(), true);
iter.next();
assert.equal(iter.value(), 'bar');
assert.equal(iter.hasNext(), false);
assert.strictEqual(iter.value(), 'bar');
assert.strictEqual(iter.hasNext(), false);
});
test('URIIterator', function () {
const iter = new UriIterator(() => false);
iter.reset(URI.parse('file:///usr/bin/file.txt'));
assert.equal(iter.value(), 'file');
// assert.equal(iter.cmp('FILE'), 0);
assert.equal(iter.cmp('file'), 0);
assert.equal(iter.hasNext(), true);
assert.strictEqual(iter.value(), 'file');
// assert.strictEqual(iter.cmp('FILE'), 0);
assert.strictEqual(iter.cmp('file'), 0);
assert.strictEqual(iter.hasNext(), true);
iter.next();
assert.equal(iter.value(), 'usr');
assert.equal(iter.hasNext(), true);
assert.strictEqual(iter.value(), 'usr');
assert.strictEqual(iter.hasNext(), true);
iter.next();
assert.equal(iter.value(), 'bin');
assert.equal(iter.hasNext(), true);
assert.strictEqual(iter.value(), 'bin');
assert.strictEqual(iter.hasNext(), true);
iter.next();
assert.equal(iter.value(), 'file.txt');
assert.equal(iter.hasNext(), false);
assert.strictEqual(iter.value(), 'file.txt');
assert.strictEqual(iter.hasNext(), false);
iter.reset(URI.parse('file://share/usr/bin/file.txt?foo'));
// scheme
assert.equal(iter.value(), 'file');
// assert.equal(iter.cmp('FILE'), 0);
assert.equal(iter.cmp('file'), 0);
assert.equal(iter.hasNext(), true);
assert.strictEqual(iter.value(), 'file');
// assert.strictEqual(iter.cmp('FILE'), 0);
assert.strictEqual(iter.cmp('file'), 0);
assert.strictEqual(iter.hasNext(), true);
iter.next();
// authority
assert.equal(iter.value(), 'share');
assert.equal(iter.cmp('SHARe'), 0);
assert.equal(iter.hasNext(), true);
assert.strictEqual(iter.value(), 'share');
assert.strictEqual(iter.cmp('SHARe'), 0);
assert.strictEqual(iter.hasNext(), true);
iter.next();
// path
assert.equal(iter.value(), 'usr');
assert.equal(iter.hasNext(), true);
assert.strictEqual(iter.value(), 'usr');
assert.strictEqual(iter.hasNext(), true);
iter.next();
// path
assert.equal(iter.value(), 'bin');
assert.equal(iter.hasNext(), true);
assert.strictEqual(iter.value(), 'bin');
assert.strictEqual(iter.hasNext(), true);
iter.next();
// path
assert.equal(iter.value(), 'file.txt');
assert.equal(iter.hasNext(), true);
assert.strictEqual(iter.value(), 'file.txt');
assert.strictEqual(iter.hasNext(), true);
iter.next();
// query
assert.equal(iter.value(), 'foo');
assert.equal(iter.cmp('z') > 0, true);
assert.equal(iter.cmp('a') < 0, true);
assert.equal(iter.hasNext(), false);
assert.strictEqual(iter.value(), 'foo');
assert.strictEqual(iter.cmp('z') > 0, true);
assert.strictEqual(iter.cmp('a') < 0, true);
assert.strictEqual(iter.hasNext(), false);
});
function assertTernarySearchTree<E>(trie: TernarySearchTree<string, E>, ...elements: [string, E][]) {
@@ -432,24 +432,24 @@ suite('Map', () => {
map.set(key, value);
}
map.forEach((value, key) => {
assert.equal(trie.get(key), value);
assert.strictEqual(trie.get(key), value);
});
// forEach
let forEachCount = 0;
trie.forEach((element, key) => {
assert.equal(element, map.get(key));
assert.strictEqual(element, map.get(key));
forEachCount++;
});
assert.equal(map.size, forEachCount);
assert.strictEqual(map.size, forEachCount);
// iterator
let iterCount = 0;
for (let [key, value] of trie) {
assert.equal(value, map.get(key));
assert.strictEqual(value, map.get(key));
iterCount++;
}
assert.equal(map.size, iterCount);
assert.strictEqual(map.size, iterCount);
}
test('TernarySearchTree - set', function () {
@@ -493,13 +493,13 @@ suite('Map', () => {
trie.set('foobar', 2);
trie.set('foobaz', 3);
assert.equal(trie.findSubstr('f'), undefined);
assert.equal(trie.findSubstr('z'), undefined);
assert.equal(trie.findSubstr('foo'), 1);
assert.equal(trie.findSubstr('fooö'), 1);
assert.equal(trie.findSubstr('fooba'), 1);
assert.equal(trie.findSubstr('foobarr'), 2);
assert.equal(trie.findSubstr('foobazrr'), 3);
assert.strictEqual(trie.findSubstr('f'), undefined);
assert.strictEqual(trie.findSubstr('z'), undefined);
assert.strictEqual(trie.findSubstr('foo'), 1);
assert.strictEqual(trie.findSubstr('fooö'), 1);
assert.strictEqual(trie.findSubstr('fooba'), 1);
assert.strictEqual(trie.findSubstr('foobarr'), 2);
assert.strictEqual(trie.findSubstr('foobazrr'), 3);
});
test('TernarySearchTree - basics', function () {
@@ -509,27 +509,27 @@ suite('Map', () => {
trie.set('bar', 2);
trie.set('foobar', 3);
assert.equal(trie.get('foo'), 1);
assert.equal(trie.get('bar'), 2);
assert.equal(trie.get('foobar'), 3);
assert.equal(trie.get('foobaz'), undefined);
assert.equal(trie.get('foobarr'), undefined);
assert.strictEqual(trie.get('foo'), 1);
assert.strictEqual(trie.get('bar'), 2);
assert.strictEqual(trie.get('foobar'), 3);
assert.strictEqual(trie.get('foobaz'), undefined);
assert.strictEqual(trie.get('foobarr'), undefined);
assert.equal(trie.findSubstr('fo'), undefined);
assert.equal(trie.findSubstr('foo'), 1);
assert.equal(trie.findSubstr('foooo'), 1);
assert.strictEqual(trie.findSubstr('fo'), undefined);
assert.strictEqual(trie.findSubstr('foo'), 1);
assert.strictEqual(trie.findSubstr('foooo'), 1);
trie.delete('foobar');
trie.delete('bar');
assert.equal(trie.get('foobar'), undefined);
assert.equal(trie.get('bar'), undefined);
assert.strictEqual(trie.get('foobar'), undefined);
assert.strictEqual(trie.get('bar'), undefined);
trie.set('foobar', 17);
trie.set('barr', 18);
assert.equal(trie.get('foobar'), 17);
assert.equal(trie.get('barr'), 18);
assert.equal(trie.get('bar'), undefined);
assert.strictEqual(trie.get('foobar'), 17);
assert.strictEqual(trie.get('barr'), 18);
assert.strictEqual(trie.get('bar'), undefined);
});
test('TernarySearchTree - delete & cleanup', function () {
@@ -576,20 +576,20 @@ suite('Map', () => {
trie.set('/user/foo', 2);
trie.set('/user/foo/flip/flop', 3);
assert.equal(trie.get('/user/foo/bar'), 1);
assert.equal(trie.get('/user/foo'), 2);
assert.equal(trie.get('/user//foo'), 2);
assert.equal(trie.get('/user\\foo'), 2);
assert.equal(trie.get('/user/foo/flip/flop'), 3);
assert.strictEqual(trie.get('/user/foo/bar'), 1);
assert.strictEqual(trie.get('/user/foo'), 2);
assert.strictEqual(trie.get('/user//foo'), 2);
assert.strictEqual(trie.get('/user\\foo'), 2);
assert.strictEqual(trie.get('/user/foo/flip/flop'), 3);
assert.equal(trie.findSubstr('/user/bar'), undefined);
assert.equal(trie.findSubstr('/user/foo'), 2);
assert.equal(trie.findSubstr('\\user\\foo'), 2);
assert.equal(trie.findSubstr('/user//foo'), 2);
assert.equal(trie.findSubstr('/user/foo/ba'), 2);
assert.equal(trie.findSubstr('/user/foo/far/boo'), 2);
assert.equal(trie.findSubstr('/user/foo/bar'), 1);
assert.equal(trie.findSubstr('/user/foo/bar/far/boo'), 1);
assert.strictEqual(trie.findSubstr('/user/bar'), undefined);
assert.strictEqual(trie.findSubstr('/user/foo'), 2);
assert.strictEqual(trie.findSubstr('\\user\\foo'), 2);
assert.strictEqual(trie.findSubstr('/user//foo'), 2);
assert.strictEqual(trie.findSubstr('/user/foo/ba'), 2);
assert.strictEqual(trie.findSubstr('/user/foo/far/boo'), 2);
assert.strictEqual(trie.findSubstr('/user/foo/bar'), 1);
assert.strictEqual(trie.findSubstr('/user/foo/bar/far/boo'), 1);
});
test('TernarySearchTree (PathSegments) - lookup', function () {
@@ -599,11 +599,11 @@ suite('Map', () => {
map.set('/user/foo', 2);
map.set('/user/foo/flip/flop', 3);
assert.equal(map.get('/foo'), undefined);
assert.equal(map.get('/user'), undefined);
assert.equal(map.get('/user/foo'), 2);
assert.equal(map.get('/user/foo/bar'), 1);
assert.equal(map.get('/user/foo/bar/boo'), undefined);
assert.strictEqual(map.get('/foo'), undefined);
assert.strictEqual(map.get('/user'), undefined);
assert.strictEqual(map.get('/user/foo'), 2);
assert.strictEqual(map.get('/user/foo/bar'), 1);
assert.strictEqual(map.get('/user/foo/bar/boo'), undefined);
});
test('TernarySearchTree (PathSegments) - superstr', function () {
@@ -618,31 +618,31 @@ suite('Map', () => {
let iter = map.findSuperstr('/user');
item = iter!.next();
assert.equal(item.value[1], 2);
assert.equal(item.done, false);
assert.strictEqual(item.value[1], 2);
assert.strictEqual(item.done, false);
item = iter!.next();
assert.equal(item.value[1], 1);
assert.equal(item.done, false);
assert.strictEqual(item.value[1], 1);
assert.strictEqual(item.done, false);
item = iter!.next();
assert.equal(item.value[1], 3);
assert.equal(item.done, false);
assert.strictEqual(item.value[1], 3);
assert.strictEqual(item.done, false);
item = iter!.next();
assert.equal(item.value, undefined);
assert.equal(item.done, true);
assert.strictEqual(item.value, undefined);
assert.strictEqual(item.done, true);
iter = map.findSuperstr('/usr');
item = iter!.next();
assert.equal(item.value[1], 4);
assert.equal(item.done, false);
assert.strictEqual(item.value[1], 4);
assert.strictEqual(item.done, false);
item = iter!.next();
assert.equal(item.value, undefined);
assert.equal(item.done, true);
assert.strictEqual(item.value, undefined);
assert.strictEqual(item.done, true);
assert.equal(map.findSuperstr('/not'), undefined);
assert.equal(map.findSuperstr('/us'), undefined);
assert.equal(map.findSuperstr('/usrr'), undefined);
assert.equal(map.findSuperstr('/userr'), undefined);
assert.strictEqual(map.findSuperstr('/not'), undefined);
assert.strictEqual(map.findSuperstr('/us'), undefined);
assert.strictEqual(map.findSuperstr('/usrr'), undefined);
assert.strictEqual(map.findSuperstr('/userr'), undefined);
});
@@ -688,16 +688,16 @@ suite('Map', () => {
trie.set(URI.file('/user/foo'), 2);
trie.set(URI.file('/user/foo/flip/flop'), 3);
assert.equal(trie.get(URI.file('/user/foo/bar')), 1);
assert.equal(trie.get(URI.file('/user/foo')), 2);
assert.equal(trie.get(URI.file('/user/foo/flip/flop')), 3);
assert.strictEqual(trie.get(URI.file('/user/foo/bar')), 1);
assert.strictEqual(trie.get(URI.file('/user/foo')), 2);
assert.strictEqual(trie.get(URI.file('/user/foo/flip/flop')), 3);
assert.equal(trie.findSubstr(URI.file('/user/bar')), undefined);
assert.equal(trie.findSubstr(URI.file('/user/foo')), 2);
assert.equal(trie.findSubstr(URI.file('/user/foo/ba')), 2);
assert.equal(trie.findSubstr(URI.file('/user/foo/far/boo')), 2);
assert.equal(trie.findSubstr(URI.file('/user/foo/bar')), 1);
assert.equal(trie.findSubstr(URI.file('/user/foo/bar/far/boo')), 1);
assert.strictEqual(trie.findSubstr(URI.file('/user/bar')), undefined);
assert.strictEqual(trie.findSubstr(URI.file('/user/foo')), 2);
assert.strictEqual(trie.findSubstr(URI.file('/user/foo/ba')), 2);
assert.strictEqual(trie.findSubstr(URI.file('/user/foo/far/boo')), 2);
assert.strictEqual(trie.findSubstr(URI.file('/user/foo/bar')), 1);
assert.strictEqual(trie.findSubstr(URI.file('/user/foo/bar/far/boo')), 1);
});
test('TernarySearchTree (URI) - lookup', function () {
@@ -708,23 +708,23 @@ suite('Map', () => {
map.set(URI.parse('http://foo.bar/user/foo?QUERY'), 3);
map.set(URI.parse('http://foo.bar/user/foo/flip/flop'), 3);
assert.equal(map.get(URI.parse('http://foo.bar/foo')), undefined);
assert.equal(map.get(URI.parse('http://foo.bar/user')), undefined);
assert.equal(map.get(URI.parse('http://foo.bar/user/foo/bar')), 1);
assert.equal(map.get(URI.parse('http://foo.bar/user/foo?query')), 2);
assert.equal(map.get(URI.parse('http://foo.bar/user/foo?Query')), undefined);
assert.equal(map.get(URI.parse('http://foo.bar/user/foo?QUERY')), 3);
assert.equal(map.get(URI.parse('http://foo.bar/user/foo/bar/boo')), undefined);
assert.strictEqual(map.get(URI.parse('http://foo.bar/foo')), undefined);
assert.strictEqual(map.get(URI.parse('http://foo.bar/user')), undefined);
assert.strictEqual(map.get(URI.parse('http://foo.bar/user/foo/bar')), 1);
assert.strictEqual(map.get(URI.parse('http://foo.bar/user/foo?query')), 2);
assert.strictEqual(map.get(URI.parse('http://foo.bar/user/foo?Query')), undefined);
assert.strictEqual(map.get(URI.parse('http://foo.bar/user/foo?QUERY')), 3);
assert.strictEqual(map.get(URI.parse('http://foo.bar/user/foo/bar/boo')), undefined);
});
test('TernarySearchTree (URI) - lookup, casing', function () {
const map = new TernarySearchTree<URI, number>(new UriIterator(uri => /^https?$/.test(uri.scheme)));
map.set(URI.parse('http://foo.bar/user/foo/bar'), 1);
assert.equal(map.get(URI.parse('http://foo.bar/USER/foo/bar')), 1);
assert.strictEqual(map.get(URI.parse('http://foo.bar/USER/foo/bar')), 1);
map.set(URI.parse('foo://foo.bar/user/foo/bar'), 1);
assert.equal(map.get(URI.parse('foo://foo.bar/USER/foo/bar')), undefined);
assert.strictEqual(map.get(URI.parse('foo://foo.bar/USER/foo/bar')), undefined);
});
test('TernarySearchTree (URI) - superstr', function () {
@@ -739,48 +739,48 @@ suite('Map', () => {
let iter = map.findSuperstr(URI.file('/user'))!;
item = iter.next();
assert.equal(item.value[1], 2);
assert.equal(item.done, false);
assert.strictEqual(item.value[1], 2);
assert.strictEqual(item.done, false);
item = iter.next();
assert.equal(item.value[1], 1);
assert.equal(item.done, false);
assert.strictEqual(item.value[1], 1);
assert.strictEqual(item.done, false);
item = iter.next();
assert.equal(item.value[1], 3);
assert.equal(item.done, false);
assert.strictEqual(item.value[1], 3);
assert.strictEqual(item.done, false);
item = iter.next();
assert.equal(item.value, undefined);
assert.equal(item.done, true);
assert.strictEqual(item.value, undefined);
assert.strictEqual(item.done, true);
iter = map.findSuperstr(URI.file('/usr'))!;
item = iter.next();
assert.equal(item.value[1], 4);
assert.equal(item.done, false);
assert.strictEqual(item.value[1], 4);
assert.strictEqual(item.done, false);
item = iter.next();
assert.equal(item.value, undefined);
assert.equal(item.done, true);
assert.strictEqual(item.value, undefined);
assert.strictEqual(item.done, true);
iter = map.findSuperstr(URI.file('/'))!;
item = iter.next();
assert.equal(item.value[1], 2);
assert.equal(item.done, false);
assert.strictEqual(item.value[1], 2);
assert.strictEqual(item.done, false);
item = iter.next();
assert.equal(item.value[1], 1);
assert.equal(item.done, false);
assert.strictEqual(item.value[1], 1);
assert.strictEqual(item.done, false);
item = iter.next();
assert.equal(item.value[1], 3);
assert.equal(item.done, false);
assert.strictEqual(item.value[1], 3);
assert.strictEqual(item.done, false);
item = iter.next();
assert.equal(item.value[1], 4);
assert.equal(item.done, false);
assert.strictEqual(item.value[1], 4);
assert.strictEqual(item.done, false);
item = iter.next();
assert.equal(item.value, undefined);
assert.equal(item.done, true);
assert.strictEqual(item.value, undefined);
assert.strictEqual(item.done, true);
assert.equal(map.findSuperstr(URI.file('/not')), undefined);
assert.equal(map.findSuperstr(URI.file('/us')), undefined);
assert.equal(map.findSuperstr(URI.file('/usrr')), undefined);
assert.equal(map.findSuperstr(URI.file('/userr')), undefined);
assert.strictEqual(map.findSuperstr(URI.file('/not')), undefined);
assert.strictEqual(map.findSuperstr(URI.file('/us')), undefined);
assert.strictEqual(map.findSuperstr(URI.file('/usrr')), undefined);
assert.strictEqual(map.findSuperstr(URI.file('/userr')), undefined);
});
test('TernarySearchTree (ConfigKeySegments) - basics', function () {
@@ -790,16 +790,16 @@ suite('Map', () => {
trie.set('config.foo', 2);
trie.set('config.foo.flip.flop', 3);
assert.equal(trie.get('config.foo.bar'), 1);
assert.equal(trie.get('config.foo'), 2);
assert.equal(trie.get('config.foo.flip.flop'), 3);
assert.strictEqual(trie.get('config.foo.bar'), 1);
assert.strictEqual(trie.get('config.foo'), 2);
assert.strictEqual(trie.get('config.foo.flip.flop'), 3);
assert.equal(trie.findSubstr('config.bar'), undefined);
assert.equal(trie.findSubstr('config.foo'), 2);
assert.equal(trie.findSubstr('config.foo.ba'), 2);
assert.equal(trie.findSubstr('config.foo.far.boo'), 2);
assert.equal(trie.findSubstr('config.foo.bar'), 1);
assert.equal(trie.findSubstr('config.foo.bar.far.boo'), 1);
assert.strictEqual(trie.findSubstr('config.bar'), undefined);
assert.strictEqual(trie.findSubstr('config.foo'), 2);
assert.strictEqual(trie.findSubstr('config.foo.ba'), 2);
assert.strictEqual(trie.findSubstr('config.foo.far.boo'), 2);
assert.strictEqual(trie.findSubstr('config.foo.bar'), 1);
assert.strictEqual(trie.findSubstr('config.foo.bar.far.boo'), 1);
});
test('TernarySearchTree (ConfigKeySegments) - lookup', function () {
@@ -809,11 +809,11 @@ suite('Map', () => {
map.set('config.foo', 2);
map.set('config.foo.flip.flop', 3);
assert.equal(map.get('foo'), undefined);
assert.equal(map.get('config'), undefined);
assert.equal(map.get('config.foo'), 2);
assert.equal(map.get('config.foo.bar'), 1);
assert.equal(map.get('config.foo.bar.boo'), undefined);
assert.strictEqual(map.get('foo'), undefined);
assert.strictEqual(map.get('config'), undefined);
assert.strictEqual(map.get('config.foo'), 2);
assert.strictEqual(map.get('config.foo.bar'), 1);
assert.strictEqual(map.get('config.foo.bar.boo'), undefined);
});
test('TernarySearchTree (ConfigKeySegments) - superstr', function () {
@@ -828,21 +828,21 @@ suite('Map', () => {
let iter = map.findSuperstr('config');
item = iter!.next();
assert.equal(item.value[1], 2);
assert.equal(item.done, false);
assert.strictEqual(item.value[1], 2);
assert.strictEqual(item.done, false);
item = iter!.next();
assert.equal(item.value[1], 1);
assert.equal(item.done, false);
assert.strictEqual(item.value[1], 1);
assert.strictEqual(item.done, false);
item = iter!.next();
assert.equal(item.value[1], 3);
assert.equal(item.done, false);
assert.strictEqual(item.value[1], 3);
assert.strictEqual(item.done, false);
item = iter!.next();
assert.equal(item.value, undefined);
assert.equal(item.done, true);
assert.strictEqual(item.value, undefined);
assert.strictEqual(item.done, true);
assert.equal(map.findSuperstr('foo'), undefined);
assert.equal(map.findSuperstr('config.foo.no'), undefined);
assert.equal(map.findSuperstr('config.foop'), undefined);
assert.strictEqual(map.findSuperstr('foo'), undefined);
assert.strictEqual(map.findSuperstr('config.foo.no'), undefined);
assert.strictEqual(map.findSuperstr('config.foop'), undefined);
});
@@ -891,7 +891,7 @@ suite('Map', () => {
const resource5 = URI.parse('some://5');
const resource6 = URI.parse('some://6');
assert.equal(map.size, 0);
assert.strictEqual(map.size, 0);
let res = map.set(resource1, 1);
assert.ok(res === map);
@@ -899,13 +899,13 @@ suite('Map', () => {
map.set(resource3, true);
const values = [...map.values()];
assert.equal(values[0], 1);
assert.equal(values[1], '2');
assert.equal(values[2], true);
assert.strictEqual(values[0], 1);
assert.strictEqual(values[1], '2');
assert.strictEqual(values[2], true);
let counter = 0;
map.forEach((value, key, mapObj) => {
assert.equal(value, values[counter++]);
assert.strictEqual(value, values[counter++]);
assert.ok(URI.isUri(key));
assert.ok(map === mapObj);
});
@@ -916,23 +916,23 @@ suite('Map', () => {
const date = Date.now();
map.set(resource5, date);
assert.equal(map.size, 5);
assert.equal(map.get(resource1), 1);
assert.equal(map.get(resource2), '2');
assert.equal(map.get(resource3), true);
assert.equal(map.get(resource4), obj);
assert.equal(map.get(resource5), date);
assert.strictEqual(map.size, 5);
assert.strictEqual(map.get(resource1), 1);
assert.strictEqual(map.get(resource2), '2');
assert.strictEqual(map.get(resource3), true);
assert.strictEqual(map.get(resource4), obj);
assert.strictEqual(map.get(resource5), date);
assert.ok(!map.get(resource6));
map.delete(resource6);
assert.equal(map.size, 5);
assert.strictEqual(map.size, 5);
assert.ok(map.delete(resource1));
assert.ok(map.delete(resource2));
assert.ok(map.delete(resource3));
assert.ok(map.delete(resource4));
assert.ok(map.delete(resource5));
assert.equal(map.size, 0);
assert.strictEqual(map.size, 0);
assert.ok(!map.get(resource5));
assert.ok(!map.get(resource4));
assert.ok(!map.get(resource3));
@@ -944,13 +944,13 @@ suite('Map', () => {
map.set(resource3, true);
assert.ok(map.has(resource1));
assert.equal(map.get(resource1), 1);
assert.equal(map.get(resource2), '2');
assert.equal(map.get(resource3), true);
assert.strictEqual(map.get(resource1), 1);
assert.strictEqual(map.get(resource2), '2');
assert.strictEqual(map.get(resource3), true);
map.clear();
assert.equal(map.size, 0);
assert.strictEqual(map.size, 0);
assert.ok(!map.get(resource1));
assert.ok(!map.get(resource2));
assert.ok(!map.get(resource3));
@@ -971,16 +971,16 @@ suite('Map', () => {
const fileAUpper = URI.parse('file://SOME/FILEA');
map.set(fileA, 'true');
assert.equal(map.get(fileA), 'true');
assert.strictEqual(map.get(fileA), 'true');
assert.ok(!map.get(fileAUpper));
assert.ok(!map.get(fileB));
map.set(fileAUpper, 'false');
assert.equal(map.get(fileAUpper), 'false');
assert.strictEqual(map.get(fileAUpper), 'false');
assert.equal(map.get(fileA), 'true');
assert.strictEqual(map.get(fileA), 'true');
const windowsFile = URI.file('c:\\test with %25\\c#code');
const uncFile = URI.file('\\\\shäres\\path\\c#\\plugin.json');
@@ -988,8 +988,8 @@ suite('Map', () => {
map.set(windowsFile, 'true');
map.set(uncFile, 'true');
assert.equal(map.get(windowsFile), 'true');
assert.equal(map.get(uncFile), 'true');
assert.strictEqual(map.get(windowsFile), 'true');
assert.strictEqual(map.get(uncFile), 'true');
});
test('ResourceMap - files (ignorecase)', function () {
@@ -1000,16 +1000,16 @@ suite('Map', () => {
const fileAUpper = URI.parse('file://SOME/FILEA');
map.set(fileA, 'true');
assert.equal(map.get(fileA), 'true');
assert.strictEqual(map.get(fileA), 'true');
assert.equal(map.get(fileAUpper), 'true');
assert.strictEqual(map.get(fileAUpper), 'true');
assert.ok(!map.get(fileB));
map.set(fileAUpper, 'false');
assert.equal(map.get(fileAUpper), 'false');
assert.strictEqual(map.get(fileAUpper), 'false');
assert.equal(map.get(fileA), 'false');
assert.strictEqual(map.get(fileA), 'false');
const windowsFile = URI.file('c:\\test with %25\\c#code');
const uncFile = URI.file('\\\\shäres\\path\\c#\\plugin.json');
@@ -1017,7 +1017,7 @@ suite('Map', () => {
map.set(windowsFile, 'true');
map.set(uncFile, 'true');
assert.equal(map.get(windowsFile), 'true');
assert.equal(map.get(uncFile), 'true');
assert.strictEqual(map.get(windowsFile), 'true');
assert.strictEqual(map.get(uncFile), 'true');
});
});