cubetiq/code-server
1
0
Fork 0
Code Issues Pull Requests 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

211
lib/vscode/src/vs/base/test/common/async.test.ts
View File

@@ -18,7 +18,7 @@ suite('Async', () => {
return new Promise(resolve => { /*never*/ });
});
let result = promise.then(_ => assert.ok(false), err => {
assert.equal(canceled, 1);
assert.strictEqual(canceled, 1);
assert.ok(isPromiseCanceledError(err));
});
promise.cancel();
@@ -33,7 +33,7 @@ suite('Async', () => {
return Promise.resolve(1234);
});
let result = promise.then(_ => assert.ok(false), err => {
assert.equal(canceled, 1);
assert.strictEqual(canceled, 1);
assert.ok(isPromiseCanceledError(err));
});
promise.cancel();
@@ -60,7 +60,7 @@ suite('Async', () => {
cancellablePromise.cancel();
order.push('afterCancel');
return promise.then(() => assert.deepEqual(order, ['in callback', 'afterCreate', 'cancelled', 'afterCancel', 'finally']));
return promise.then(() => assert.deepStrictEqual(order, ['in callback', 'afterCreate', 'cancelled', 'afterCancel', 'finally']));
});
// Cancelling an async cancelable promise is just the same as a sync cancellable promise.
@@ -82,7 +82,7 @@ suite('Async', () => {
cancellablePromise.cancel();
order.push('afterCancel');
return promise.then(() => assert.deepEqual(order, ['in callback', 'afterCreate', 'cancelled', 'afterCancel', 'finally']));
return promise.then(() => assert.deepStrictEqual(order, ['in callback', 'afterCreate', 'cancelled', 'afterCancel', 'finally']));
});
test('cancelablePromise - get inner result', async function () {
@@ -91,7 +91,7 @@ suite('Async', () => {
});
let result = await promise;
assert.equal(result, 1234);
assert.strictEqual(result, 1234);
});
test('Throttler - non async', function () {
@@ -103,12 +103,12 @@ suite('Async', () => {
let throttler = new async.Throttler();
return Promise.all([
throttler.queue(factory).then((result) => { assert.equal(result, 1); }),
throttler.queue(factory).then((result) => { assert.equal(result, 2); }),
throttler.queue(factory).then((result) => { assert.equal(result, 2); }),
throttler.queue(factory).then((result) => { assert.equal(result, 2); }),
throttler.queue(factory).then((result) => { assert.equal(result, 2); })
]).then(() => assert.equal(count, 2));
throttler.queue(factory).then((result) => { assert.strictEqual(result, 1); }),
throttler.queue(factory).then((result) => { assert.strictEqual(result, 2); }),
throttler.queue(factory).then((result) => { assert.strictEqual(result, 2); }),
throttler.queue(factory).then((result) => { assert.strictEqual(result, 2); }),
throttler.queue(factory).then((result) => { assert.strictEqual(result, 2); })
]).then(() => assert.strictEqual(count, 2));
});
test('Throttler', () => {
@@ -118,18 +118,18 @@ suite('Async', () => {
let throttler = new async.Throttler();
return Promise.all([
throttler.queue(factory).then((result) => { assert.equal(result, 1); }),
throttler.queue(factory).then((result) => { assert.equal(result, 2); }),
throttler.queue(factory).then((result) => { assert.equal(result, 2); }),
throttler.queue(factory).then((result) => { assert.equal(result, 2); }),
throttler.queue(factory).then((result) => { assert.equal(result, 2); })
throttler.queue(factory).then((result) => { assert.strictEqual(result, 1); }),
throttler.queue(factory).then((result) => { assert.strictEqual(result, 2); }),
throttler.queue(factory).then((result) => { assert.strictEqual(result, 2); }),
throttler.queue(factory).then((result) => { assert.strictEqual(result, 2); }),
throttler.queue(factory).then((result) => { assert.strictEqual(result, 2); })
]).then(() => {
return Promise.all([
throttler.queue(factory).then((result) => { assert.equal(result, 3); }),
throttler.queue(factory).then((result) => { assert.equal(result, 4); }),
throttler.queue(factory).then((result) => { assert.equal(result, 4); }),
throttler.queue(factory).then((result) => { assert.equal(result, 4); }),
throttler.queue(factory).then((result) => { assert.equal(result, 4); })
throttler.queue(factory).then((result) => { assert.strictEqual(result, 3); }),
throttler.queue(factory).then((result) => { assert.strictEqual(result, 4); }),
throttler.queue(factory).then((result) => { assert.strictEqual(result, 4); }),
throttler.queue(factory).then((result) => { assert.strictEqual(result, 4); }),
throttler.queue(factory).then((result) => { assert.strictEqual(result, 4); })
]);
});
});
@@ -143,9 +143,9 @@ suite('Async', () => {
let promises: Promise<any>[] = [];
promises.push(throttler.queue(factoryFactory(1)).then((n) => { assert.equal(n, 1); }));
promises.push(throttler.queue(factoryFactory(2)).then((n) => { assert.equal(n, 3); }));
promises.push(throttler.queue(factoryFactory(3)).then((n) => { assert.equal(n, 3); }));
promises.push(throttler.queue(factoryFactory(1)).then((n) => { assert.strictEqual(n, 1); }));
promises.push(throttler.queue(factoryFactory(2)).then((n) => { assert.strictEqual(n, 3); }));
promises.push(throttler.queue(factoryFactory(3)).then((n) => { assert.strictEqual(n, 3); }));
return Promise.all(promises);
});
@@ -161,13 +161,13 @@ suite('Async', () => {
assert(!delayer.isTriggered());
promises.push(delayer.trigger(factory).then((result) => { assert.equal(result, 1); assert(!delayer.isTriggered()); }));
promises.push(delayer.trigger(factory).then((result) => { assert.strictEqual(result, 1); assert(!delayer.isTriggered()); }));
assert(delayer.isTriggered());
promises.push(delayer.trigger(factory).then((result) => { assert.equal(result, 1); assert(!delayer.isTriggered()); }));
promises.push(delayer.trigger(factory).then((result) => { assert.strictEqual(result, 1); assert(!delayer.isTriggered()); }));
assert(delayer.isTriggered());
promises.push(delayer.trigger(factory).then((result) => { assert.equal(result, 1); assert(!delayer.isTriggered()); }));
promises.push(delayer.trigger(factory).then((result) => { assert.strictEqual(result, 1); assert(!delayer.isTriggered()); }));
assert(delayer.isTriggered());
return Promise.all(promises).then(() => {
@@ -237,7 +237,7 @@ suite('Async', () => {
assert(!delayer.isTriggered());
const p = delayer.trigger(factory).then((result) => {
assert.equal(result, 1);
assert.strictEqual(result, 1);
assert(!delayer.isTriggered());
promises.push(delayer.trigger(factory).then(undefined, () => { assert(true, 'yes, it was cancelled'); }));
@@ -253,10 +253,10 @@ suite('Async', () => {
assert(!delayer.isTriggered());
promises.push(delayer.trigger(factory).then(() => { assert.equal(result, 1); assert(!delayer.isTriggered()); }));
promises.push(delayer.trigger(factory).then(() => { assert.strictEqual(result, 1); assert(!delayer.isTriggered()); }));
assert(delayer.isTriggered());
promises.push(delayer.trigger(factory).then(() => { assert.equal(result, 1); assert(!delayer.isTriggered()); }));
promises.push(delayer.trigger(factory).then(() => { assert.strictEqual(result, 1); assert(!delayer.isTriggered()); }));
assert(delayer.isTriggered());
const p = Promise.all(promises).then(() => {
@@ -286,9 +286,9 @@ suite('Async', () => {
assert(!delayer.isTriggered());
promises.push(delayer.trigger(factoryFactory(1)).then((n) => { assert.equal(n, 3); }));
promises.push(delayer.trigger(factoryFactory(2)).then((n) => { assert.equal(n, 3); }));
promises.push(delayer.trigger(factoryFactory(3)).then((n) => { assert.equal(n, 3); }));
promises.push(delayer.trigger(factoryFactory(1)).then((n) => { assert.strictEqual(n, 3); }));
promises.push(delayer.trigger(factoryFactory(2)).then((n) => { assert.strictEqual(n, 3); }));
promises.push(delayer.trigger(factoryFactory(3)).then((n) => { assert.strictEqual(n, 3); }));
const p = Promise.all(promises).then(() => {
assert(!delayer.isTriggered());
@@ -311,12 +311,12 @@ suite('Async', () => {
factoryFactory(4),
factoryFactory(5),
]).then((result) => {
assert.equal(5, result.length);
assert.equal(1, result[0]);
assert.equal(2, result[1]);
assert.equal(3, result[2]);
assert.equal(4, result[3]);
assert.equal(5, result[4]);
assert.strictEqual(5, result.length);
assert.strictEqual(1, result[0]);
assert.strictEqual(2, result[1]);
assert.strictEqual(3, result[2]);
assert.strictEqual(4, result[3]);
assert.strictEqual(5, result[4]);
});
});
@@ -331,7 +331,7 @@ suite('Async', () => {
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(n => promises.push(limiter.queue(factoryFactory(n))));
return Promise.all(promises).then((res) => {
assert.equal(10, res.length);
assert.strictEqual(10, res.length);
limiter = new async.Limiter(100);
@@ -339,7 +339,7 @@ suite('Async', () => {
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(n => promises.push(limiter.queue(factoryFactory(n))));
return Promise.all(promises).then((res) => {
assert.equal(10, res.length);
assert.strictEqual(10, res.length);
});
});
});
@@ -352,7 +352,7 @@ suite('Async', () => {
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(n => promises.push(limiter.queue(factoryFactory(n))));
return Promise.all(promises).then((res) => {
assert.equal(10, res.length);
assert.strictEqual(10, res.length);
limiter = new async.Limiter(100);
@@ -360,7 +360,7 @@ suite('Async', () => {
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(n => promises.push(limiter.queue(factoryFactory(n))));
return Promise.all(promises).then((res) => {
assert.equal(10, res.length);
assert.strictEqual(10, res.length);
});
});
});
@@ -379,8 +379,8 @@ suite('Async', () => {
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(n => promises.push(limiter.queue(factoryFactory(n))));
return Promise.all(promises).then((res) => {
assert.equal(10, res.length);
assert.deepEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], res);
assert.strictEqual(10, res.length);
assert.deepStrictEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], res);
});
});
@@ -393,15 +393,15 @@ suite('Async', () => {
let asyncPromise = false;
let f2 = () => async.timeout(10).then(() => asyncPromise = true);
assert.equal(queue.size, 0);
assert.strictEqual(queue.size, 0);
queue.queue(f1);
assert.equal(queue.size, 1);
assert.strictEqual(queue.size, 1);
const p = queue.queue(f2);
assert.equal(queue.size, 2);
assert.strictEqual(queue.size, 2);
return p.then(() => {
assert.equal(queue.size, 0);
assert.strictEqual(queue.size, 0);
assert.ok(syncPromise);
assert.ok(asyncPromise);
});
@@ -423,11 +423,11 @@ suite('Async', () => {
queue.queue(f3);
queue.queue(f4);
return queue.queue(f5).then(() => {
assert.equal(res[0], 1);
assert.equal(res[1], 2);
assert.equal(res[2], 3);
assert.equal(res[3], 4);
assert.equal(res[4], 5);
assert.strictEqual(res[0], 1);
assert.strictEqual(res[1], 2);
assert.strictEqual(res[2], 3);
assert.strictEqual(res[3], 4);
assert.strictEqual(res[4], 5);
});
});
@@ -448,11 +448,11 @@ suite('Async', () => {
queue.queue(f3).then(undefined, () => error = true);
queue.queue(f4);
return queue.queue(f5).then(() => {
assert.equal(res[0], 1);
assert.equal(res[1], 2);
assert.strictEqual(res[0], 1);
assert.strictEqual(res[1], 2);
assert.ok(error);
assert.equal(res[2], 4);
assert.equal(res[3], 5);
assert.strictEqual(res[2], 4);
assert.strictEqual(res[3], 5);
});
});
@@ -472,11 +472,11 @@ suite('Async', () => {
return queue.queue(f3).then(() => {
return queue.queue(f4).then(() => {
return queue.queue(f5).then(() => {
assert.equal(res[0], 1);
assert.equal(res[1], 2);
assert.equal(res[2], 3);
assert.equal(res[3], 4);
assert.equal(res[4], 5);
assert.strictEqual(res[0], 1);
assert.strictEqual(res[1], 2);
assert.strictEqual(res[2], 3);
assert.strictEqual(res[3], 4);
assert.strictEqual(res[4], 5);
});
});
});
@@ -521,7 +521,7 @@ suite('Async', () => {
assert.ok(r1Queue);
assert.ok(r2Queue);
assert.equal(r1Queue, queue.queueFor(URI.file('/some/path'))); // same queue returned
assert.strictEqual(r1Queue, queue.queueFor(URI.file('/some/path'))); // same queue returned
let syncPromiseFactory = () => Promise.resolve(undefined);
@@ -545,7 +545,7 @@ suite('Async', () => {
return Promise.resolve(true);
}, 10, 3);
assert.equal(res, true);
assert.strictEqual(res, true);
});
test('retry - error case', async () => {
@@ -555,7 +555,7 @@ suite('Async', () => {
return Promise.reject(expectedError);
}, 10, 3);
} catch (error) {
assert.equal(error, error);
assert.strictEqual(error, error);
}
});
@@ -576,12 +576,12 @@ suite('Async', () => {
sequentializer.setPending(2, async.timeout(1));
assert.ok(sequentializer.hasPending());
assert.ok(sequentializer.hasPending(2));
assert.ok(!sequentializer.hasPending(1));
assert.strictEqual(sequentializer.hasPending(1), false);
assert.ok(sequentializer.pending);
await async.timeout(2);
assert.ok(!sequentializer.hasPending());
assert.ok(!sequentializer.hasPending(2));
assert.strictEqual(sequentializer.hasPending(), false);
assert.strictEqual(sequentializer.hasPending(2), false);
assert.ok(!sequentializer.pending);
});
@@ -673,7 +673,7 @@ suite('Async', () => {
await p1;
assert.ok(!triggered);
assert.equal(timedout, true);
assert.strictEqual(timedout, true);
// promise wins
timedout = false;
@@ -684,38 +684,42 @@ suite('Async', () => {
await p2;
assert.ok(triggered);
assert.equal(timedout, false);
assert.strictEqual(timedout, false);
});
test('SequencerByKey', async () => {
const s = new async.SequencerByKey<string>();
const r1 = await s.queue('key1', () => Promise.resolve('hello'));
assert.equal(r1, 'hello');
assert.strictEqual(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');
assert.strictEqual(err.message, 'failed');
});
// Still works after a queued promise is rejected
const r3 = await s.queue('key2', () => Promise.resolve('hello'));
assert.equal(r3, 'hello');
assert.strictEqual(r3, 'hello');
});
test('IntervalCounter', async () => {
const counter = new async.IntervalCounter(10);
assert.equal(counter.increment(), 1);
assert.equal(counter.increment(), 2);
assert.equal(counter.increment(), 3);
assert.strictEqual(counter.increment(), 1);
assert.strictEqual(counter.increment(), 2);
assert.strictEqual(counter.increment(), 3);
const now = Date.now();
await async.timeout(20);
if (Date.now() - now < 11) {
return; // Firefox in Playwright seems to have a flaky timeout implementation (https://github.com/microsoft/vscode/issues/114028)
}
assert.equal(counter.increment(), 1);
assert.equal(counter.increment(), 2);
assert.equal(counter.increment(), 3);
assert.strictEqual(counter.increment(), 1);
assert.strictEqual(counter.increment(), 2);
assert.strictEqual(counter.increment(), 3);
});
test('firstParallel - simple', async () => {
@@ -724,19 +728,19 @@ suite('Async', () => {
Promise.resolve(2),
Promise.resolve(3),
], v => v === 2);
assert.equal(a, 2);
assert.strictEqual(a, 2);
});
test('firstParallel - uses null default', async () => {
assert.equal(await async.firstParallel([Promise.resolve(1)], v => v === 2), null);
assert.strictEqual(await async.firstParallel([Promise.resolve(1)], v => v === 2), null);
});
test('firstParallel - uses value default', async () => {
assert.equal(await async.firstParallel([Promise.resolve(1)], v => v === 2, 4), 4);
assert.strictEqual(await async.firstParallel([Promise.resolve(1)], v => v === 2, 4), 4);
});
test('firstParallel - empty', async () => {
assert.equal(await async.firstParallel([], v => v === 2, 4), 4);
assert.strictEqual(await async.firstParallel([], v => v === 2, 4), 4);
});
test('firstParallel - cancels', async () => {
@@ -753,9 +757,9 @@ suite('Async', () => {
return 2;
});
assert.equal(await async.firstParallel([p1, p2], v => v === 2, 4), 2);
assert.equal(ct1!.isCancellationRequested, true, 'should cancel a');
assert.equal(ct2!.isCancellationRequested, true, 'should cancel b');
assert.strictEqual(await async.firstParallel([p1, p2], v => v === 2, 4), 2);
assert.strictEqual(ct1!.isCancellationRequested, true, 'should cancel a');
assert.strictEqual(ct2!.isCancellationRequested, true, 'should cancel b');
});
test('firstParallel - rejection handling', async () => {
@@ -772,8 +776,35 @@ suite('Async', () => {
throw new Error('oh no');
});
assert.equal(await async.firstParallel([p1, p2], v => v === 2, 4).catch(() => 'ok'), 'ok');
assert.equal(ct1!.isCancellationRequested, true, 'should cancel a');
assert.equal(ct2!.isCancellationRequested, true, 'should cancel b');
assert.strictEqual(await async.firstParallel([p1, p2], v => v === 2, 4).catch(() => 'ok'), 'ok');
assert.strictEqual(ct1!.isCancellationRequested, true, 'should cancel a');
assert.strictEqual(ct2!.isCancellationRequested, true, 'should cancel b');
});
suite('DeferredPromise', () => {
test('resolves', async () => {
const deferred = new async.DeferredPromise<number>();
assert.strictEqual(deferred.isResolved, false);
deferred.complete(42);
assert.strictEqual(await deferred.p, 42);
assert.strictEqual(deferred.isResolved, true);
});
test('rejects', async () => {
const deferred = new async.DeferredPromise<number>();
assert.strictEqual(deferred.isRejected, false);
const err = new Error('oh no!');
deferred.error(err);
assert.strictEqual(await deferred.p.catch(e => e), err);
assert.strictEqual(deferred.isRejected, true);
});
test('cancels', async () => {
const deferred = new async.DeferredPromise<number>();
assert.strictEqual(deferred.isRejected, false);
deferred.cancel();
assert.strictEqual((await deferred.p.catch(e => e)).name, 'Canceled');
assert.strictEqual(deferred.isRejected, true);
});
});
});