diff --git a/src/vs/base/parts/ipc/test/browser/ipc.mp.test.ts b/src/vs/base/parts/ipc/test/browser/ipc.mp.test.ts index 765c4291e2619f79dcce53c5f0322819a3237793..86e03184adb8bc510a445136750726dfedd598df 100644 --- a/src/vs/base/parts/ipc/test/browser/ipc.mp.test.ts +++ b/src/vs/base/parts/ipc/test/browser/ipc.mp.test.ts @@ -47,10 +47,10 @@ suite('IPC, MessagePorts', () => { }); const channelClient1 = client2.getChannel('client1'); - assert.equal(await channelClient1.call('testMethodClient1'), 'success1'); + assert.strictEqual(await channelClient1.call('testMethodClient1'), 'success1'); const channelClient2 = client1.getChannel('client2'); - assert.equal(await channelClient2.call('testMethodClient2'), 'success2'); + assert.strictEqual(await channelClient2.call('testMethodClient2'), 'success2'); client1.dispose(); client2.dispose(); diff --git a/src/vs/base/parts/storage/test/node/storage.test.ts b/src/vs/base/parts/storage/test/node/storage.test.ts index 0f085331a7a229bd4fb7292732c4575b474035f9..00ffc9799da361ed2eac029cc6adc8d7c54055fd 100644 --- a/src/vs/base/parts/storage/test/node/storage.test.ts +++ b/src/vs/base/parts/storage/test/node/storage.test.ts @@ -7,7 +7,7 @@ import { SQLiteStorageDatabase, ISQLiteStorageDatabaseOptions } from 'vs/base/pa import { Storage, IStorageDatabase, IStorageItemsChangeEvent } from 'vs/base/parts/storage/common/storage'; import { join } from 'vs/base/common/path'; import { tmpdir } from 'os'; -import { equal, ok } from 'assert'; +import { strictEqual, ok } from 'assert'; import { mkdirp, writeFile, exists, unlink, rimraf } from 'vs/base/node/pfs'; import { timeout } from 'vs/base/common/async'; import { Event, Emitter } from 'vs/base/common/event'; @@ -35,9 +35,9 @@ flakySuite('Storage Library', function () { await storage.init(); // Empty fallbacks - equal(storage.get('foo', 'bar'), 'bar'); - equal(storage.getNumber('foo', 55), 55); - equal(storage.getBoolean('foo', true), true); + strictEqual(storage.get('foo', 'bar'), 'bar'); + strictEqual(storage.getNumber('foo', 55), 55); + strictEqual(storage.getBoolean('foo', true), true); let changes = new Set(); storage.onDidChangeStorage(key => { @@ -54,19 +54,19 @@ flakySuite('Storage Library', function () { let flushPromiseResolved = false; storage.whenFlushed().then(() => flushPromiseResolved = true); - equal(storage.get('bar'), 'foo'); - equal(storage.getNumber('barNumber'), 55); - equal(storage.getBoolean('barBoolean'), true); + strictEqual(storage.get('bar'), 'foo'); + strictEqual(storage.getNumber('barNumber'), 55); + strictEqual(storage.getBoolean('barBoolean'), true); - equal(changes.size, 3); + strictEqual(changes.size, 3); ok(changes.has('bar')); ok(changes.has('barNumber')); ok(changes.has('barBoolean')); let setPromiseResolved = false; await Promise.all([set1Promise, set2Promise, set3Promise]).then(() => setPromiseResolved = true); - equal(setPromiseResolved, true); - equal(flushPromiseResolved, true); + strictEqual(setPromiseResolved, true); + strictEqual(flushPromiseResolved, true); changes = new Set(); @@ -74,7 +74,7 @@ flakySuite('Storage Library', function () { storage.set('bar', 'foo'); storage.set('barNumber', 55); storage.set('barBoolean', true); - equal(changes.size, 0); + strictEqual(changes.size, 0); // Simple deletes const delete1Promise = storage.delete('bar'); @@ -85,7 +85,7 @@ flakySuite('Storage Library', function () { ok(!storage.getNumber('barNumber')); ok(!storage.getBoolean('barBoolean')); - equal(changes.size, 3); + strictEqual(changes.size, 3); ok(changes.has('bar')); ok(changes.has('barNumber')); ok(changes.has('barBoolean')); @@ -96,11 +96,11 @@ flakySuite('Storage Library', function () { storage.delete('bar'); storage.delete('barNumber'); storage.delete('barBoolean'); - equal(changes.size, 0); + strictEqual(changes.size, 0); let deletePromiseResolved = false; await Promise.all([delete1Promise, delete2Promise, delete3Promise]).then(() => deletePromiseResolved = true); - equal(deletePromiseResolved, true); + strictEqual(deletePromiseResolved, true); await storage.close(); }); @@ -134,25 +134,25 @@ flakySuite('Storage Library', function () { const changed = new Map(); changed.set('foo', 'bar'); database.fireDidChangeItemsExternal({ changed }); - equal(changes.size, 0); + strictEqual(changes.size, 0); // Change is accepted if valid changed.set('foo', 'bar1'); database.fireDidChangeItemsExternal({ changed }); ok(changes.has('foo')); - equal(storage.get('foo'), 'bar1'); + strictEqual(storage.get('foo'), 'bar1'); changes.clear(); // Delete is accepted const deleted = new Set(['foo']); database.fireDidChangeItemsExternal({ deleted }); ok(changes.has('foo')); - equal(storage.get('foo', undefined), undefined); + strictEqual(storage.get('foo', undefined), undefined); changes.clear(); // Nothing happens if changing to same value database.fireDidChangeItemsExternal({ deleted }); - equal(changes.size, 0); + strictEqual(changes.size, 0); await storage.close(); }); @@ -167,22 +167,22 @@ flakySuite('Storage Library', function () { let flushPromiseResolved = false; storage.whenFlushed().then(() => flushPromiseResolved = true); - equal(storage.get('foo'), 'bar'); - equal(storage.get('bar'), 'foo'); + strictEqual(storage.get('foo'), 'bar'); + strictEqual(storage.get('bar'), 'foo'); let setPromiseResolved = false; Promise.all([set1Promise, set2Promise]).then(() => setPromiseResolved = true); await storage.close(); - equal(setPromiseResolved, true); - equal(flushPromiseResolved, true); + strictEqual(setPromiseResolved, true); + strictEqual(flushPromiseResolved, true); storage = new Storage(new SQLiteStorageDatabase(join(storageDir, 'storage.db'))); await storage.init(); - equal(storage.get('foo'), 'bar'); - equal(storage.get('bar'), 'foo'); + strictEqual(storage.get('foo'), 'bar'); + strictEqual(storage.get('bar'), 'foo'); await storage.close(); @@ -200,7 +200,7 @@ flakySuite('Storage Library', function () { await storage.close(); - equal(deletePromiseResolved, true); + strictEqual(deletePromiseResolved, true); storage = new Storage(new SQLiteStorageDatabase(join(storageDir, 'storage.db'))); await storage.init(); @@ -227,8 +227,8 @@ flakySuite('Storage Library', function () { let flushPromiseResolved = false; storage.whenFlushed().then(() => flushPromiseResolved = true); - equal(storage.get('foo'), 'bar3'); - equal(changes.size, 1); + strictEqual(storage.get('foo'), 'bar3'); + strictEqual(changes.size, 1); ok(changes.has('foo')); let setPromiseResolved = false; @@ -243,7 +243,7 @@ flakySuite('Storage Library', function () { ok(!storage.get('bar')); - equal(changes.size, 1); + strictEqual(changes.size, 1); ok(changes.has('bar')); let setAndDeletePromiseResolved = false; @@ -265,16 +265,16 @@ flakySuite('Storage Library', function () { await storage.set('foo', 'bar'); - equal(storage.get('bar'), 'foo'); - equal(storage.get('foo'), 'bar'); + strictEqual(storage.get('bar'), 'foo'); + strictEqual(storage.get('foo'), 'bar'); await storage.close(); storage = new Storage(new SQLiteStorageDatabase(storageFile)); await storage.init(); - equal(storage.get('bar'), 'foo'); - equal(storage.get('foo'), 'bar'); + strictEqual(storage.get('bar'), 'foo'); + strictEqual(storage.get('foo'), 'bar'); await storage.close(); }); @@ -319,49 +319,49 @@ flakySuite('SQLite Storage Library', function () { items.set(JSON.stringify({ foo: 'bar' }), JSON.stringify({ bar: 'foo' })); let storedItems = await storage.getItems(); - equal(storedItems.size, 0); + strictEqual(storedItems.size, 0); await storage.updateItems({ insert: items }); storedItems = await storage.getItems(); - equal(storedItems.size, items.size); - equal(storedItems.get('foo'), 'bar'); - equal(storedItems.get('some/foo/path'), 'some/bar/path'); - equal(storedItems.get(JSON.stringify({ foo: 'bar' })), JSON.stringify({ bar: 'foo' })); + strictEqual(storedItems.size, items.size); + strictEqual(storedItems.get('foo'), 'bar'); + strictEqual(storedItems.get('some/foo/path'), 'some/bar/path'); + strictEqual(storedItems.get(JSON.stringify({ foo: 'bar' })), JSON.stringify({ bar: 'foo' })); await storage.updateItems({ delete: toSet(['foo']) }); storedItems = await storage.getItems(); - equal(storedItems.size, items.size - 1); + strictEqual(storedItems.size, items.size - 1); ok(!storedItems.has('foo')); - equal(storedItems.get('some/foo/path'), 'some/bar/path'); - equal(storedItems.get(JSON.stringify({ foo: 'bar' })), JSON.stringify({ bar: 'foo' })); + strictEqual(storedItems.get('some/foo/path'), 'some/bar/path'); + strictEqual(storedItems.get(JSON.stringify({ foo: 'bar' })), JSON.stringify({ bar: 'foo' })); await storage.updateItems({ insert: items }); storedItems = await storage.getItems(); - equal(storedItems.size, items.size); - equal(storedItems.get('foo'), 'bar'); - equal(storedItems.get('some/foo/path'), 'some/bar/path'); - equal(storedItems.get(JSON.stringify({ foo: 'bar' })), JSON.stringify({ bar: 'foo' })); + strictEqual(storedItems.size, items.size); + strictEqual(storedItems.get('foo'), 'bar'); + strictEqual(storedItems.get('some/foo/path'), 'some/bar/path'); + strictEqual(storedItems.get(JSON.stringify({ foo: 'bar' })), JSON.stringify({ bar: 'foo' })); const itemsChange = new Map(); itemsChange.set('foo', 'otherbar'); await storage.updateItems({ insert: itemsChange }); storedItems = await storage.getItems(); - equal(storedItems.get('foo'), 'otherbar'); + strictEqual(storedItems.get('foo'), 'otherbar'); await storage.updateItems({ delete: toSet(['foo', 'bar', 'some/foo/path', JSON.stringify({ foo: 'bar' })]) }); storedItems = await storage.getItems(); - equal(storedItems.size, 0); + strictEqual(storedItems.size, 0); await storage.updateItems({ insert: items, delete: toSet(['foo', 'some/foo/path', 'other']) }); storedItems = await storage.getItems(); - equal(storedItems.size, 1); - equal(storedItems.get(JSON.stringify({ foo: 'bar' })), JSON.stringify({ bar: 'foo' })); + strictEqual(storedItems.size, 1); + strictEqual(storedItems.get(JSON.stringify({ foo: 'bar' })), JSON.stringify({ bar: 'foo' })); await storage.updateItems({ delete: toSet([JSON.stringify({ foo: 'bar' })]) }); storedItems = await storage.getItems(); - equal(storedItems.size, 0); + strictEqual(storedItems.size, 0); let recoveryCalled = false; await storage.close(() => { @@ -370,7 +370,7 @@ flakySuite('SQLite Storage Library', function () { return new Map(); }); - equal(recoveryCalled, false); + strictEqual(recoveryCalled, false); } test('basics', async () => { @@ -411,10 +411,10 @@ flakySuite('SQLite Storage Library', function () { storage = new SQLiteStorageDatabase(storagePath); const storedItems = await storage.getItems(); - equal(storedItems.size, items.size); - equal(storedItems.get('foo'), 'bar'); - equal(storedItems.get('some/foo/path'), 'some/bar/path'); - equal(storedItems.get(JSON.stringify({ foo: 'bar' })), JSON.stringify({ bar: 'foo' })); + strictEqual(storedItems.size, items.size); + strictEqual(storedItems.get('foo'), 'bar'); + strictEqual(storedItems.get('some/foo/path'), 'some/bar/path'); + strictEqual(storedItems.get(JSON.stringify({ foo: 'bar' })), JSON.stringify({ bar: 'foo' })); let recoveryCalled = false; await storage.close(() => { @@ -423,7 +423,7 @@ flakySuite('SQLite Storage Library', function () { return new Map(); }); - equal(recoveryCalled, false); + strictEqual(recoveryCalled, false); }); test('basics (corrupt DB falls back to empty DB if backup is corrupt)', async () => { @@ -444,7 +444,7 @@ flakySuite('SQLite Storage Library', function () { storage = new SQLiteStorageDatabase(storagePath); const storedItems = await storage.getItems(); - equal(storedItems.size, 0); + strictEqual(storedItems.size, 0); await testDBBasics(storagePath); }); @@ -462,7 +462,7 @@ flakySuite('SQLite Storage Library', function () { await storage.close(); const backupPath = `${storagePath}.backup`; - equal(await exists(backupPath), true); + strictEqual(await exists(backupPath), true); storage = new SQLiteStorageDatabase(storagePath); await storage.getItems(); @@ -484,16 +484,16 @@ flakySuite('SQLite Storage Library', function () { return items; }); - equal(recoveryCalled, true); - equal(await exists(backupPath), true); + strictEqual(recoveryCalled, true); + strictEqual(await exists(backupPath), true); storage = new SQLiteStorageDatabase(storagePath); const storedItems = await storage.getItems(); - equal(storedItems.size, items.size); - equal(storedItems.get('foo'), 'bar'); - equal(storedItems.get('some/foo/path'), 'some/bar/path'); - equal(storedItems.get(JSON.stringify({ foo: 'bar' })), JSON.stringify({ bar: 'foo' })); + strictEqual(storedItems.size, items.size); + strictEqual(storedItems.get('foo'), 'bar'); + strictEqual(storedItems.get('some/foo/path'), 'some/bar/path'); + strictEqual(storedItems.get(JSON.stringify({ foo: 'bar' })), JSON.stringify({ bar: 'foo' })); recoveryCalled = false; await storage.close(() => { @@ -502,7 +502,7 @@ flakySuite('SQLite Storage Library', function () { return new Map(); }); - equal(recoveryCalled, false); + strictEqual(recoveryCalled, false); }); test('real world example', async function () { @@ -525,7 +525,7 @@ flakySuite('SQLite Storage Library', function () { items3.set('very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.very.long.key.', 'is long'); let storedItems = await storage.getItems(); - equal(storedItems.size, 0); + strictEqual(storedItems.size, 0); await Promise.all([ await storage.updateItems({ insert: items1 }), @@ -533,28 +533,28 @@ flakySuite('SQLite Storage Library', function () { await storage.updateItems({ insert: items3 }) ]); - equal(await storage.checkIntegrity(true), 'ok'); - equal(await storage.checkIntegrity(false), 'ok'); + strictEqual(await storage.checkIntegrity(true), 'ok'); + strictEqual(await storage.checkIntegrity(false), 'ok'); storedItems = await storage.getItems(); - equal(storedItems.size, items1.size + items2.size + items3.size); + strictEqual(storedItems.size, items1.size + items2.size + items3.size); const items1Keys: string[] = []; items1.forEach((value, key) => { items1Keys.push(key); - equal(storedItems.get(key), value); + strictEqual(storedItems.get(key), value); }); const items2Keys: string[] = []; items2.forEach((value, key) => { items2Keys.push(key); - equal(storedItems.get(key), value); + strictEqual(storedItems.get(key), value); }); const items3Keys: string[] = []; items3.forEach((value, key) => { items3Keys.push(key); - equal(storedItems.get(key), value); + strictEqual(storedItems.get(key), value); }); await Promise.all([ @@ -564,7 +564,7 @@ flakySuite('SQLite Storage Library', function () { ]); storedItems = await storage.getItems(); - equal(storedItems.size, 0); + strictEqual(storedItems.size, 0); await Promise.all([ await storage.updateItems({ insert: items1 }), @@ -576,14 +576,14 @@ flakySuite('SQLite Storage Library', function () { ]); storedItems = await storage.getItems(); - equal(storedItems.size, items1.size + items2.size + items3.size); + strictEqual(storedItems.size, items1.size + items2.size + items3.size); await storage.close(); storage = new SQLiteStorageDatabase(join(storageDir, 'storage.db')); storedItems = await storage.getItems(); - equal(storedItems.size, items1.size + items2.size + items3.size); + strictEqual(storedItems.size, items1.size + items2.size + items3.size); await storage.close(); }); @@ -605,9 +605,9 @@ flakySuite('SQLite Storage Library', function () { await storage.updateItems({ insert: items }); let storedItems = await storage.getItems(); - equal(items.get('colorthemedata'), storedItems.get('colorthemedata')); - equal(items.get('commandpalette.mru.cache'), storedItems.get('commandpalette.mru.cache')); - equal(items.get('super.large.string'), storedItems.get('super.large.string')); + strictEqual(items.get('colorthemedata'), storedItems.get('colorthemedata')); + strictEqual(items.get('commandpalette.mru.cache'), storedItems.get('commandpalette.mru.cache')); + strictEqual(items.get('super.large.string'), storedItems.get('super.large.string')); uuid = generateUuid(); value = []; @@ -619,17 +619,17 @@ flakySuite('SQLite Storage Library', function () { await storage.updateItems({ insert: items }); storedItems = await storage.getItems(); - equal(items.get('colorthemedata'), storedItems.get('colorthemedata')); - equal(items.get('commandpalette.mru.cache'), storedItems.get('commandpalette.mru.cache')); - equal(items.get('super.large.string'), storedItems.get('super.large.string')); + strictEqual(items.get('colorthemedata'), storedItems.get('colorthemedata')); + strictEqual(items.get('commandpalette.mru.cache'), storedItems.get('commandpalette.mru.cache')); + strictEqual(items.get('super.large.string'), storedItems.get('super.large.string')); const toDelete = new Set(); toDelete.add('super.large.string'); await storage.updateItems({ delete: toDelete }); storedItems = await storage.getItems(); - equal(items.get('colorthemedata'), storedItems.get('colorthemedata')); - equal(items.get('commandpalette.mru.cache'), storedItems.get('commandpalette.mru.cache')); + strictEqual(items.get('colorthemedata'), storedItems.get('colorthemedata')); + strictEqual(items.get('commandpalette.mru.cache'), storedItems.get('commandpalette.mru.cache')); ok(!storedItems.get('super.large.string')); await storage.close(); @@ -676,14 +676,14 @@ flakySuite('SQLite Storage Library', function () { await storage.set('some/foo3/path', 'some/bar/path'); const items = await storage.getStorage().getItems(); - equal(items.get('foo'), 'bar'); - equal(items.get('some/foo/path'), 'some/bar/path'); - equal(items.has('foo1'), false); - equal(items.has('some/foo1/path'), false); - equal(items.get('foo2'), 'bar'); - equal(items.get('some/foo2/path'), 'some/bar/path'); - equal(items.get('foo3'), 'bar'); - equal(items.get('some/foo3/path'), 'some/bar/path'); + strictEqual(items.get('foo'), 'bar'); + strictEqual(items.get('some/foo/path'), 'some/bar/path'); + strictEqual(items.has('foo1'), false); + strictEqual(items.has('some/foo1/path'), false); + strictEqual(items.get('foo2'), 'bar'); + strictEqual(items.get('some/foo2/path'), 'some/bar/path'); + strictEqual(items.get('foo3'), 'bar'); + strictEqual(items.get('some/foo3/path'), 'some/bar/path'); await storage.close(); }); @@ -704,12 +704,12 @@ flakySuite('SQLite Storage Library', function () { await storage.updateItems({ insert: items }); let storedItems = await storage.getItems(); - equal(storedItems.size, items.size); + strictEqual(storedItems.size, items.size); await storage.updateItems({ delete: keys }); storedItems = await storage.getItems(); - equal(storedItems.size, 0); + strictEqual(storedItems.size, 0); await storage.close(); }); @@ -730,12 +730,12 @@ flakySuite('SQLite Storage Library', function () { await storage.updateItems({ insert: items }); let storedItems = await storage.getItems(); - equal(storedItems.size, items.size); + strictEqual(storedItems.size, items.size); await storage.updateItems({ delete: keys }); storedItems = await storage.getItems(); - equal(storedItems.size, 0); + strictEqual(storedItems.size, 0); await storage.close(); }); diff --git a/src/vs/base/test/browser/actionbar.test.ts b/src/vs/base/test/browser/actionbar.test.ts index 049c4d48bb31100dd27e4986e2d6a80590054867..0fb8338d3eb327fbb0e64a67947f0868107160e2 100644 --- a/src/vs/base/test/browser/actionbar.test.ts +++ b/src/vs/base/test/browser/actionbar.test.ts @@ -33,28 +33,28 @@ suite('Actionbar', () => { let a2 = new Action('a2'); actionbar.push(a1); - assert.equal(actionbar.hasAction(a1), true); - assert.equal(actionbar.hasAction(a2), false); + assert.strictEqual(actionbar.hasAction(a1), true); + assert.strictEqual(actionbar.hasAction(a2), false); actionbar.pull(0); - assert.equal(actionbar.hasAction(a1), false); + assert.strictEqual(actionbar.hasAction(a1), false); actionbar.push(a1, { index: 1 }); actionbar.push(a2, { index: 0 }); - assert.equal(actionbar.hasAction(a1), true); - assert.equal(actionbar.hasAction(a2), true); + assert.strictEqual(actionbar.hasAction(a1), true); + assert.strictEqual(actionbar.hasAction(a2), true); actionbar.pull(0); - assert.equal(actionbar.hasAction(a1), true); - assert.equal(actionbar.hasAction(a2), false); + assert.strictEqual(actionbar.hasAction(a1), true); + assert.strictEqual(actionbar.hasAction(a2), false); actionbar.pull(0); - assert.equal(actionbar.hasAction(a1), false); - assert.equal(actionbar.hasAction(a2), false); + assert.strictEqual(actionbar.hasAction(a1), false); + assert.strictEqual(actionbar.hasAction(a2), false); actionbar.push(a1); - assert.equal(actionbar.hasAction(a1), true); + assert.strictEqual(actionbar.hasAction(a1), true); actionbar.clear(); - assert.equal(actionbar.hasAction(a1), false); + assert.strictEqual(actionbar.hasAction(a1), false); }); }); diff --git a/src/vs/base/test/browser/comparers.test.ts b/src/vs/base/test/browser/comparers.test.ts index 8adcb5d51410306b52e469255610923e4ac345b8..5f85f7bed348a894ea4b9ead3e3d9f97c36698c6 100644 --- a/src/vs/base/test/browser/comparers.test.ts +++ b/src/vs/base/test/browser/comparers.test.ts @@ -123,8 +123,8 @@ suite('Comparers', () => { // name-only comparisions assert(compareFileExtensions('a', 'A') !== compareLocale('a', 'A'), 'the same letter of different case does not sort by locale'); assert(compareFileExtensions('â', 'Â') !== compareLocale('â', 'Â'), 'the same accented letter of different case does not sort by locale'); - assert.notDeepEqual(['artichoke', 'Artichoke', 'art', 'Art'].sort(compareFileExtensions), ['artichoke', 'Artichoke', 'art', 'Art'].sort(compareLocale), 'words with the same root and different cases do not sort in locale order'); - assert.notDeepEqual(['email', 'Email', 'émail', 'Émail'].sort(compareFileExtensions), ['email', 'Email', 'émail', 'Émail'].sort((a, b) => a.localeCompare(b)), 'the same base characters with different case or accents do not sort in locale order'); + assert.notDeepStrictEqual(['artichoke', 'Artichoke', 'art', 'Art'].sort(compareFileExtensions), ['artichoke', 'Artichoke', 'art', 'Art'].sort(compareLocale), 'words with the same root and different cases do not sort in locale order'); + assert.notDeepStrictEqual(['email', 'Email', 'émail', 'Émail'].sort(compareFileExtensions), ['email', 'Email', 'émail', 'Émail'].sort((a, b) => a.localeCompare(b)), 'the same base characters with different case or accents do not sort in locale order'); // name plus extension comparisons assert(compareFileExtensions('a.MD', 'a.md') !== compareLocale('MD', 'md'), 'case differences in extensions do not sort by locale'); @@ -197,7 +197,7 @@ suite('Comparers', () => { // name-only comparisons assert(compareFileNamesDefault('a', 'A') === compareLocale('a', 'A'), 'the same letter sorts by locale'); assert(compareFileNamesDefault('â', 'Â') === compareLocale('â', 'Â'), 'the same accented letter sorts by locale'); - assert.deepEqual(['email', 'Email', 'émail', 'Émail'].sort(compareFileNamesDefault), ['email', 'Email', 'émail', 'Émail'].sort(compareLocale), 'the same base characters with different case or accents sort in locale order'); + assert.deepStrictEqual(['email', 'Email', 'émail', 'Émail'].sort(compareFileNamesDefault), ['email', 'Email', 'émail', 'Émail'].sort(compareLocale), 'the same base characters with different case or accents sort in locale order'); // numeric comparisons assert(compareFileNamesDefault('abc02.txt', 'abc002.txt') < 0, 'filenames with equivalent numbers and leading zeros sort shortest number first'); @@ -258,7 +258,7 @@ suite('Comparers', () => { // name-only comparisons assert(compareFileExtensionsDefault('a', 'A') === compareLocale('a', 'A'), 'the same letter of different case sorts by locale'); assert(compareFileExtensionsDefault('â', 'Â') === compareLocale('â', 'Â'), 'the same accented letter of different case sorts by locale'); - assert.deepEqual(['email', 'Email', 'émail', 'Émail'].sort(compareFileExtensionsDefault), ['email', 'Email', 'émail', 'Émail'].sort((a, b) => a.localeCompare(b)), 'the same base characters with different case or accents sort in locale order'); + assert.deepStrictEqual(['email', 'Email', 'émail', 'Émail'].sort(compareFileExtensionsDefault), ['email', 'Email', 'émail', 'Émail'].sort((a, b) => a.localeCompare(b)), 'the same base characters with different case or accents sort in locale order'); // name plus extension comparisons assert(compareFileExtensionsDefault('a.MD', 'a.md') === compareLocale('MD', 'md'), 'case differences in extensions sort by locale'); diff --git a/src/vs/base/test/common/extpath.test.ts b/src/vs/base/test/common/extpath.test.ts index 26e5f98f5880252c483c30648dbee3887883bdcd..b05be8d83224dbd5a3750b75ef170883ee0665e1 100644 --- a/src/vs/base/test/common/extpath.test.ts +++ b/src/vs/base/test/common/extpath.test.ts @@ -11,25 +11,25 @@ import { CharCode } from 'vs/base/common/charCode'; suite('Paths', () => { test('toForwardSlashes', () => { - assert.equal(extpath.toSlashes('\\\\server\\share\\some\\path'), '//server/share/some/path'); - assert.equal(extpath.toSlashes('c:\\test'), 'c:/test'); - assert.equal(extpath.toSlashes('foo\\bar'), 'foo/bar'); - assert.equal(extpath.toSlashes('/user/far'), '/user/far'); + assert.strictEqual(extpath.toSlashes('\\\\server\\share\\some\\path'), '//server/share/some/path'); + assert.strictEqual(extpath.toSlashes('c:\\test'), 'c:/test'); + assert.strictEqual(extpath.toSlashes('foo\\bar'), 'foo/bar'); + assert.strictEqual(extpath.toSlashes('/user/far'), '/user/far'); }); test('getRoot', () => { - assert.equal(extpath.getRoot('/user/far'), '/'); - assert.equal(extpath.getRoot('\\\\server\\share\\some\\path'), '//server/share/'); - assert.equal(extpath.getRoot('//server/share/some/path'), '//server/share/'); - assert.equal(extpath.getRoot('//server/share'), '/'); - assert.equal(extpath.getRoot('//server'), '/'); - assert.equal(extpath.getRoot('//server//'), '/'); - assert.equal(extpath.getRoot('c:/user/far'), 'c:/'); - assert.equal(extpath.getRoot('c:user/far'), 'c:'); - assert.equal(extpath.getRoot('http://www'), ''); - assert.equal(extpath.getRoot('http://www/'), 'http://www/'); - assert.equal(extpath.getRoot('file:///foo'), 'file:///'); - assert.equal(extpath.getRoot('file://foo'), ''); + assert.strictEqual(extpath.getRoot('/user/far'), '/'); + assert.strictEqual(extpath.getRoot('\\\\server\\share\\some\\path'), '//server/share/'); + assert.strictEqual(extpath.getRoot('//server/share/some/path'), '//server/share/'); + assert.strictEqual(extpath.getRoot('//server/share'), '/'); + assert.strictEqual(extpath.getRoot('//server'), '/'); + assert.strictEqual(extpath.getRoot('//server//'), '/'); + assert.strictEqual(extpath.getRoot('c:/user/far'), 'c:/'); + assert.strictEqual(extpath.getRoot('c:user/far'), 'c:'); + assert.strictEqual(extpath.getRoot('http://www'), ''); + assert.strictEqual(extpath.getRoot('http://www/'), 'http://www/'); + assert.strictEqual(extpath.getRoot('file:///foo'), 'file:///'); + assert.strictEqual(extpath.getRoot('file://foo'), ''); }); (!platform.isWindows ? test.skip : test)('isUNC', () => { @@ -73,37 +73,37 @@ suite('Paths', () => { test('sanitizeFilePath', () => { if (platform.isWindows) { - assert.equal(extpath.sanitizeFilePath('.', 'C:\\the\\cwd'), 'C:\\the\\cwd'); - assert.equal(extpath.sanitizeFilePath('', 'C:\\the\\cwd'), 'C:\\the\\cwd'); + assert.strictEqual(extpath.sanitizeFilePath('.', 'C:\\the\\cwd'), 'C:\\the\\cwd'); + assert.strictEqual(extpath.sanitizeFilePath('', 'C:\\the\\cwd'), 'C:\\the\\cwd'); - assert.equal(extpath.sanitizeFilePath('C:', 'C:\\the\\cwd'), 'C:\\'); - assert.equal(extpath.sanitizeFilePath('C:\\', 'C:\\the\\cwd'), 'C:\\'); - assert.equal(extpath.sanitizeFilePath('C:\\\\', 'C:\\the\\cwd'), 'C:\\'); + assert.strictEqual(extpath.sanitizeFilePath('C:', 'C:\\the\\cwd'), 'C:\\'); + assert.strictEqual(extpath.sanitizeFilePath('C:\\', 'C:\\the\\cwd'), 'C:\\'); + assert.strictEqual(extpath.sanitizeFilePath('C:\\\\', 'C:\\the\\cwd'), 'C:\\'); - assert.equal(extpath.sanitizeFilePath('C:\\folder\\my.txt', 'C:\\the\\cwd'), 'C:\\folder\\my.txt'); - assert.equal(extpath.sanitizeFilePath('C:\\folder\\my', 'C:\\the\\cwd'), 'C:\\folder\\my'); - assert.equal(extpath.sanitizeFilePath('C:\\folder\\..\\my', 'C:\\the\\cwd'), 'C:\\my'); - assert.equal(extpath.sanitizeFilePath('C:\\folder\\my\\', 'C:\\the\\cwd'), 'C:\\folder\\my'); - assert.equal(extpath.sanitizeFilePath('C:\\folder\\my\\\\\\', 'C:\\the\\cwd'), 'C:\\folder\\my'); + assert.strictEqual(extpath.sanitizeFilePath('C:\\folder\\my.txt', 'C:\\the\\cwd'), 'C:\\folder\\my.txt'); + assert.strictEqual(extpath.sanitizeFilePath('C:\\folder\\my', 'C:\\the\\cwd'), 'C:\\folder\\my'); + assert.strictEqual(extpath.sanitizeFilePath('C:\\folder\\..\\my', 'C:\\the\\cwd'), 'C:\\my'); + assert.strictEqual(extpath.sanitizeFilePath('C:\\folder\\my\\', 'C:\\the\\cwd'), 'C:\\folder\\my'); + assert.strictEqual(extpath.sanitizeFilePath('C:\\folder\\my\\\\\\', 'C:\\the\\cwd'), 'C:\\folder\\my'); - assert.equal(extpath.sanitizeFilePath('my.txt', 'C:\\the\\cwd'), 'C:\\the\\cwd\\my.txt'); - assert.equal(extpath.sanitizeFilePath('my.txt\\', 'C:\\the\\cwd'), 'C:\\the\\cwd\\my.txt'); + assert.strictEqual(extpath.sanitizeFilePath('my.txt', 'C:\\the\\cwd'), 'C:\\the\\cwd\\my.txt'); + assert.strictEqual(extpath.sanitizeFilePath('my.txt\\', 'C:\\the\\cwd'), 'C:\\the\\cwd\\my.txt'); - assert.equal(extpath.sanitizeFilePath('\\\\localhost\\folder\\my', 'C:\\the\\cwd'), '\\\\localhost\\folder\\my'); - assert.equal(extpath.sanitizeFilePath('\\\\localhost\\folder\\my\\', 'C:\\the\\cwd'), '\\\\localhost\\folder\\my'); + assert.strictEqual(extpath.sanitizeFilePath('\\\\localhost\\folder\\my', 'C:\\the\\cwd'), '\\\\localhost\\folder\\my'); + assert.strictEqual(extpath.sanitizeFilePath('\\\\localhost\\folder\\my\\', 'C:\\the\\cwd'), '\\\\localhost\\folder\\my'); } else { - assert.equal(extpath.sanitizeFilePath('.', '/the/cwd'), '/the/cwd'); - assert.equal(extpath.sanitizeFilePath('', '/the/cwd'), '/the/cwd'); - assert.equal(extpath.sanitizeFilePath('/', '/the/cwd'), '/'); - - assert.equal(extpath.sanitizeFilePath('/folder/my.txt', '/the/cwd'), '/folder/my.txt'); - assert.equal(extpath.sanitizeFilePath('/folder/my', '/the/cwd'), '/folder/my'); - assert.equal(extpath.sanitizeFilePath('/folder/../my', '/the/cwd'), '/my'); - assert.equal(extpath.sanitizeFilePath('/folder/my/', '/the/cwd'), '/folder/my'); - assert.equal(extpath.sanitizeFilePath('/folder/my///', '/the/cwd'), '/folder/my'); - - assert.equal(extpath.sanitizeFilePath('my.txt', '/the/cwd'), '/the/cwd/my.txt'); - assert.equal(extpath.sanitizeFilePath('my.txt/', '/the/cwd'), '/the/cwd/my.txt'); + assert.strictEqual(extpath.sanitizeFilePath('.', '/the/cwd'), '/the/cwd'); + assert.strictEqual(extpath.sanitizeFilePath('', '/the/cwd'), '/the/cwd'); + assert.strictEqual(extpath.sanitizeFilePath('/', '/the/cwd'), '/'); + + assert.strictEqual(extpath.sanitizeFilePath('/folder/my.txt', '/the/cwd'), '/folder/my.txt'); + assert.strictEqual(extpath.sanitizeFilePath('/folder/my', '/the/cwd'), '/folder/my'); + assert.strictEqual(extpath.sanitizeFilePath('/folder/../my', '/the/cwd'), '/my'); + assert.strictEqual(extpath.sanitizeFilePath('/folder/my/', '/the/cwd'), '/folder/my'); + assert.strictEqual(extpath.sanitizeFilePath('/folder/my///', '/the/cwd'), '/folder/my'); + + assert.strictEqual(extpath.sanitizeFilePath('my.txt', '/the/cwd'), '/the/cwd/my.txt'); + assert.strictEqual(extpath.sanitizeFilePath('my.txt/', '/the/cwd'), '/the/cwd/my.txt'); } }); @@ -137,12 +137,12 @@ suite('Paths', () => { test('getDriveLetter', () => { if (platform.isWindows) { - assert.equal(extpath.getDriveLetter('c:'), 'c'); - assert.equal(extpath.getDriveLetter('D:'), 'D'); - assert.equal(extpath.getDriveLetter('D:/'), 'D'); - assert.equal(extpath.getDriveLetter('D:\\'), 'D'); - assert.equal(extpath.getDriveLetter('D:\\path'), 'D'); - assert.equal(extpath.getDriveLetter('D:/path'), 'D'); + assert.strictEqual(extpath.getDriveLetter('c:'), 'c'); + assert.strictEqual(extpath.getDriveLetter('D:'), 'D'); + assert.strictEqual(extpath.getDriveLetter('D:/'), 'D'); + assert.strictEqual(extpath.getDriveLetter('D:\\'), 'D'); + assert.strictEqual(extpath.getDriveLetter('D:\\path'), 'D'); + assert.strictEqual(extpath.getDriveLetter('D:/path'), 'D'); } else { assert.ok(!extpath.getDriveLetter('/')); assert.ok(!extpath.getDriveLetter('/path')); @@ -157,47 +157,47 @@ suite('Paths', () => { }); test('indexOfPath', () => { - assert.equal(extpath.indexOfPath('/foo', '/bar', true), -1); - assert.equal(extpath.indexOfPath('/foo', '/FOO', false), -1); - assert.equal(extpath.indexOfPath('/foo', '/FOO', true), 0); - assert.equal(extpath.indexOfPath('/some/long/path', '/some/long', false), 0); - assert.equal(extpath.indexOfPath('/some/long/path', '/PATH', true), 10); + assert.strictEqual(extpath.indexOfPath('/foo', '/bar', true), -1); + assert.strictEqual(extpath.indexOfPath('/foo', '/FOO', false), -1); + assert.strictEqual(extpath.indexOfPath('/foo', '/FOO', true), 0); + assert.strictEqual(extpath.indexOfPath('/some/long/path', '/some/long', false), 0); + assert.strictEqual(extpath.indexOfPath('/some/long/path', '/PATH', true), 10); }); test('parseLineAndColumnAware', () => { let res = extpath.parseLineAndColumnAware('/foo/bar'); - assert.equal(res.path, '/foo/bar'); - assert.equal(res.line, undefined); - assert.equal(res.column, undefined); + assert.strictEqual(res.path, '/foo/bar'); + assert.strictEqual(res.line, undefined); + assert.strictEqual(res.column, undefined); res = extpath.parseLineAndColumnAware('/foo/bar:33'); - assert.equal(res.path, '/foo/bar'); - assert.equal(res.line, 33); - assert.equal(res.column, 1); + assert.strictEqual(res.path, '/foo/bar'); + assert.strictEqual(res.line, 33); + assert.strictEqual(res.column, 1); res = extpath.parseLineAndColumnAware('/foo/bar:33:34'); - assert.equal(res.path, '/foo/bar'); - assert.equal(res.line, 33); - assert.equal(res.column, 34); + assert.strictEqual(res.path, '/foo/bar'); + assert.strictEqual(res.line, 33); + assert.strictEqual(res.column, 34); res = extpath.parseLineAndColumnAware('C:\\foo\\bar'); - assert.equal(res.path, 'C:\\foo\\bar'); - assert.equal(res.line, undefined); - assert.equal(res.column, undefined); + assert.strictEqual(res.path, 'C:\\foo\\bar'); + assert.strictEqual(res.line, undefined); + assert.strictEqual(res.column, undefined); res = extpath.parseLineAndColumnAware('C:\\foo\\bar:33'); - assert.equal(res.path, 'C:\\foo\\bar'); - assert.equal(res.line, 33); - assert.equal(res.column, 1); + assert.strictEqual(res.path, 'C:\\foo\\bar'); + assert.strictEqual(res.line, 33); + assert.strictEqual(res.column, 1); res = extpath.parseLineAndColumnAware('C:\\foo\\bar:33:34'); - assert.equal(res.path, 'C:\\foo\\bar'); - assert.equal(res.line, 33); - assert.equal(res.column, 34); + assert.strictEqual(res.path, 'C:\\foo\\bar'); + assert.strictEqual(res.line, 33); + assert.strictEqual(res.column, 34); res = extpath.parseLineAndColumnAware('/foo/bar:abb'); - assert.equal(res.path, '/foo/bar:abb'); - assert.equal(res.line, undefined); - assert.equal(res.column, undefined); + assert.strictEqual(res.path, '/foo/bar:abb'); + assert.strictEqual(res.line, undefined); + assert.strictEqual(res.column, undefined); }); }); diff --git a/src/vs/base/test/common/fuzzyScorer.test.ts b/src/vs/base/test/common/fuzzyScorer.test.ts index 5aac1fb98b471354d2a076370895f6efd8629664..59c52ce00f3b44c6c76aeec2324ada77054d1c96 100644 --- a/src/vs/base/test/common/fuzzyScorer.test.ts +++ b/src/vs/base/test/common/fuzzyScorer.test.ts @@ -120,30 +120,30 @@ suite('Fuzzy Scorer', () => { // Assert scoring order let sortedScores = scores.concat().sort((a, b) => b[0] - a[0]); - assert.deepEqual(scores, sortedScores); + assert.deepStrictEqual(scores, sortedScores); // Assert scoring positions // let positions = scores[0][1]; - // assert.equal(positions.length, 'HelLo-World'.length); + // assert.strictEqual(positions.length, 'HelLo-World'.length); // positions = scores[2][1]; - // assert.equal(positions.length, 'HW'.length); - // assert.equal(positions[0], 0); - // assert.equal(positions[1], 6); + // assert.strictEqual(positions.length, 'HW'.length); + // assert.strictEqual(positions[0], 0); + // assert.strictEqual(positions[1], 6); }); test('score (non fuzzy)', function () { const target = 'HeLlo-World'; assert.ok(_doScore(target, 'HelLo-World', false)[0] > 0); - assert.equal(_doScore(target, 'HelLo-World', false)[1].length, 'HelLo-World'.length); + assert.strictEqual(_doScore(target, 'HelLo-World', false)[1].length, 'HelLo-World'.length); assert.ok(_doScore(target, 'hello-world', false)[0] > 0); - assert.equal(_doScore(target, 'HW', false)[0], 0); + assert.strictEqual(_doScore(target, 'HW', false)[0], 0); assert.ok(_doScore(target, 'h', false)[0] > 0); assert.ok(_doScore(target, 'ello', false)[0] > 0); assert.ok(_doScore(target, 'ld', false)[0] > 0); - assert.equal(_doScore(target, 'eo', false)[0], 0); + assert.strictEqual(_doScore(target, 'eo', false)[0], 0); }); test('scoreItem - matches are proper', function () { @@ -158,52 +158,52 @@ suite('Fuzzy Scorer', () => { // Path Identity const identityRes = scoreItem(resource, ResourceAccessor.getItemPath(resource), true, ResourceAccessor); assert.ok(identityRes.score); - assert.equal(identityRes.descriptionMatch!.length, 1); - assert.equal(identityRes.labelMatch!.length, 1); - assert.equal(identityRes.descriptionMatch![0].start, 0); - assert.equal(identityRes.descriptionMatch![0].end, ResourceAccessor.getItemDescription(resource).length); - assert.equal(identityRes.labelMatch![0].start, 0); - assert.equal(identityRes.labelMatch![0].end, ResourceAccessor.getItemLabel(resource).length); + assert.strictEqual(identityRes.descriptionMatch!.length, 1); + assert.strictEqual(identityRes.labelMatch!.length, 1); + assert.strictEqual(identityRes.descriptionMatch![0].start, 0); + assert.strictEqual(identityRes.descriptionMatch![0].end, ResourceAccessor.getItemDescription(resource).length); + assert.strictEqual(identityRes.labelMatch![0].start, 0); + assert.strictEqual(identityRes.labelMatch![0].end, ResourceAccessor.getItemLabel(resource).length); // Basename Prefix const basenamePrefixRes = scoreItem(resource, 'som', true, ResourceAccessor); assert.ok(basenamePrefixRes.score); assert.ok(!basenamePrefixRes.descriptionMatch); - assert.equal(basenamePrefixRes.labelMatch!.length, 1); - assert.equal(basenamePrefixRes.labelMatch![0].start, 0); - assert.equal(basenamePrefixRes.labelMatch![0].end, 'som'.length); + assert.strictEqual(basenamePrefixRes.labelMatch!.length, 1); + assert.strictEqual(basenamePrefixRes.labelMatch![0].start, 0); + assert.strictEqual(basenamePrefixRes.labelMatch![0].end, 'som'.length); // Basename Camelcase const basenameCamelcaseRes = scoreItem(resource, 'sF', true, ResourceAccessor); assert.ok(basenameCamelcaseRes.score); assert.ok(!basenameCamelcaseRes.descriptionMatch); - assert.equal(basenameCamelcaseRes.labelMatch!.length, 2); - assert.equal(basenameCamelcaseRes.labelMatch![0].start, 0); - assert.equal(basenameCamelcaseRes.labelMatch![0].end, 1); - assert.equal(basenameCamelcaseRes.labelMatch![1].start, 4); - assert.equal(basenameCamelcaseRes.labelMatch![1].end, 5); + assert.strictEqual(basenameCamelcaseRes.labelMatch!.length, 2); + assert.strictEqual(basenameCamelcaseRes.labelMatch![0].start, 0); + assert.strictEqual(basenameCamelcaseRes.labelMatch![0].end, 1); + assert.strictEqual(basenameCamelcaseRes.labelMatch![1].start, 4); + assert.strictEqual(basenameCamelcaseRes.labelMatch![1].end, 5); // Basename Match const basenameRes = scoreItem(resource, 'of', true, ResourceAccessor); assert.ok(basenameRes.score); assert.ok(!basenameRes.descriptionMatch); - assert.equal(basenameRes.labelMatch!.length, 2); - assert.equal(basenameRes.labelMatch![0].start, 1); - assert.equal(basenameRes.labelMatch![0].end, 2); - assert.equal(basenameRes.labelMatch![1].start, 4); - assert.equal(basenameRes.labelMatch![1].end, 5); + assert.strictEqual(basenameRes.labelMatch!.length, 2); + assert.strictEqual(basenameRes.labelMatch![0].start, 1); + assert.strictEqual(basenameRes.labelMatch![0].end, 2); + assert.strictEqual(basenameRes.labelMatch![1].start, 4); + assert.strictEqual(basenameRes.labelMatch![1].end, 5); // Path Match const pathRes = scoreItem(resource, 'xyz123', true, ResourceAccessor); assert.ok(pathRes.score); assert.ok(pathRes.descriptionMatch); assert.ok(pathRes.labelMatch); - assert.equal(pathRes.labelMatch!.length, 1); - assert.equal(pathRes.labelMatch![0].start, 8); - assert.equal(pathRes.labelMatch![0].end, 11); - assert.equal(pathRes.descriptionMatch!.length, 1); - assert.equal(pathRes.descriptionMatch![0].start, 1); - assert.equal(pathRes.descriptionMatch![0].end, 4); + assert.strictEqual(pathRes.labelMatch!.length, 1); + assert.strictEqual(pathRes.labelMatch![0].start, 8); + assert.strictEqual(pathRes.labelMatch![0].end, 11); + assert.strictEqual(pathRes.descriptionMatch!.length, 1); + assert.strictEqual(pathRes.descriptionMatch![0].start, 1); + assert.strictEqual(pathRes.descriptionMatch![0].end, 4); // No Match const noRes = scoreItem(resource, '987', true, ResourceAccessor); @@ -223,51 +223,51 @@ suite('Fuzzy Scorer', () => { let res1 = scoreItem(resource, 'xyz some', true, ResourceAccessor); assert.ok(res1.score); - assert.equal(res1.labelMatch?.length, 1); - assert.equal(res1.labelMatch![0].start, 0); - assert.equal(res1.labelMatch![0].end, 4); - assert.equal(res1.descriptionMatch?.length, 1); - assert.equal(res1.descriptionMatch![0].start, 1); - assert.equal(res1.descriptionMatch![0].end, 4); + assert.strictEqual(res1.labelMatch?.length, 1); + assert.strictEqual(res1.labelMatch![0].start, 0); + assert.strictEqual(res1.labelMatch![0].end, 4); + assert.strictEqual(res1.descriptionMatch?.length, 1); + assert.strictEqual(res1.descriptionMatch![0].start, 1); + assert.strictEqual(res1.descriptionMatch![0].end, 4); let res2 = scoreItem(resource, 'some xyz', true, ResourceAccessor); assert.ok(res2.score); - assert.equal(res1.score, res2.score); - assert.equal(res2.labelMatch?.length, 1); - assert.equal(res2.labelMatch![0].start, 0); - assert.equal(res2.labelMatch![0].end, 4); - assert.equal(res2.descriptionMatch?.length, 1); - assert.equal(res2.descriptionMatch![0].start, 1); - assert.equal(res2.descriptionMatch![0].end, 4); + assert.strictEqual(res1.score, res2.score); + assert.strictEqual(res2.labelMatch?.length, 1); + assert.strictEqual(res2.labelMatch![0].start, 0); + assert.strictEqual(res2.labelMatch![0].end, 4); + assert.strictEqual(res2.descriptionMatch?.length, 1); + assert.strictEqual(res2.descriptionMatch![0].start, 1); + assert.strictEqual(res2.descriptionMatch![0].end, 4); let res3 = scoreItem(resource, 'some xyz file file123', true, ResourceAccessor); assert.ok(res3.score); assert.ok(res3.score > res2.score); - assert.equal(res3.labelMatch?.length, 1); - assert.equal(res3.labelMatch![0].start, 0); - assert.equal(res3.labelMatch![0].end, 11); - assert.equal(res3.descriptionMatch?.length, 1); - assert.equal(res3.descriptionMatch![0].start, 1); - assert.equal(res3.descriptionMatch![0].end, 4); + assert.strictEqual(res3.labelMatch?.length, 1); + assert.strictEqual(res3.labelMatch![0].start, 0); + assert.strictEqual(res3.labelMatch![0].end, 11); + assert.strictEqual(res3.descriptionMatch?.length, 1); + assert.strictEqual(res3.descriptionMatch![0].start, 1); + assert.strictEqual(res3.descriptionMatch![0].end, 4); let res4 = scoreItem(resource, 'path z y', true, ResourceAccessor); assert.ok(res4.score); assert.ok(res4.score < res2.score); - assert.equal(res4.labelMatch?.length, 0); - assert.equal(res4.descriptionMatch?.length, 2); - assert.equal(res4.descriptionMatch![0].start, 2); - assert.equal(res4.descriptionMatch![0].end, 4); - assert.equal(res4.descriptionMatch![1].start, 10); - assert.equal(res4.descriptionMatch![1].end, 14); + assert.strictEqual(res4.labelMatch?.length, 0); + assert.strictEqual(res4.descriptionMatch?.length, 2); + assert.strictEqual(res4.descriptionMatch![0].start, 2); + assert.strictEqual(res4.descriptionMatch![0].end, 4); + assert.strictEqual(res4.descriptionMatch![1].start, 10); + assert.strictEqual(res4.descriptionMatch![1].end, 14); }); test('scoreItem - invalid input', function () { let res = scoreItem(null, null!, true, ResourceAccessor); - assert.equal(res.score, 0); + assert.strictEqual(res.score, 0); res = scoreItem(null, 'null', true, ResourceAccessor); - assert.equal(res.score, 0); + assert.strictEqual(res.score, 0); }); test('scoreItem - optimize for file paths', function () { @@ -280,12 +280,12 @@ suite('Fuzzy Scorer', () => { assert.ok(pathRes.score); assert.ok(pathRes.descriptionMatch); assert.ok(pathRes.labelMatch); - assert.equal(pathRes.labelMatch!.length, 1); - assert.equal(pathRes.labelMatch![0].start, 0); - assert.equal(pathRes.labelMatch![0].end, 7); - assert.equal(pathRes.descriptionMatch!.length, 1); - assert.equal(pathRes.descriptionMatch![0].start, 23); - assert.equal(pathRes.descriptionMatch![0].end, 26); + assert.strictEqual(pathRes.labelMatch!.length, 1); + assert.strictEqual(pathRes.labelMatch![0].start, 0); + assert.strictEqual(pathRes.labelMatch![0].end, 7); + assert.strictEqual(pathRes.descriptionMatch!.length, 1); + assert.strictEqual(pathRes.descriptionMatch![0].start, 23); + assert.strictEqual(pathRes.descriptionMatch![0].end, 26); }); test('scoreItem - avoid match scattering (bug #36119)', function () { @@ -295,9 +295,9 @@ suite('Fuzzy Scorer', () => { assert.ok(pathRes.score); assert.ok(pathRes.descriptionMatch); assert.ok(pathRes.labelMatch); - assert.equal(pathRes.labelMatch!.length, 1); - assert.equal(pathRes.labelMatch![0].start, 0); - assert.equal(pathRes.labelMatch![0].end, 9); + assert.strictEqual(pathRes.labelMatch!.length, 1); + assert.strictEqual(pathRes.labelMatch![0].start, 0); + assert.strictEqual(pathRes.labelMatch![0].end, 9); }); test('scoreItem - prefers more compact matches', function () { @@ -309,11 +309,11 @@ suite('Fuzzy Scorer', () => { assert.ok(res.score); assert.ok(res.descriptionMatch); assert.ok(!res.labelMatch!.length); - assert.equal(res.descriptionMatch!.length, 2); - assert.equal(res.descriptionMatch![0].start, 11); - assert.equal(res.descriptionMatch![0].end, 12); - assert.equal(res.descriptionMatch![1].start, 13); - assert.equal(res.descriptionMatch![1].end, 14); + assert.strictEqual(res.descriptionMatch!.length, 2); + assert.strictEqual(res.descriptionMatch![0].start, 11); + assert.strictEqual(res.descriptionMatch![0].end, 12); + assert.strictEqual(res.descriptionMatch![1].start, 13); + assert.strictEqual(res.descriptionMatch![1].end, 14); }); test('scoreItem - proper target offset', function () { @@ -328,9 +328,9 @@ suite('Fuzzy Scorer', () => { const res = scoreItem(resource, 'de', true, ResourceAccessor); - assert.equal(res.labelMatch!.length, 1); - assert.equal(res.labelMatch![0].start, 1); - assert.equal(res.labelMatch![0].end, 3); + assert.strictEqual(res.labelMatch!.length, 1); + assert.strictEqual(res.labelMatch![0].start, 1); + assert.strictEqual(res.labelMatch![0].end, 3); }); test('scoreItem - proper target offset #3', function () { @@ -338,19 +338,19 @@ suite('Fuzzy Scorer', () => { const res = scoreItem(resource, 'debug', true, ResourceAccessor); - assert.equal(res.descriptionMatch!.length, 3); - assert.equal(res.descriptionMatch![0].start, 9); - assert.equal(res.descriptionMatch![0].end, 10); - assert.equal(res.descriptionMatch![1].start, 36); - assert.equal(res.descriptionMatch![1].end, 37); - assert.equal(res.descriptionMatch![2].start, 40); - assert.equal(res.descriptionMatch![2].end, 41); - - assert.equal(res.labelMatch!.length, 2); - assert.equal(res.labelMatch![0].start, 9); - assert.equal(res.labelMatch![0].end, 10); - assert.equal(res.labelMatch![1].start, 20); - assert.equal(res.labelMatch![1].end, 21); + assert.strictEqual(res.descriptionMatch!.length, 3); + assert.strictEqual(res.descriptionMatch![0].start, 9); + assert.strictEqual(res.descriptionMatch![0].end, 10); + assert.strictEqual(res.descriptionMatch![1].start, 36); + assert.strictEqual(res.descriptionMatch![1].end, 37); + assert.strictEqual(res.descriptionMatch![2].start, 40); + assert.strictEqual(res.descriptionMatch![2].end, 41); + + assert.strictEqual(res.labelMatch!.length, 2); + assert.strictEqual(res.labelMatch![0].start, 9); + assert.strictEqual(res.labelMatch![0].end, 10); + assert.strictEqual(res.labelMatch![1].start, 20); + assert.strictEqual(res.labelMatch![1].end, 21); }); test('scoreItem - no match unless query contained in sequence', function () { @@ -394,27 +394,27 @@ suite('Fuzzy Scorer', () => { let query = ResourceAccessor.getItemPath(resourceA); let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); + assert.strictEqual(res[2], resourceC); res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); + assert.strictEqual(res[2], resourceC); // Full resource B path query = ResourceAccessor.getItemPath(resourceB); res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); + assert.strictEqual(res[2], resourceC); res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); + assert.strictEqual(res[2], resourceC); }); test('compareFilesByScore - basename prefix', function () { @@ -426,27 +426,27 @@ suite('Fuzzy Scorer', () => { let query = ResourceAccessor.getItemLabel(resourceA); let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); + assert.strictEqual(res[2], resourceC); res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); + assert.strictEqual(res[2], resourceC); // Full resource B basename query = ResourceAccessor.getItemLabel(resourceB); res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); + assert.strictEqual(res[2], resourceC); res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); + assert.strictEqual(res[2], resourceC); }); test('compareFilesByScore - basename camelcase', function () { @@ -458,27 +458,27 @@ suite('Fuzzy Scorer', () => { let query = 'fA'; let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); + assert.strictEqual(res[2], resourceC); res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); + assert.strictEqual(res[2], resourceC); // resource B camelcase query = 'fB'; res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); + assert.strictEqual(res[2], resourceC); res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); + assert.strictEqual(res[2], resourceC); }); test('compareFilesByScore - basename scores', function () { @@ -490,27 +490,27 @@ suite('Fuzzy Scorer', () => { let query = 'fileA'; let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); + assert.strictEqual(res[2], resourceC); res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); + assert.strictEqual(res[2], resourceC); // Resource B part of basename query = 'fileB'; res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); + assert.strictEqual(res[2], resourceC); res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); + assert.strictEqual(res[2], resourceC); }); test('compareFilesByScore - path scores', function () { @@ -522,27 +522,27 @@ suite('Fuzzy Scorer', () => { let query = 'pathfileA'; let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); + assert.strictEqual(res[2], resourceC); res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); + assert.strictEqual(res[2], resourceC); // Resource B part of path query = 'pathfileB'; res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); + assert.strictEqual(res[2], resourceC); res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); + assert.strictEqual(res[2], resourceC); }); test('compareFilesByScore - prefer shorter basenames', function () { @@ -554,14 +554,14 @@ suite('Fuzzy Scorer', () => { let query = 'somepath'; let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); + assert.strictEqual(res[2], resourceC); res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); + assert.strictEqual(res[2], resourceC); }); test('compareFilesByScore - prefer shorter basenames (match on basename)', function () { @@ -573,14 +573,14 @@ suite('Fuzzy Scorer', () => { let query = 'file'; let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceC); - assert.equal(res[2], resourceB); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceC); + assert.strictEqual(res[2], resourceB); res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceC); - assert.equal(res[2], resourceB); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceC); + assert.strictEqual(res[2], resourceB); }); test('compareFilesByScore - prefer shorter paths', function () { @@ -592,14 +592,14 @@ suite('Fuzzy Scorer', () => { let query = 'somepath'; let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); + assert.strictEqual(res[2], resourceC); res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); + assert.strictEqual(res[2], resourceC); }); test('compareFilesByScore - prefer shorter paths (bug #17443)', function () { @@ -610,9 +610,9 @@ suite('Fuzzy Scorer', () => { let query = 'co/te'; let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); - assert.equal(res[2], resourceC); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); + assert.strictEqual(res[2], resourceC); }); test('compareFilesByScore - prefer matches in label over description if scores are otherwise equal', function () { @@ -622,8 +622,8 @@ suite('Fuzzy Scorer', () => { let query = 'partsquick'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); }); test('compareFilesByScore - prefer camel case matches', function () { @@ -632,12 +632,12 @@ suite('Fuzzy Scorer', () => { for (const query of ['npe', 'NPE']) { let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); } }); @@ -648,12 +648,12 @@ suite('Fuzzy Scorer', () => { let query = 'AH'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); }); test('compareFilesByScore - prefer more compact matches (label)', function () { @@ -663,12 +663,12 @@ suite('Fuzzy Scorer', () => { let query = 'xp'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); }); test('compareFilesByScore - prefer more compact matches (path)', function () { @@ -678,12 +678,12 @@ suite('Fuzzy Scorer', () => { let query = 'xp'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); }); test('compareFilesByScore - prefer more compact matches (label and path)', function () { @@ -693,12 +693,12 @@ suite('Fuzzy Scorer', () => { let query = 'exfile'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); }); test('compareFilesByScore - avoid match scattering (bug #34210)', function () { @@ -710,18 +710,18 @@ suite('Fuzzy Scorer', () => { let query = isWindows ? 'modu1\\index.js' : 'modu1/index.js'; let res = [resourceA, resourceB, resourceC, resourceD].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceC); + assert.strictEqual(res[0], resourceC); res = [resourceC, resourceB, resourceA, resourceD].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceC); + assert.strictEqual(res[0], resourceC); query = isWindows ? 'un1\\index.js' : 'un1/index.js'; res = [resourceA, resourceB, resourceC, resourceD].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); res = [resourceC, resourceB, resourceA, resourceD].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); }); test('compareFilesByScore - avoid match scattering (bug #21019 1.)', function () { @@ -732,10 +732,10 @@ suite('Fuzzy Scorer', () => { let query = 'StatVideoindex'; let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceC); + assert.strictEqual(res[0], resourceC); res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceC); + assert.strictEqual(res[0], resourceC); }); test('compareFilesByScore - avoid match scattering (bug #21019 2.)', function () { @@ -745,10 +745,10 @@ suite('Fuzzy Scorer', () => { let query = 'reproreduxts'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); }); test('compareFilesByScore - avoid match scattering (bug #26649)', function () { @@ -759,10 +759,10 @@ suite('Fuzzy Scorer', () => { let query = 'bookpageIndex'; let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceC); + assert.strictEqual(res[0], resourceC); res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceC); + assert.strictEqual(res[0], resourceC); }); test('compareFilesByScore - avoid match scattering (bug #33247)', function () { @@ -772,10 +772,10 @@ suite('Fuzzy Scorer', () => { let query = isWindows ? 'ui\\icons' : 'ui/icons'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); }); test('compareFilesByScore - avoid match scattering (bug #33247 comment)', function () { @@ -785,10 +785,10 @@ suite('Fuzzy Scorer', () => { let query = isWindows ? 'ui\\input\\index' : 'ui/input/index'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); }); test('compareFilesByScore - avoid match scattering (bug #36166)', function () { @@ -798,10 +798,10 @@ suite('Fuzzy Scorer', () => { let query = 'djancosig'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); }); test('compareFilesByScore - avoid match scattering (bug #32918)', function () { @@ -812,14 +812,14 @@ suite('Fuzzy Scorer', () => { let query = 'protectedconfig.php'; let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceC); - assert.equal(res[2], resourceB); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceC); + assert.strictEqual(res[2], resourceB); res = [resourceC, resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceC); - assert.equal(res[2], resourceB); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceC); + assert.strictEqual(res[2], resourceB); }); test('compareFilesByScore - avoid match scattering (bug #14879)', function () { @@ -829,10 +829,10 @@ suite('Fuzzy Scorer', () => { let query = 'gradientmain'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); }); test('compareFilesByScore - avoid match scattering (bug #14727 1)', function () { @@ -842,10 +842,10 @@ suite('Fuzzy Scorer', () => { let query = 'abc'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); }); test('compareFilesByScore - avoid match scattering (bug #14727 2)', function () { @@ -855,10 +855,10 @@ suite('Fuzzy Scorer', () => { let query = 'xyz'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); }); test('compareFilesByScore - avoid match scattering (bug #18381)', function () { @@ -868,10 +868,10 @@ suite('Fuzzy Scorer', () => { let query = 'async'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); }); test('compareFilesByScore - avoid match scattering (bug #35572)', function () { @@ -881,10 +881,10 @@ suite('Fuzzy Scorer', () => { let query = 'partisettings'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); }); test('compareFilesByScore - avoid match scattering (bug #36810)', function () { @@ -894,10 +894,10 @@ suite('Fuzzy Scorer', () => { let query = 'tipsindex.cshtml'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); }); test('compareFilesByScore - prefer shorter hit (bug #20546)', function () { @@ -907,10 +907,10 @@ suite('Fuzzy Scorer', () => { let query = 'listview'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); }); test('compareFilesByScore - avoid match scattering (bug #12095)', function () { @@ -921,10 +921,10 @@ suite('Fuzzy Scorer', () => { let query = 'filesexplorerview.ts'; let res = [resourceA, resourceB, resourceC].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); res = [resourceA, resourceC, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); }); test('compareFilesByScore - prefer case match (bug #96122)', function () { @@ -934,10 +934,10 @@ suite('Fuzzy Scorer', () => { let query = 'Lists.php'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); + assert.strictEqual(res[0], resourceB); }); test('compareFilesByScore - prefer shorter match (bug #103052) - foo bar', function () { @@ -946,12 +946,12 @@ suite('Fuzzy Scorer', () => { for (const query of ['foo bar', 'foobar']) { let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); } }); @@ -961,12 +961,12 @@ suite('Fuzzy Scorer', () => { for (const query of ['payment model', 'paymentmodel']) { let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); } }); @@ -976,12 +976,12 @@ suite('Fuzzy Scorer', () => { for (const query of ['color js', 'colorjs']) { let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); } }); @@ -992,22 +992,22 @@ suite('Fuzzy Scorer', () => { let query = 'Color'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); query = 'color'; res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); }); test('compareFilesByScore - prefer prefix (bug #103052)', function () { @@ -1017,12 +1017,12 @@ suite('Fuzzy Scorer', () => { let query = 'smoke main.ts'; let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceA); - assert.equal(res[1], resourceB); + assert.strictEqual(res[0], resourceA); + assert.strictEqual(res[1], resourceB); }); test('compareFilesByScore - boost better prefix match if multiple queries are used', function () { @@ -1031,12 +1031,12 @@ suite('Fuzzy Scorer', () => { for (const query of ['workbench.ts browser', 'browser workbench.ts', 'browser workbench', 'workbench browser']) { let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); } }); @@ -1046,12 +1046,12 @@ suite('Fuzzy Scorer', () => { for (const query of ['window browser', 'window.ts browser']) { let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); } }); @@ -1061,73 +1061,73 @@ suite('Fuzzy Scorer', () => { for (const query of ['m life, life m']) { let res = [resourceA, resourceB].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); res = [resourceB, resourceA].sort((r1, r2) => compareItemsByScore(r1, r2, query, true, ResourceAccessor)); - assert.equal(res[0], resourceB); - assert.equal(res[1], resourceA); + assert.strictEqual(res[0], resourceB); + assert.strictEqual(res[1], resourceA); } }); test('prepareQuery', () => { - assert.equal(scorer.prepareQuery(' f*a ').normalized, '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').normalized, 'modelTester.ts'); - assert.equal(scorer.prepareQuery('Model Tester.ts').normalizedLowercase, 'modeltester.ts'); - assert.equal(scorer.prepareQuery('ModelTester.ts').containsPathSeparator, false); - assert.equal(scorer.prepareQuery('Model' + sep + 'Tester.ts').containsPathSeparator, true); + assert.strictEqual(scorer.prepareQuery(' f*a ').normalized, 'fa'); + assert.strictEqual(scorer.prepareQuery('model Tester.ts').original, 'model Tester.ts'); + assert.strictEqual(scorer.prepareQuery('model Tester.ts').originalLowercase, 'model Tester.ts'.toLowerCase()); + assert.strictEqual(scorer.prepareQuery('model Tester.ts').normalized, 'modelTester.ts'); + assert.strictEqual(scorer.prepareQuery('Model Tester.ts').normalizedLowercase, 'modeltester.ts'); + assert.strictEqual(scorer.prepareQuery('ModelTester.ts').containsPathSeparator, false); + assert.strictEqual(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.normalized, 'HelloWorld'); - assert.equal(query.normalizedLowercase, 'HelloWorld'.toLowerCase()); - assert.equal(query.values?.length, 2); - assert.equal(query.values?.[0].original, 'He*llo'); - assert.equal(query.values?.[0].normalized, 'Hello'); - assert.equal(query.values?.[0].normalizedLowercase, 'Hello'.toLowerCase()); - assert.equal(query.values?.[1].original, 'World'); - assert.equal(query.values?.[1].normalized, 'World'); - assert.equal(query.values?.[1].normalizedLowercase, 'World'.toLowerCase()); + assert.strictEqual(query.original, 'He*llo World'); + assert.strictEqual(query.normalized, 'HelloWorld'); + assert.strictEqual(query.normalizedLowercase, 'HelloWorld'.toLowerCase()); + assert.strictEqual(query.values?.length, 2); + assert.strictEqual(query.values?.[0].original, 'He*llo'); + assert.strictEqual(query.values?.[0].normalized, 'Hello'); + assert.strictEqual(query.values?.[0].normalizedLowercase, 'Hello'.toLowerCase()); + assert.strictEqual(query.values?.[1].original, 'World'); + assert.strictEqual(query.values?.[1].normalized, 'World'); + assert.strictEqual(query.values?.[1].normalizedLowercase, 'World'.toLowerCase()); let restoredQuery = scorer.pieceToQuery(query.values!); - assert.equal(restoredQuery.original, query.original); - assert.equal(restoredQuery.values?.length, query.values?.length); - assert.equal(restoredQuery.containsPathSeparator, query.containsPathSeparator); + assert.strictEqual(restoredQuery.original, query.original); + assert.strictEqual(restoredQuery.values?.length, query.values?.length); + assert.strictEqual(restoredQuery.containsPathSeparator, query.containsPathSeparator); // 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.normalized, 'HelloWorld'); - assert.equal(query.normalizedLowercase, '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].normalized, 'Hello'); - assert.equal(query.values?.[0].normalizedLowercase, 'Hello'.toLowerCase()); - assert.equal(query.values?.[1].original, 'World'); - assert.equal(query.values?.[1].originalLowercase, 'World'.toLowerCase()); - assert.equal(query.values?.[1].normalized, 'World'); - assert.equal(query.values?.[1].normalizedLowercase, 'World'.toLowerCase()); + assert.strictEqual(query.original, ' Hello World '); + assert.strictEqual(query.originalLowercase, ' Hello World '.toLowerCase()); + assert.strictEqual(query.normalized, 'HelloWorld'); + assert.strictEqual(query.normalizedLowercase, 'HelloWorld'.toLowerCase()); + assert.strictEqual(query.values?.length, 2); + assert.strictEqual(query.values?.[0].original, 'Hello'); + assert.strictEqual(query.values?.[0].originalLowercase, 'Hello'.toLowerCase()); + assert.strictEqual(query.values?.[0].normalized, 'Hello'); + assert.strictEqual(query.values?.[0].normalizedLowercase, 'Hello'.toLowerCase()); + assert.strictEqual(query.values?.[1].original, 'World'); + assert.strictEqual(query.values?.[1].originalLowercase, 'World'.toLowerCase()); + assert.strictEqual(query.values?.[1].normalized, 'World'); + assert.strictEqual(query.values?.[1].normalizedLowercase, 'World'.toLowerCase()); // Path related if (isWindows) { - assert.equal(scorer.prepareQuery('C:\\some\\path').pathNormalized, 'C:\\some\\path'); - assert.equal(scorer.prepareQuery('C:\\some\\path').normalized, 'C:\\some\\path'); - assert.equal(scorer.prepareQuery('C:\\some\\path').containsPathSeparator, true); - assert.equal(scorer.prepareQuery('C:/some/path').pathNormalized, 'C:\\some\\path'); - assert.equal(scorer.prepareQuery('C:/some/path').normalized, 'C:\\some\\path'); - assert.equal(scorer.prepareQuery('C:/some/path').containsPathSeparator, true); + assert.strictEqual(scorer.prepareQuery('C:\\some\\path').pathNormalized, 'C:\\some\\path'); + assert.strictEqual(scorer.prepareQuery('C:\\some\\path').normalized, 'C:\\some\\path'); + assert.strictEqual(scorer.prepareQuery('C:\\some\\path').containsPathSeparator, true); + assert.strictEqual(scorer.prepareQuery('C:/some/path').pathNormalized, 'C:\\some\\path'); + assert.strictEqual(scorer.prepareQuery('C:/some/path').normalized, 'C:\\some\\path'); + assert.strictEqual(scorer.prepareQuery('C:/some/path').containsPathSeparator, true); } else { - assert.equal(scorer.prepareQuery('/some/path').pathNormalized, '/some/path'); - assert.equal(scorer.prepareQuery('/some/path').normalized, '/some/path'); - assert.equal(scorer.prepareQuery('/some/path').containsPathSeparator, true); - assert.equal(scorer.prepareQuery('\\some\\path').pathNormalized, '/some/path'); - assert.equal(scorer.prepareQuery('\\some\\path').normalized, '/some/path'); - assert.equal(scorer.prepareQuery('\\some\\path').containsPathSeparator, true); + assert.strictEqual(scorer.prepareQuery('/some/path').pathNormalized, '/some/path'); + assert.strictEqual(scorer.prepareQuery('/some/path').normalized, '/some/path'); + assert.strictEqual(scorer.prepareQuery('/some/path').containsPathSeparator, true); + assert.strictEqual(scorer.prepareQuery('\\some\\path').pathNormalized, '/some/path'); + assert.strictEqual(scorer.prepareQuery('\\some\\path').normalized, '/some/path'); + assert.strictEqual(scorer.prepareQuery('\\some\\path').containsPathSeparator, true); } }); @@ -1138,18 +1138,18 @@ suite('Fuzzy Scorer', () => { let [score, matches] = _doScore2(offset === 0 ? target : `123${target}`, 'HeLlo-World', offset); assert.ok(score); - assert.equal(matches.length, 1); - assert.equal(matches[0].start, 0 + offset); - assert.equal(matches[0].end, target.length + offset); + assert.strictEqual(matches.length, 1); + assert.strictEqual(matches[0].start, 0 + offset); + assert.strictEqual(matches[0].end, target.length + offset); [score, matches] = _doScore2(offset === 0 ? target : `123${target}`, 'HW', offset); assert.ok(score); - assert.equal(matches.length, 2); - assert.equal(matches[0].start, 0 + offset); - assert.equal(matches[0].end, 1 + offset); - assert.equal(matches[1].start, 6 + offset); - assert.equal(matches[1].end, 7 + offset); + assert.strictEqual(matches.length, 2); + assert.strictEqual(matches[0].start, 0 + offset); + assert.strictEqual(matches[0].end, 1 + offset); + assert.strictEqual(matches[1].start, 6 + offset); + assert.strictEqual(matches[1].end, 7 + offset); } }); @@ -1169,8 +1169,8 @@ suite('Fuzzy Scorer', () => { const firstAndSecondSingleMatch = firstAndSecondSingleMatches[i]; if (multiMatch && firstAndSecondSingleMatch) { - assert.equal(multiMatch.start, firstAndSecondSingleMatch.start); - assert.equal(multiMatch.end, firstAndSecondSingleMatch.end); + assert.strictEqual(multiMatch.start, firstAndSecondSingleMatch.start); + assert.strictEqual(multiMatch.end, firstAndSecondSingleMatch.end); } else { assert.fail(); } @@ -1178,8 +1178,8 @@ suite('Fuzzy Scorer', () => { } function assertNoScore() { - assert.equal(multiScore, undefined); - assert.equal(multiMatches.length, 0); + assert.strictEqual(multiScore, undefined); + assert.strictEqual(multiMatches.length, 0); } assertScore(); diff --git a/src/vs/base/test/common/labels.test.ts b/src/vs/base/test/common/labels.test.ts index 27f0daab32830a66f78a0fb6fd33c73ba5f9df89..d7f0a401fb688bb1f45a108d2e4152e19f2e567b 100644 --- a/src/vs/base/test/common/labels.test.ts +++ b/src/vs/base/test/common/labels.test.ts @@ -11,95 +11,95 @@ suite('Labels', () => { (!platform.isWindows ? test.skip : test)('shorten - windows', () => { // nothing to shorten - assert.deepEqual(labels.shorten(['a']), ['a']); - assert.deepEqual(labels.shorten(['a', 'b']), ['a', 'b']); - assert.deepEqual(labels.shorten(['a', 'b', 'c']), ['a', 'b', 'c']); + assert.deepStrictEqual(labels.shorten(['a']), ['a']); + assert.deepStrictEqual(labels.shorten(['a', 'b']), ['a', 'b']); + assert.deepStrictEqual(labels.shorten(['a', 'b', 'c']), ['a', 'b', 'c']); // completely different paths - assert.deepEqual(labels.shorten(['a\\b', 'c\\d', 'e\\f']), ['…\\b', '…\\d', '…\\f']); + assert.deepStrictEqual(labels.shorten(['a\\b', 'c\\d', 'e\\f']), ['…\\b', '…\\d', '…\\f']); // same beginning - assert.deepEqual(labels.shorten(['a', 'a\\b']), ['a', '…\\b']); - assert.deepEqual(labels.shorten(['a\\b', 'a\\b\\c']), ['…\\b', '…\\c']); - assert.deepEqual(labels.shorten(['a', 'a\\b', 'a\\b\\c']), ['a', '…\\b', '…\\c']); - assert.deepEqual(labels.shorten(['x:\\a\\b', 'x:\\a\\c']), ['x:\\…\\b', 'x:\\…\\c']); - assert.deepEqual(labels.shorten(['\\\\a\\b', '\\\\a\\c']), ['\\\\a\\b', '\\\\a\\c']); + assert.deepStrictEqual(labels.shorten(['a', 'a\\b']), ['a', '…\\b']); + assert.deepStrictEqual(labels.shorten(['a\\b', 'a\\b\\c']), ['…\\b', '…\\c']); + assert.deepStrictEqual(labels.shorten(['a', 'a\\b', 'a\\b\\c']), ['a', '…\\b', '…\\c']); + assert.deepStrictEqual(labels.shorten(['x:\\a\\b', 'x:\\a\\c']), ['x:\\…\\b', 'x:\\…\\c']); + assert.deepStrictEqual(labels.shorten(['\\\\a\\b', '\\\\a\\c']), ['\\\\a\\b', '\\\\a\\c']); // same ending - assert.deepEqual(labels.shorten(['a', 'b\\a']), ['a', 'b\\…']); - assert.deepEqual(labels.shorten(['a\\b\\c', 'd\\b\\c']), ['a\\…', 'd\\…']); - assert.deepEqual(labels.shorten(['a\\b\\c\\d', 'f\\b\\c\\d']), ['a\\…', 'f\\…']); - assert.deepEqual(labels.shorten(['d\\e\\a\\b\\c', 'd\\b\\c']), ['…\\a\\…', 'd\\b\\…']); - assert.deepEqual(labels.shorten(['a\\b\\c\\d', 'a\\f\\b\\c\\d']), ['a\\b\\…', '…\\f\\…']); - assert.deepEqual(labels.shorten(['a\\b\\a', 'b\\b\\a']), ['a\\b\\…', 'b\\b\\…']); - assert.deepEqual(labels.shorten(['d\\f\\a\\b\\c', 'h\\d\\b\\c']), ['…\\a\\…', 'h\\…']); - assert.deepEqual(labels.shorten(['a\\b\\c', 'x:\\0\\a\\b\\c']), ['a\\b\\c', 'x:\\0\\…']); - assert.deepEqual(labels.shorten(['x:\\a\\b\\c', 'x:\\0\\a\\b\\c']), ['x:\\a\\…', 'x:\\0\\…']); - assert.deepEqual(labels.shorten(['x:\\a\\b', 'y:\\a\\b']), ['x:\\…', 'y:\\…']); - assert.deepEqual(labels.shorten(['x:\\a', 'x:\\c']), ['x:\\a', 'x:\\c']); - assert.deepEqual(labels.shorten(['x:\\a\\b', 'y:\\x\\a\\b']), ['x:\\…', 'y:\\…']); - assert.deepEqual(labels.shorten(['\\\\x\\b', '\\\\y\\b']), ['\\\\x\\…', '\\\\y\\…']); - assert.deepEqual(labels.shorten(['\\\\x\\a', '\\\\x\\b']), ['\\\\x\\a', '\\\\x\\b']); + assert.deepStrictEqual(labels.shorten(['a', 'b\\a']), ['a', 'b\\…']); + assert.deepStrictEqual(labels.shorten(['a\\b\\c', 'd\\b\\c']), ['a\\…', 'd\\…']); + assert.deepStrictEqual(labels.shorten(['a\\b\\c\\d', 'f\\b\\c\\d']), ['a\\…', 'f\\…']); + assert.deepStrictEqual(labels.shorten(['d\\e\\a\\b\\c', 'd\\b\\c']), ['…\\a\\…', 'd\\b\\…']); + assert.deepStrictEqual(labels.shorten(['a\\b\\c\\d', 'a\\f\\b\\c\\d']), ['a\\b\\…', '…\\f\\…']); + assert.deepStrictEqual(labels.shorten(['a\\b\\a', 'b\\b\\a']), ['a\\b\\…', 'b\\b\\…']); + assert.deepStrictEqual(labels.shorten(['d\\f\\a\\b\\c', 'h\\d\\b\\c']), ['…\\a\\…', 'h\\…']); + assert.deepStrictEqual(labels.shorten(['a\\b\\c', 'x:\\0\\a\\b\\c']), ['a\\b\\c', 'x:\\0\\…']); + assert.deepStrictEqual(labels.shorten(['x:\\a\\b\\c', 'x:\\0\\a\\b\\c']), ['x:\\a\\…', 'x:\\0\\…']); + assert.deepStrictEqual(labels.shorten(['x:\\a\\b', 'y:\\a\\b']), ['x:\\…', 'y:\\…']); + assert.deepStrictEqual(labels.shorten(['x:\\a', 'x:\\c']), ['x:\\a', 'x:\\c']); + assert.deepStrictEqual(labels.shorten(['x:\\a\\b', 'y:\\x\\a\\b']), ['x:\\…', 'y:\\…']); + assert.deepStrictEqual(labels.shorten(['\\\\x\\b', '\\\\y\\b']), ['\\\\x\\…', '\\\\y\\…']); + assert.deepStrictEqual(labels.shorten(['\\\\x\\a', '\\\\x\\b']), ['\\\\x\\a', '\\\\x\\b']); // same name ending - assert.deepEqual(labels.shorten(['a\\b', 'a\\c', 'a\\e-b']), ['…\\b', '…\\c', '…\\e-b']); + assert.deepStrictEqual(labels.shorten(['a\\b', 'a\\c', 'a\\e-b']), ['…\\b', '…\\c', '…\\e-b']); // same in the middle - assert.deepEqual(labels.shorten(['a\\b\\c', 'd\\b\\e']), ['…\\c', '…\\e']); + assert.deepStrictEqual(labels.shorten(['a\\b\\c', 'd\\b\\e']), ['…\\c', '…\\e']); // case-sensetive - assert.deepEqual(labels.shorten(['a\\b\\c', 'd\\b\\C']), ['…\\c', '…\\C']); + assert.deepStrictEqual(labels.shorten(['a\\b\\c', 'd\\b\\C']), ['…\\c', '…\\C']); // empty or null - assert.deepEqual(labels.shorten(['', null!]), ['.\\', null]); + assert.deepStrictEqual(labels.shorten(['', null!]), ['.\\', null]); - assert.deepEqual(labels.shorten(['a', 'a\\b', 'a\\b\\c', 'd\\b\\c', 'd\\b']), ['a', 'a\\b', 'a\\b\\c', 'd\\b\\c', 'd\\b']); - assert.deepEqual(labels.shorten(['a', 'a\\b', 'b']), ['a', 'a\\b', 'b']); - assert.deepEqual(labels.shorten(['', 'a', 'b', 'b\\c', 'a\\c']), ['.\\', 'a', 'b', 'b\\c', 'a\\c']); - assert.deepEqual(labels.shorten(['src\\vs\\workbench\\parts\\execution\\electron-browser', 'src\\vs\\workbench\\parts\\execution\\electron-browser\\something', 'src\\vs\\workbench\\parts\\terminal\\electron-browser']), ['…\\execution\\electron-browser', '…\\something', '…\\terminal\\…']); + assert.deepStrictEqual(labels.shorten(['a', 'a\\b', 'a\\b\\c', 'd\\b\\c', 'd\\b']), ['a', 'a\\b', 'a\\b\\c', 'd\\b\\c', 'd\\b']); + assert.deepStrictEqual(labels.shorten(['a', 'a\\b', 'b']), ['a', 'a\\b', 'b']); + assert.deepStrictEqual(labels.shorten(['', 'a', 'b', 'b\\c', 'a\\c']), ['.\\', 'a', 'b', 'b\\c', 'a\\c']); + assert.deepStrictEqual(labels.shorten(['src\\vs\\workbench\\parts\\execution\\electron-browser', 'src\\vs\\workbench\\parts\\execution\\electron-browser\\something', 'src\\vs\\workbench\\parts\\terminal\\electron-browser']), ['…\\execution\\electron-browser', '…\\something', '…\\terminal\\…']); }); (platform.isWindows ? test.skip : test)('shorten - not windows', () => { // nothing to shorten - assert.deepEqual(labels.shorten(['a']), ['a']); - assert.deepEqual(labels.shorten(['a', 'b']), ['a', 'b']); - assert.deepEqual(labels.shorten(['a', 'b', 'c']), ['a', 'b', 'c']); + assert.deepStrictEqual(labels.shorten(['a']), ['a']); + assert.deepStrictEqual(labels.shorten(['a', 'b']), ['a', 'b']); + assert.deepStrictEqual(labels.shorten(['a', 'b', 'c']), ['a', 'b', 'c']); // completely different paths - assert.deepEqual(labels.shorten(['a/b', 'c/d', 'e/f']), ['…/b', '…/d', '…/f']); + assert.deepStrictEqual(labels.shorten(['a/b', 'c/d', 'e/f']), ['…/b', '…/d', '…/f']); // same beginning - assert.deepEqual(labels.shorten(['a', 'a/b']), ['a', '…/b']); - assert.deepEqual(labels.shorten(['a/b', 'a/b/c']), ['…/b', '…/c']); - assert.deepEqual(labels.shorten(['a', 'a/b', 'a/b/c']), ['a', '…/b', '…/c']); - assert.deepEqual(labels.shorten(['/a/b', '/a/c']), ['/a/b', '/a/c']); + assert.deepStrictEqual(labels.shorten(['a', 'a/b']), ['a', '…/b']); + assert.deepStrictEqual(labels.shorten(['a/b', 'a/b/c']), ['…/b', '…/c']); + assert.deepStrictEqual(labels.shorten(['a', 'a/b', 'a/b/c']), ['a', '…/b', '…/c']); + assert.deepStrictEqual(labels.shorten(['/a/b', '/a/c']), ['/a/b', '/a/c']); // same ending - assert.deepEqual(labels.shorten(['a', 'b/a']), ['a', 'b/…']); - assert.deepEqual(labels.shorten(['a/b/c', 'd/b/c']), ['a/…', 'd/…']); - assert.deepEqual(labels.shorten(['a/b/c/d', 'f/b/c/d']), ['a/…', 'f/…']); - assert.deepEqual(labels.shorten(['d/e/a/b/c', 'd/b/c']), ['…/a/…', 'd/b/…']); - assert.deepEqual(labels.shorten(['a/b/c/d', 'a/f/b/c/d']), ['a/b/…', '…/f/…']); - assert.deepEqual(labels.shorten(['a/b/a', 'b/b/a']), ['a/b/…', 'b/b/…']); - assert.deepEqual(labels.shorten(['d/f/a/b/c', 'h/d/b/c']), ['…/a/…', 'h/…']); - assert.deepEqual(labels.shorten(['/x/b', '/y/b']), ['/x/…', '/y/…']); + assert.deepStrictEqual(labels.shorten(['a', 'b/a']), ['a', 'b/…']); + assert.deepStrictEqual(labels.shorten(['a/b/c', 'd/b/c']), ['a/…', 'd/…']); + assert.deepStrictEqual(labels.shorten(['a/b/c/d', 'f/b/c/d']), ['a/…', 'f/…']); + assert.deepStrictEqual(labels.shorten(['d/e/a/b/c', 'd/b/c']), ['…/a/…', 'd/b/…']); + assert.deepStrictEqual(labels.shorten(['a/b/c/d', 'a/f/b/c/d']), ['a/b/…', '…/f/…']); + assert.deepStrictEqual(labels.shorten(['a/b/a', 'b/b/a']), ['a/b/…', 'b/b/…']); + assert.deepStrictEqual(labels.shorten(['d/f/a/b/c', 'h/d/b/c']), ['…/a/…', 'h/…']); + assert.deepStrictEqual(labels.shorten(['/x/b', '/y/b']), ['/x/…', '/y/…']); // same name ending - assert.deepEqual(labels.shorten(['a/b', 'a/c', 'a/e-b']), ['…/b', '…/c', '…/e-b']); + assert.deepStrictEqual(labels.shorten(['a/b', 'a/c', 'a/e-b']), ['…/b', '…/c', '…/e-b']); // same in the middle - assert.deepEqual(labels.shorten(['a/b/c', 'd/b/e']), ['…/c', '…/e']); + assert.deepStrictEqual(labels.shorten(['a/b/c', 'd/b/e']), ['…/c', '…/e']); // case-sensitive - assert.deepEqual(labels.shorten(['a/b/c', 'd/b/C']), ['…/c', '…/C']); + assert.deepStrictEqual(labels.shorten(['a/b/c', 'd/b/C']), ['…/c', '…/C']); // empty or null - assert.deepEqual(labels.shorten(['', null!]), ['./', null]); + assert.deepStrictEqual(labels.shorten(['', null!]), ['./', null]); - assert.deepEqual(labels.shorten(['a', 'a/b', 'a/b/c', 'd/b/c', 'd/b']), ['a', 'a/b', 'a/b/c', 'd/b/c', 'd/b']); - assert.deepEqual(labels.shorten(['a', 'a/b', 'b']), ['a', 'a/b', 'b']); - assert.deepEqual(labels.shorten(['', 'a', 'b', 'b/c', 'a/c']), ['./', 'a', 'b', 'b/c', 'a/c']); + assert.deepStrictEqual(labels.shorten(['a', 'a/b', 'a/b/c', 'd/b/c', 'd/b']), ['a', 'a/b', 'a/b/c', 'd/b/c', 'd/b']); + assert.deepStrictEqual(labels.shorten(['a', 'a/b', 'b']), ['a', 'a/b', 'b']); + assert.deepStrictEqual(labels.shorten(['', 'a', 'b', 'b/c', 'a/c']), ['./', 'a', 'b', 'b/c', 'a/c']); }); test('template', () => { @@ -135,31 +135,31 @@ suite('Labels', () => { }); (platform.isWindows ? test.skip : test)('getBaseLabel - unix', () => { - assert.equal(labels.getBaseLabel('/some/folder/file.txt'), 'file.txt'); - assert.equal(labels.getBaseLabel('/some/folder'), 'folder'); - assert.equal(labels.getBaseLabel('/'), '/'); + assert.strictEqual(labels.getBaseLabel('/some/folder/file.txt'), 'file.txt'); + assert.strictEqual(labels.getBaseLabel('/some/folder'), 'folder'); + assert.strictEqual(labels.getBaseLabel('/'), '/'); }); (!platform.isWindows ? test.skip : test)('getBaseLabel - windows', () => { - assert.equal(labels.getBaseLabel('c:'), 'C:'); - assert.equal(labels.getBaseLabel('c:\\'), 'C:'); - assert.equal(labels.getBaseLabel('c:\\some\\folder\\file.txt'), 'file.txt'); - assert.equal(labels.getBaseLabel('c:\\some\\folder'), 'folder'); - assert.equal(labels.getBaseLabel('c:\\some\\f:older'), 'f:older'); // https://github.com/microsoft/vscode-remote-release/issues/4227 + assert.strictEqual(labels.getBaseLabel('c:'), 'C:'); + assert.strictEqual(labels.getBaseLabel('c:\\'), 'C:'); + assert.strictEqual(labels.getBaseLabel('c:\\some\\folder\\file.txt'), 'file.txt'); + assert.strictEqual(labels.getBaseLabel('c:\\some\\folder'), 'folder'); + assert.strictEqual(labels.getBaseLabel('c:\\some\\f:older'), 'f:older'); // https://github.com/microsoft/vscode-remote-release/issues/4227 }); test('mnemonicButtonLabel', () => { - assert.equal(labels.mnemonicButtonLabel('Hello World'), 'Hello World'); - assert.equal(labels.mnemonicButtonLabel(''), ''); + assert.strictEqual(labels.mnemonicButtonLabel('Hello World'), 'Hello World'); + assert.strictEqual(labels.mnemonicButtonLabel(''), ''); if (platform.isWindows) { - assert.equal(labels.mnemonicButtonLabel('Hello & World'), 'Hello && World'); - assert.equal(labels.mnemonicButtonLabel('Do &¬ Save & Continue'), 'Do ¬ Save && Continue'); + assert.strictEqual(labels.mnemonicButtonLabel('Hello & World'), 'Hello && World'); + assert.strictEqual(labels.mnemonicButtonLabel('Do &¬ Save & Continue'), 'Do ¬ Save && Continue'); } else if (platform.isMacintosh) { - assert.equal(labels.mnemonicButtonLabel('Hello & World'), 'Hello & World'); - assert.equal(labels.mnemonicButtonLabel('Do &¬ Save & Continue'), 'Do not Save & Continue'); + assert.strictEqual(labels.mnemonicButtonLabel('Hello & World'), 'Hello & World'); + assert.strictEqual(labels.mnemonicButtonLabel('Do &¬ Save & Continue'), 'Do not Save & Continue'); } else { - assert.equal(labels.mnemonicButtonLabel('Hello & World'), 'Hello & World'); - assert.equal(labels.mnemonicButtonLabel('Do &¬ Save & Continue'), 'Do _not Save & Continue'); + assert.strictEqual(labels.mnemonicButtonLabel('Hello & World'), 'Hello & World'); + assert.strictEqual(labels.mnemonicButtonLabel('Do &¬ Save & Continue'), 'Do _not Save & Continue'); } }); }); diff --git a/src/vs/base/test/common/mime.test.ts b/src/vs/base/test/common/mime.test.ts index a7ac5a177a6a57c51ee98565e2cea83635cdc82a..f2583fed404c31973328c276787ccdd5ae11d7bb 100644 --- a/src/vs/base/test/common/mime.test.ts +++ b/src/vs/base/test/common/mime.test.ts @@ -11,38 +11,38 @@ suite('Mime', () => { test('Dynamically Register Text Mime', () => { let guess = guessMimeTypes(URI.file('foo.monaco')); - assert.deepEqual(guess, ['application/unknown']); + assert.deepStrictEqual(guess, ['application/unknown']); registerTextMime({ id: 'monaco', extension: '.monaco', mime: 'text/monaco' }); guess = guessMimeTypes(URI.file('foo.monaco')); - assert.deepEqual(guess, ['text/monaco', 'text/plain']); + assert.deepStrictEqual(guess, ['text/monaco', 'text/plain']); guess = guessMimeTypes(URI.file('.monaco')); - assert.deepEqual(guess, ['text/monaco', 'text/plain']); + assert.deepStrictEqual(guess, ['text/monaco', 'text/plain']); registerTextMime({ id: 'codefile', filename: 'Codefile', mime: 'text/code' }); guess = guessMimeTypes(URI.file('Codefile')); - assert.deepEqual(guess, ['text/code', 'text/plain']); + assert.deepStrictEqual(guess, ['text/code', 'text/plain']); guess = guessMimeTypes(URI.file('foo.Codefile')); - assert.deepEqual(guess, ['application/unknown']); + assert.deepStrictEqual(guess, ['application/unknown']); registerTextMime({ id: 'docker', filepattern: 'Docker*', mime: 'text/docker' }); guess = guessMimeTypes(URI.file('Docker-debug')); - assert.deepEqual(guess, ['text/docker', 'text/plain']); + assert.deepStrictEqual(guess, ['text/docker', 'text/plain']); guess = guessMimeTypes(URI.file('docker-PROD')); - assert.deepEqual(guess, ['text/docker', 'text/plain']); + assert.deepStrictEqual(guess, ['text/docker', 'text/plain']); registerTextMime({ id: 'niceregex', mime: 'text/nice-regex', firstline: /RegexesAreNice/ }); guess = guessMimeTypes(URI.file('Randomfile.noregistration'), 'RegexesAreNice'); - assert.deepEqual(guess, ['text/nice-regex', 'text/plain']); + assert.deepStrictEqual(guess, ['text/nice-regex', 'text/plain']); guess = guessMimeTypes(URI.file('Randomfile.noregistration'), 'RegexesAreNotNice'); - assert.deepEqual(guess, ['application/unknown']); + assert.deepStrictEqual(guess, ['application/unknown']); guess = guessMimeTypes(URI.file('Codefile'), 'RegexesAreNice'); - assert.deepEqual(guess, ['text/code', 'text/plain']); + assert.deepStrictEqual(guess, ['text/code', 'text/plain']); }); test('Mimes Priority', () => { @@ -50,36 +50,36 @@ suite('Mime', () => { registerTextMime({ id: 'foobar', mime: 'text/foobar', firstline: /foobar/ }); let guess = guessMimeTypes(URI.file('foo.monaco')); - assert.deepEqual(guess, ['text/monaco', 'text/plain']); + assert.deepStrictEqual(guess, ['text/monaco', 'text/plain']); guess = guessMimeTypes(URI.file('foo.monaco'), 'foobar'); - assert.deepEqual(guess, ['text/monaco', 'text/plain']); + assert.deepStrictEqual(guess, ['text/monaco', 'text/plain']); registerTextMime({ id: 'docker', filename: 'dockerfile', mime: 'text/winner' }); registerTextMime({ id: 'docker', filepattern: 'dockerfile*', mime: 'text/looser' }); guess = guessMimeTypes(URI.file('dockerfile')); - assert.deepEqual(guess, ['text/winner', 'text/plain']); + assert.deepStrictEqual(guess, ['text/winner', 'text/plain']); registerTextMime({ id: 'azure-looser', mime: 'text/azure-looser', firstline: /azure/ }); registerTextMime({ id: 'azure-winner', mime: 'text/azure-winner', firstline: /azure/ }); guess = guessMimeTypes(URI.file('azure'), 'azure'); - assert.deepEqual(guess, ['text/azure-winner', 'text/plain']); + assert.deepStrictEqual(guess, ['text/azure-winner', 'text/plain']); }); test('Specificity priority 1', () => { registerTextMime({ id: 'monaco2', extension: '.monaco2', mime: 'text/monaco2' }); registerTextMime({ id: 'monaco2', filename: 'specific.monaco2', mime: 'text/specific-monaco2' }); - assert.deepEqual(guessMimeTypes(URI.file('specific.monaco2')), ['text/specific-monaco2', 'text/plain']); - assert.deepEqual(guessMimeTypes(URI.file('foo.monaco2')), ['text/monaco2', 'text/plain']); + assert.deepStrictEqual(guessMimeTypes(URI.file('specific.monaco2')), ['text/specific-monaco2', 'text/plain']); + assert.deepStrictEqual(guessMimeTypes(URI.file('foo.monaco2')), ['text/monaco2', 'text/plain']); }); test('Specificity priority 2', () => { registerTextMime({ id: 'monaco3', filename: 'specific.monaco3', mime: 'text/specific-monaco3' }); registerTextMime({ id: 'monaco3', extension: '.monaco3', mime: 'text/monaco3' }); - assert.deepEqual(guessMimeTypes(URI.file('specific.monaco3')), ['text/specific-monaco3', 'text/plain']); - assert.deepEqual(guessMimeTypes(URI.file('foo.monaco3')), ['text/monaco3', 'text/plain']); + assert.deepStrictEqual(guessMimeTypes(URI.file('specific.monaco3')), ['text/specific-monaco3', 'text/plain']); + assert.deepStrictEqual(guessMimeTypes(URI.file('foo.monaco3')), ['text/monaco3', 'text/plain']); }); test('Mimes Priority - Longest Extension wins', () => { @@ -88,13 +88,13 @@ suite('Mime', () => { registerTextMime({ id: 'monaco', extension: '.monaco.xml.build', mime: 'text/monaco-xml-build' }); let guess = guessMimeTypes(URI.file('foo.monaco')); - assert.deepEqual(guess, ['text/monaco', 'text/plain']); + assert.deepStrictEqual(guess, ['text/monaco', 'text/plain']); guess = guessMimeTypes(URI.file('foo.monaco.xml')); - assert.deepEqual(guess, ['text/monaco-xml', 'text/plain']); + assert.deepStrictEqual(guess, ['text/monaco-xml', 'text/plain']); guess = guessMimeTypes(URI.file('foo.monaco.xml.build')); - assert.deepEqual(guess, ['text/monaco-xml-build', 'text/plain']); + assert.deepStrictEqual(guess, ['text/monaco-xml-build', 'text/plain']); }); test('Mimes Priority - User configured wins', () => { @@ -102,7 +102,7 @@ suite('Mime', () => { registerTextMime({ id: 'monaco', extension: '.monaco.xml', mime: 'text/monaco-xml' }); let guess = guessMimeTypes(URI.file('foo.monaco.xnl')); - assert.deepEqual(guess, ['text/monaco', 'text/plain']); + assert.deepStrictEqual(guess, ['text/monaco', 'text/plain']); }); test('Mimes Priority - Pattern matches on path if specified', () => { @@ -110,7 +110,7 @@ suite('Mime', () => { registerTextMime({ id: 'other', filepattern: '*ot.other.xml', mime: 'text/other' }); let guess = guessMimeTypes(URI.file('/some/path/dot.monaco.xml')); - assert.deepEqual(guess, ['text/monaco', 'text/plain']); + assert.deepStrictEqual(guess, ['text/monaco', 'text/plain']); }); test('Mimes Priority - Last registered mime wins', () => { @@ -118,12 +118,12 @@ suite('Mime', () => { registerTextMime({ id: 'other', filepattern: '**/dot.monaco.xml', mime: 'text/other' }); let guess = guessMimeTypes(URI.file('/some/path/dot.monaco.xml')); - assert.deepEqual(guess, ['text/other', 'text/plain']); + assert.deepStrictEqual(guess, ['text/other', 'text/plain']); }); test('Data URIs', () => { registerTextMime({ id: 'data', extension: '.data', mime: 'text/data' }); - assert.deepEqual(guessMimeTypes(URI.parse(`data:;label:something.data;description:data,`)), ['text/data', 'text/plain']); + assert.deepStrictEqual(guessMimeTypes(URI.parse(`data:;label:something.data;description:data,`)), ['text/data', 'text/plain']); }); }); diff --git a/src/vs/base/test/common/stream.test.ts b/src/vs/base/test/common/stream.test.ts index 0efecf7224dfc6413cda376ef74d29e192a73a7b..0fb36467b2ff047e503b85f3bce6350c6ff015f7 100644 --- a/src/vs/base/test/common/stream.test.ts +++ b/src/vs/base/test/common/stream.test.ts @@ -43,37 +43,37 @@ suite('Stream', () => { chunks.push(data); }); - assert.equal(chunks[0], 'Hello'); + assert.strictEqual(chunks[0], 'Hello'); stream.write('World'); - assert.equal(chunks[1], 'World'); + assert.strictEqual(chunks[1], 'World'); - assert.equal(error, false); - assert.equal(end, false); + assert.strictEqual(error, false); + assert.strictEqual(end, false); stream.pause(); stream.write('1'); stream.write('2'); stream.write('3'); - assert.equal(chunks.length, 2); + assert.strictEqual(chunks.length, 2); stream.resume(); - assert.equal(chunks.length, 3); - assert.equal(chunks[2], '1,2,3'); + assert.strictEqual(chunks.length, 3); + assert.strictEqual(chunks[2], '1,2,3'); stream.error(new Error()); - assert.equal(error, true); + assert.strictEqual(error, true); stream.end('Final Bit'); - assert.equal(chunks.length, 4); - assert.equal(chunks[3], 'Final Bit'); + assert.strictEqual(chunks.length, 4); + assert.strictEqual(chunks[3], 'Final Bit'); stream.destroy(); stream.write('Unexpected'); - assert.equal(chunks.length, 4); + assert.strictEqual(chunks.length, 4); }); test('WriteableStream - removeListener', () => { @@ -92,16 +92,16 @@ suite('Stream', () => { stream.on('data', dataListener); stream.write('Hello'); - assert.equal(data, true); + assert.strictEqual(data, true); data = false; stream.removeListener('data', dataListener); stream.write('World'); - assert.equal(data, false); + assert.strictEqual(data, false); stream.error(new Error()); - assert.equal(error, true); + assert.strictEqual(error, true); error = false; stream.removeListener('error', errorListener); @@ -109,7 +109,7 @@ suite('Stream', () => { // always leave at least one error listener to streams to avoid unexpected errors during test running stream.on('error', () => { }); stream.error(new Error()); - assert.equal(error, false); + assert.strictEqual(error, false); }); test('WriteableStream - highWaterMark', async () => { @@ -149,14 +149,14 @@ suite('Stream', () => { assert.ok(data); await timeout(0); - assert.equal(drained1, true); - assert.equal(drained2, true); + assert.strictEqual(drained1, true); + assert.strictEqual(drained2, true); }); test('consumeReadable', () => { const readable = arrayToReadable(['1', '2', '3', '4', '5']); const consumed = consumeReadable(readable, strings => strings.join()); - assert.equal(consumed, '1,2,3,4,5'); + assert.strictEqual(consumed, '1,2,3,4,5'); }); test('peekReadable', () => { @@ -168,17 +168,17 @@ suite('Stream', () => { assert.fail('Unexpected result'); } else { const consumed = consumeReadable(consumedOrReadable, strings => strings.join()); - assert.equal(consumed, '1,2,3,4,5'); + assert.strictEqual(consumed, '1,2,3,4,5'); } } let readable = arrayToReadable(['1', '2', '3', '4', '5']); let consumedOrReadable = peekReadable(readable, strings => strings.join(), 5); - assert.equal(consumedOrReadable, '1,2,3,4,5'); + assert.strictEqual(consumedOrReadable, '1,2,3,4,5'); readable = arrayToReadable(['1', '2', '3', '4', '5']); consumedOrReadable = peekReadable(readable, strings => strings.join(), 6); - assert.equal(consumedOrReadable, '1,2,3,4,5'); + assert.strictEqual(consumedOrReadable, '1,2,3,4,5'); }); test('peekReadable - error handling', async () => { @@ -267,7 +267,7 @@ suite('Stream', () => { test('consumeStream', async () => { const stream = readableToStream(arrayToReadable(['1', '2', '3', '4', '5'])); const consumed = await consumeStream(stream, strings => strings.join()); - assert.equal(consumed, '1,2,3,4,5'); + assert.strictEqual(consumed, '1,2,3,4,5'); }); test('peekStream', async () => { @@ -275,11 +275,11 @@ suite('Stream', () => { const stream = readableToStream(arrayToReadable(['1', '2', '3', '4', '5'])); const result = await peekStream(stream, i); - assert.equal(stream, result.stream); + assert.strictEqual(stream, result.stream); if (result.ended) { assert.fail('Unexpected result, stream should not have ended yet'); } else { - assert.equal(result.buffer.length, i + 1, `maxChunks: ${i}`); + assert.strictEqual(result.buffer.length, i + 1, `maxChunks: ${i}`); const additionalResult: string[] = []; await consumeStream(stream, strings => { @@ -288,33 +288,33 @@ suite('Stream', () => { return strings.join(); }); - assert.equal([...result.buffer, ...additionalResult].join(), '1,2,3,4,5'); + assert.strictEqual([...result.buffer, ...additionalResult].join(), '1,2,3,4,5'); } } let stream = readableToStream(arrayToReadable(['1', '2', '3', '4', '5'])); let result = await peekStream(stream, 5); - assert.equal(stream, result.stream); - assert.equal(result.buffer.join(), '1,2,3,4,5'); - assert.equal(result.ended, true); + assert.strictEqual(stream, result.stream); + assert.strictEqual(result.buffer.join(), '1,2,3,4,5'); + assert.strictEqual(result.ended, true); stream = readableToStream(arrayToReadable(['1', '2', '3', '4', '5'])); result = await peekStream(stream, 6); - assert.equal(stream, result.stream); - assert.equal(result.buffer.join(), '1,2,3,4,5'); - assert.equal(result.ended, true); + assert.strictEqual(stream, result.stream); + assert.strictEqual(result.buffer.join(), '1,2,3,4,5'); + assert.strictEqual(result.ended, true); }); test('toStream', async () => { const stream = toStream('1,2,3,4,5', strings => strings.join()); const consumed = await consumeStream(stream, strings => strings.join()); - assert.equal(consumed, '1,2,3,4,5'); + assert.strictEqual(consumed, '1,2,3,4,5'); }); test('toReadable', async () => { const readable = toReadable('1,2,3,4,5'); const consumed = await consumeReadable(readable, strings => strings.join()); - assert.equal(consumed, '1,2,3,4,5'); + assert.strictEqual(consumed, '1,2,3,4,5'); }); test('transform', async () => { @@ -332,7 +332,7 @@ suite('Stream', () => { }, 0); const consumed = await consumeStream(result, strings => strings.join()); - assert.equal(consumed, '11,22,33,44,55'); + assert.strictEqual(consumed, '11,22,33,44,55'); }); test('observer', async () => { diff --git a/src/vs/base/test/common/types.test.ts b/src/vs/base/test/common/types.test.ts index 32e276c1dd5ed1a587bcaecc5899b6016ff7e407..cb7dedbe27243a7d12a60b815ce73e2499ee871f 100644 --- a/src/vs/base/test/common/types.test.ts +++ b/src/vs/base/test/common/types.test.ts @@ -178,15 +178,15 @@ suite('Types', () => { assert.throws(() => types.assertAllDefined(true, undefined)); assert.throws(() => types.assertAllDefined(undefined, false)); - assert.equal(types.assertIsDefined(true), true); - assert.equal(types.assertIsDefined(false), false); - assert.equal(types.assertIsDefined('Hello'), 'Hello'); - assert.equal(types.assertIsDefined(''), ''); + assert.strictEqual(types.assertIsDefined(true), true); + assert.strictEqual(types.assertIsDefined(false), false); + assert.strictEqual(types.assertIsDefined('Hello'), 'Hello'); + assert.strictEqual(types.assertIsDefined(''), ''); const res = types.assertAllDefined(1, true, 'Hello'); - assert.equal(res[0], 1); - assert.equal(res[1], true); - assert.equal(res[2], 'Hello'); + assert.strictEqual(res[0], 1); + assert.strictEqual(res[1], true); + assert.strictEqual(res[2], 'Hello'); }); test('validateConstraints', () => { diff --git a/src/vs/base/test/node/decoder.test.ts b/src/vs/base/test/node/decoder.test.ts index 199cef9a7bfef4c5350c4f4eba3e5412a31ecde9..aa2e867c741d1f6a4a60c008c60759b47735307f 100644 --- a/src/vs/base/test/node/decoder.test.ts +++ b/src/vs/base/test/node/decoder.test.ts @@ -11,12 +11,12 @@ suite('Decoder', () => { test('decoding', () => { const lineDecoder = new LineDecoder(); let res = lineDecoder.write(Buffer.from('hello')); - assert.equal(res.length, 0); + assert.strictEqual(res.length, 0); res = lineDecoder.write(Buffer.from('\nworld')); - assert.equal(res[0], 'hello'); - assert.equal(res.length, 1); + assert.strictEqual(res[0], 'hello'); + assert.strictEqual(res.length, 1); - assert.equal(lineDecoder.end(), 'world'); + assert.strictEqual(lineDecoder.end(), 'world'); }); }); diff --git a/src/vs/base/test/node/extpath.test.ts b/src/vs/base/test/node/extpath.test.ts index 0ed8864d88dd2dea140b5a380413327aed7241a4..4ca7b3c61a5bdd90f26e24f83bb46f36074a6494 100644 --- a/src/vs/base/test/node/extpath.test.ts +++ b/src/vs/base/test/node/extpath.test.ts @@ -30,16 +30,16 @@ flakySuite('Extpath', () => { const real = realcaseSync(upper); if (real) { // can be null in case of permission errors - assert.notEqual(real, upper); - assert.equal(real.toUpperCase(), upper); - assert.equal(real, testDir); + assert.notStrictEqual(real, upper); + assert.strictEqual(real.toUpperCase(), upper); + assert.strictEqual(real, testDir); } } // linux, unix, etc. -> assume case sensitive file system else { const real = realcaseSync(testDir); - assert.equal(real, testDir); + assert.strictEqual(real, testDir); } }); diff --git a/src/vs/platform/environment/test/node/environmentService.test.ts b/src/vs/platform/environment/test/node/environmentService.test.ts index d30dc8a688b7946344c812de7a8a6b50895a0bd3..ca33c22600d614b37caf8589da39a30901a8c4bd 100644 --- a/src/vs/platform/environment/test/node/environmentService.test.ts +++ b/src/vs/platform/environment/test/node/environmentService.test.ts @@ -13,35 +13,35 @@ suite('EnvironmentService', () => { test('parseExtensionHostPort when built', () => { const parse = (a: string[]) => parseExtensionHostPort(parseArgs(a, OPTIONS), true); - assert.deepEqual(parse([]), { port: null, break: false, debugId: undefined }); - assert.deepEqual(parse(['--debugPluginHost']), { port: null, break: false, debugId: undefined }); - assert.deepEqual(parse(['--debugPluginHost=1234']), { port: 1234, break: false, debugId: undefined }); - assert.deepEqual(parse(['--debugBrkPluginHost']), { port: null, break: false, debugId: undefined }); - assert.deepEqual(parse(['--debugBrkPluginHost=5678']), { port: 5678, break: true, debugId: undefined }); - assert.deepEqual(parse(['--debugPluginHost=1234', '--debugBrkPluginHost=5678', '--debugId=7']), { port: 5678, break: true, debugId: '7' }); + assert.deepStrictEqual(parse([]), { port: null, break: false, debugId: undefined }); + assert.deepStrictEqual(parse(['--debugPluginHost']), { port: null, break: false, debugId: undefined }); + assert.deepStrictEqual(parse(['--debugPluginHost=1234']), { port: 1234, break: false, debugId: undefined }); + assert.deepStrictEqual(parse(['--debugBrkPluginHost']), { port: null, break: false, debugId: undefined }); + assert.deepStrictEqual(parse(['--debugBrkPluginHost=5678']), { port: 5678, break: true, debugId: undefined }); + assert.deepStrictEqual(parse(['--debugPluginHost=1234', '--debugBrkPluginHost=5678', '--debugId=7']), { port: 5678, break: true, debugId: '7' }); - assert.deepEqual(parse(['--inspect-extensions']), { port: null, break: false, debugId: undefined }); - assert.deepEqual(parse(['--inspect-extensions=1234']), { port: 1234, break: false, debugId: undefined }); - assert.deepEqual(parse(['--inspect-brk-extensions']), { port: null, break: false, debugId: undefined }); - assert.deepEqual(parse(['--inspect-brk-extensions=5678']), { port: 5678, break: true, debugId: undefined }); - assert.deepEqual(parse(['--inspect-extensions=1234', '--inspect-brk-extensions=5678', '--debugId=7']), { port: 5678, break: true, debugId: '7' }); + assert.deepStrictEqual(parse(['--inspect-extensions']), { port: null, break: false, debugId: undefined }); + assert.deepStrictEqual(parse(['--inspect-extensions=1234']), { port: 1234, break: false, debugId: undefined }); + assert.deepStrictEqual(parse(['--inspect-brk-extensions']), { port: null, break: false, debugId: undefined }); + assert.deepStrictEqual(parse(['--inspect-brk-extensions=5678']), { port: 5678, break: true, debugId: undefined }); + assert.deepStrictEqual(parse(['--inspect-extensions=1234', '--inspect-brk-extensions=5678', '--debugId=7']), { port: 5678, break: true, debugId: '7' }); }); test('parseExtensionHostPort when unbuilt', () => { const parse = (a: string[]) => parseExtensionHostPort(parseArgs(a, OPTIONS), false); - assert.deepEqual(parse([]), { port: 5870, break: false, debugId: undefined }); - assert.deepEqual(parse(['--debugPluginHost']), { port: 5870, break: false, debugId: undefined }); - assert.deepEqual(parse(['--debugPluginHost=1234']), { port: 1234, break: false, debugId: undefined }); - assert.deepEqual(parse(['--debugBrkPluginHost']), { port: 5870, break: false, debugId: undefined }); - assert.deepEqual(parse(['--debugBrkPluginHost=5678']), { port: 5678, break: true, debugId: undefined }); - assert.deepEqual(parse(['--debugPluginHost=1234', '--debugBrkPluginHost=5678', '--debugId=7']), { port: 5678, break: true, debugId: '7' }); + assert.deepStrictEqual(parse([]), { port: 5870, break: false, debugId: undefined }); + assert.deepStrictEqual(parse(['--debugPluginHost']), { port: 5870, break: false, debugId: undefined }); + assert.deepStrictEqual(parse(['--debugPluginHost=1234']), { port: 1234, break: false, debugId: undefined }); + assert.deepStrictEqual(parse(['--debugBrkPluginHost']), { port: 5870, break: false, debugId: undefined }); + assert.deepStrictEqual(parse(['--debugBrkPluginHost=5678']), { port: 5678, break: true, debugId: undefined }); + assert.deepStrictEqual(parse(['--debugPluginHost=1234', '--debugBrkPluginHost=5678', '--debugId=7']), { port: 5678, break: true, debugId: '7' }); - assert.deepEqual(parse(['--inspect-extensions']), { port: 5870, break: false, debugId: undefined }); - assert.deepEqual(parse(['--inspect-extensions=1234']), { port: 1234, break: false, debugId: undefined }); - assert.deepEqual(parse(['--inspect-brk-extensions']), { port: 5870, break: false, debugId: undefined }); - assert.deepEqual(parse(['--inspect-brk-extensions=5678']), { port: 5678, break: true, debugId: undefined }); - assert.deepEqual(parse(['--inspect-extensions=1234', '--inspect-brk-extensions=5678', '--debugId=7']), { port: 5678, break: true, debugId: '7' }); + assert.deepStrictEqual(parse(['--inspect-extensions']), { port: 5870, break: false, debugId: undefined }); + assert.deepStrictEqual(parse(['--inspect-extensions=1234']), { port: 1234, break: false, debugId: undefined }); + assert.deepStrictEqual(parse(['--inspect-brk-extensions']), { port: 5870, break: false, debugId: undefined }); + assert.deepStrictEqual(parse(['--inspect-brk-extensions=5678']), { port: 5678, break: true, debugId: undefined }); + assert.deepStrictEqual(parse(['--inspect-extensions=1234', '--inspect-brk-extensions=5678', '--debugId=7']), { port: 5678, break: true, debugId: '7' }); }); test('userDataPath', () => { @@ -57,10 +57,10 @@ suite('EnvironmentService', () => { test('careful with boolean file names', function () { let actual = parseArgs(['-r', 'arg.txt'], OPTIONS); assert(actual['reuse-window']); - assert.deepEqual(actual._, ['arg.txt']); + assert.deepStrictEqual(actual._, ['arg.txt']); actual = parseArgs(['-r', 'true.txt'], OPTIONS); assert(actual['reuse-window']); - assert.deepEqual(actual._, ['true.txt']); + assert.deepStrictEqual(actual._, ['true.txt']); }); }); diff --git a/src/vs/platform/files/node/watcher/nsfw/test/nsfwWatcherService.test.ts b/src/vs/platform/files/node/watcher/nsfw/test/nsfwWatcherService.test.ts index 9ad083fc9a87c65f8147d79b30582ae614cea928..0469c3f63a349e20aa45a96bf38466b07f7512ca 100644 --- a/src/vs/platform/files/node/watcher/nsfw/test/nsfwWatcherService.test.ts +++ b/src/vs/platform/files/node/watcher/nsfw/test/nsfwWatcherService.test.ts @@ -30,28 +30,28 @@ suite('NSFW Watcher Service', async () => { test('should not impacts roots that don\'t overlap', () => { const service = new TestNsfwWatcherService(); if (platform.isWindows) { - assert.deepEqual(service.normalizeRoots(['C:\\a']), ['C:\\a']); - assert.deepEqual(service.normalizeRoots(['C:\\a', 'C:\\b']), ['C:\\a', 'C:\\b']); - assert.deepEqual(service.normalizeRoots(['C:\\a', 'C:\\b', 'C:\\c\\d\\e']), ['C:\\a', 'C:\\b', 'C:\\c\\d\\e']); + assert.deepStrictEqual(service.normalizeRoots(['C:\\a']), ['C:\\a']); + assert.deepStrictEqual(service.normalizeRoots(['C:\\a', 'C:\\b']), ['C:\\a', 'C:\\b']); + assert.deepStrictEqual(service.normalizeRoots(['C:\\a', 'C:\\b', 'C:\\c\\d\\e']), ['C:\\a', 'C:\\b', 'C:\\c\\d\\e']); } else { - assert.deepEqual(service.normalizeRoots(['/a']), ['/a']); - assert.deepEqual(service.normalizeRoots(['/a', '/b']), ['/a', '/b']); - assert.deepEqual(service.normalizeRoots(['/a', '/b', '/c/d/e']), ['/a', '/b', '/c/d/e']); + assert.deepStrictEqual(service.normalizeRoots(['/a']), ['/a']); + assert.deepStrictEqual(service.normalizeRoots(['/a', '/b']), ['/a', '/b']); + assert.deepStrictEqual(service.normalizeRoots(['/a', '/b', '/c/d/e']), ['/a', '/b', '/c/d/e']); } }); test('should remove sub-folders of other roots', () => { const service = new TestNsfwWatcherService(); if (platform.isWindows) { - assert.deepEqual(service.normalizeRoots(['C:\\a', 'C:\\a\\b']), ['C:\\a']); - assert.deepEqual(service.normalizeRoots(['C:\\a', 'C:\\b', 'C:\\a\\b']), ['C:\\a', 'C:\\b']); - assert.deepEqual(service.normalizeRoots(['C:\\b\\a', 'C:\\a', 'C:\\b', 'C:\\a\\b']), ['C:\\a', 'C:\\b']); - assert.deepEqual(service.normalizeRoots(['C:\\a', 'C:\\a\\b', 'C:\\a\\c\\d']), ['C:\\a']); + assert.deepStrictEqual(service.normalizeRoots(['C:\\a', 'C:\\a\\b']), ['C:\\a']); + assert.deepStrictEqual(service.normalizeRoots(['C:\\a', 'C:\\b', 'C:\\a\\b']), ['C:\\a', 'C:\\b']); + assert.deepStrictEqual(service.normalizeRoots(['C:\\b\\a', 'C:\\a', 'C:\\b', 'C:\\a\\b']), ['C:\\a', 'C:\\b']); + assert.deepStrictEqual(service.normalizeRoots(['C:\\a', 'C:\\a\\b', 'C:\\a\\c\\d']), ['C:\\a']); } else { - assert.deepEqual(service.normalizeRoots(['/a', '/a/b']), ['/a']); - assert.deepEqual(service.normalizeRoots(['/a', '/b', '/a/b']), ['/a', '/b']); - assert.deepEqual(service.normalizeRoots(['/b/a', '/a', '/b', '/a/b']), ['/a', '/b']); - assert.deepEqual(service.normalizeRoots(['/a', '/a/b', '/a/c/d']), ['/a']); + assert.deepStrictEqual(service.normalizeRoots(['/a', '/a/b']), ['/a']); + assert.deepStrictEqual(service.normalizeRoots(['/a', '/b', '/a/b']), ['/a', '/b']); + assert.deepStrictEqual(service.normalizeRoots(['/b/a', '/a', '/b', '/a/b']), ['/a', '/b']); + assert.deepStrictEqual(service.normalizeRoots(['/a', '/a/b', '/a/c/d']), ['/a']); } }); }); diff --git a/src/vs/platform/files/node/watcher/unix/test/chockidarWatcherService.test.ts b/src/vs/platform/files/node/watcher/unix/test/chockidarWatcherService.test.ts index 4c780ec6b60e4c7400f1ac7c88f27aed9fb83c22..8b475de9a0bbe5bb7a8e539cbe1637d8bf5017f1 100644 --- a/src/vs/platform/files/node/watcher/unix/test/chockidarWatcherService.test.ts +++ b/src/vs/platform/files/node/watcher/unix/test/chockidarWatcherService.test.ts @@ -20,18 +20,18 @@ suite('Chokidar normalizeRoots', async () => { function assertNormalizedRootPath(inputPaths: string[], expectedPaths: string[]) { const requests = inputPaths.map(path => newRequest(path)); const actual = normalizeRoots(requests); - assert.deepEqual(Object.keys(actual).sort(), expectedPaths); + assert.deepStrictEqual(Object.keys(actual).sort(), expectedPaths); } function assertNormalizedRequests(inputRequests: IWatcherRequest[], expectedRequests: { [path: string]: IWatcherRequest[] }) { const actual = normalizeRoots(inputRequests); const actualPath = Object.keys(actual).sort(); const expectedPaths = Object.keys(expectedRequests).sort(); - assert.deepEqual(actualPath, expectedPaths); + assert.deepStrictEqual(actualPath, expectedPaths); for (let path of actualPath) { let a = expectedRequests[path].sort((r1, r2) => r1.path.localeCompare(r2.path)); let e = expectedRequests[path].sort((r1, r2) => r1.path.localeCompare(r2.path)); - assert.deepEqual(a, e); + assert.deepStrictEqual(a, e); } } diff --git a/src/vs/platform/files/test/browser/fileService.test.ts b/src/vs/platform/files/test/browser/fileService.test.ts index edc32f0a3b4db027fcda22bdd287cf730378cc15..e8d53c1cf1dad9f5b0f47beffd0d90425df5f741 100644 --- a/src/vs/platform/files/test/browser/fileService.test.ts +++ b/src/vs/platform/files/test/browser/fileService.test.ts @@ -19,7 +19,7 @@ suite('File Service', () => { const resource = URI.parse('test://foo/bar'); const provider = new NullFileSystemProvider(); - assert.equal(service.canHandleResource(resource), false); + assert.strictEqual(service.canHandleResource(resource), false); const registrations: IFileSystemProviderRegistrationEvent[] = []; service.onDidChangeFileSystemProviderRegistrations(e => { @@ -47,33 +47,33 @@ suite('File Service', () => { await service.activateProvider('test'); - assert.equal(service.canHandleResource(resource), true); + assert.strictEqual(service.canHandleResource(resource), true); - assert.equal(registrations.length, 1); - assert.equal(registrations[0].scheme, 'test'); - assert.equal(registrations[0].added, true); + assert.strictEqual(registrations.length, 1); + assert.strictEqual(registrations[0].scheme, 'test'); + assert.strictEqual(registrations[0].added, true); assert.ok(registrationDisposable); - assert.equal(capabilityChanges.length, 0); + assert.strictEqual(capabilityChanges.length, 0); provider.setCapabilities(FileSystemProviderCapabilities.FileFolderCopy); - assert.equal(capabilityChanges.length, 1); + assert.strictEqual(capabilityChanges.length, 1); provider.setCapabilities(FileSystemProviderCapabilities.Readonly); - assert.equal(capabilityChanges.length, 2); + assert.strictEqual(capabilityChanges.length, 2); await service.activateProvider('test'); - assert.equal(callCount, 2); // activation is called again + assert.strictEqual(callCount, 2); // activation is called again - assert.equal(service.hasCapability(resource, FileSystemProviderCapabilities.Readonly), true); - assert.equal(service.hasCapability(resource, FileSystemProviderCapabilities.FileOpenReadWriteClose), false); + assert.strictEqual(service.hasCapability(resource, FileSystemProviderCapabilities.Readonly), true); + assert.strictEqual(service.hasCapability(resource, FileSystemProviderCapabilities.FileOpenReadWriteClose), false); registrationDisposable!.dispose(); - assert.equal(service.canHandleResource(resource), false); + assert.strictEqual(service.canHandleResource(resource), false); - assert.equal(registrations.length, 2); - assert.equal(registrations[1].scheme, 'test'); - assert.equal(registrations[1].added, false); + assert.strictEqual(registrations.length, 2); + assert.strictEqual(registrations[1].scheme, 'test'); + assert.strictEqual(registrations[1].added, false); }); test('watch', async () => { @@ -91,9 +91,9 @@ suite('File Service', () => { const watcher1Disposable = service.watch(resource1); await timeout(0); // service.watch() is async - assert.equal(disposeCounter, 0); + assert.strictEqual(disposeCounter, 0); watcher1Disposable.dispose(); - assert.equal(disposeCounter, 1); + assert.strictEqual(disposeCounter, 1); disposeCounter = 0; const resource2 = URI.parse('test://foo/bar2'); @@ -102,13 +102,13 @@ suite('File Service', () => { const watcher2Disposable3 = service.watch(resource2); await timeout(0); // service.watch() is async - assert.equal(disposeCounter, 0); + assert.strictEqual(disposeCounter, 0); watcher2Disposable1.dispose(); - assert.equal(disposeCounter, 0); + assert.strictEqual(disposeCounter, 0); watcher2Disposable2.dispose(); - assert.equal(disposeCounter, 0); + assert.strictEqual(disposeCounter, 0); watcher2Disposable3.dispose(); - assert.equal(disposeCounter, 1); + assert.strictEqual(disposeCounter, 1); disposeCounter = 0; const resource3 = URI.parse('test://foo/bar3'); @@ -116,10 +116,10 @@ suite('File Service', () => { const watcher3Disposable2 = service.watch(resource3, { recursive: true, excludes: [] }); await timeout(0); // service.watch() is async - assert.equal(disposeCounter, 0); + assert.strictEqual(disposeCounter, 0); watcher3Disposable1.dispose(); - assert.equal(disposeCounter, 1); + assert.strictEqual(disposeCounter, 1); watcher3Disposable2.dispose(); - assert.equal(disposeCounter, 2); + assert.strictEqual(disposeCounter, 2); }); }); diff --git a/src/vs/platform/files/test/electron-browser/normalizer.test.ts b/src/vs/platform/files/test/electron-browser/normalizer.test.ts index 98aa1162cb2a397e370b2404e4ada951c2dd9377..df672c5f0478a59600a4bb40ff3014df11a0cdbd 100644 --- a/src/vs/platform/files/test/electron-browser/normalizer.test.ts +++ b/src/vs/platform/files/test/electron-browser/normalizer.test.ts @@ -64,7 +64,7 @@ suite('Normalizer', () => { watch.onDidFilesChange(e => { assert.ok(e); - assert.equal(e.changes.length, 3); + assert.strictEqual(e.changes.length, 3); assert.ok(e.contains(added, FileChangeType.ADDED)); assert.ok(e.contains(updated, FileChangeType.UPDATED)); assert.ok(e.contains(deleted, FileChangeType.DELETED)); @@ -103,7 +103,7 @@ suite('Normalizer', () => { watch.onDidFilesChange(e => { assert.ok(e); - assert.equal(e.changes.length, 5); + assert.strictEqual(e.changes.length, 5); assert.ok(e.contains(deletedFolderA, FileChangeType.DELETED)); assert.ok(e.contains(deletedFolderB, FileChangeType.DELETED)); @@ -133,7 +133,7 @@ suite('Normalizer', () => { watch.onDidFilesChange(e => { assert.ok(e); - assert.equal(e.changes.length, 1); + assert.strictEqual(e.changes.length, 1); assert.ok(e.contains(unrelated, FileChangeType.UPDATED)); @@ -158,7 +158,7 @@ suite('Normalizer', () => { watch.onDidFilesChange(e => { assert.ok(e); - assert.equal(e.changes.length, 2); + assert.strictEqual(e.changes.length, 2); assert.ok(e.contains(deleted, FileChangeType.UPDATED)); assert.ok(e.contains(unrelated, FileChangeType.UPDATED)); @@ -184,7 +184,7 @@ suite('Normalizer', () => { watch.onDidFilesChange(e => { assert.ok(e); - assert.equal(e.changes.length, 2); + assert.strictEqual(e.changes.length, 2); assert.ok(e.contains(created, FileChangeType.ADDED)); assert.ok(!e.contains(created, FileChangeType.UPDATED)); @@ -213,7 +213,7 @@ suite('Normalizer', () => { watch.onDidFilesChange(e => { assert.ok(e); - assert.equal(e.changes.length, 2); + assert.strictEqual(e.changes.length, 2); assert.ok(e.contains(deleted, FileChangeType.DELETED)); assert.ok(!e.contains(updated, FileChangeType.UPDATED)); diff --git a/src/vs/platform/state/test/node/state.test.ts b/src/vs/platform/state/test/node/state.test.ts index 3920bd0e78a49eb8ca9b22affcb8abb033604b53..dc4acc6aebe8fcfbacbcf1b4509a387666663aa3 100644 --- a/src/vs/platform/state/test/node/state.test.ts +++ b/src/vs/platform/state/test/node/state.test.ts @@ -31,10 +31,10 @@ flakySuite('StateService', () => { let service = new FileStorage(storageFile, () => null); service.setItem('some.key', 'some.value'); - assert.equal(service.getItem('some.key'), 'some.value'); + assert.strictEqual(service.getItem('some.key'), 'some.value'); service.removeItem('some.key'); - assert.equal(service.getItem('some.key', 'some.default'), 'some.default'); + assert.strictEqual(service.getItem('some.key', 'some.default'), 'some.default'); assert.ok(!service.getItem('some.unknonw.key')); @@ -42,15 +42,15 @@ flakySuite('StateService', () => { service = new FileStorage(storageFile, () => null); - assert.equal(service.getItem('some.other.key'), 'some.other.value'); + assert.strictEqual(service.getItem('some.other.key'), 'some.other.value'); service.setItem('some.other.key', 'some.other.value'); - assert.equal(service.getItem('some.other.key'), 'some.other.value'); + assert.strictEqual(service.getItem('some.other.key'), 'some.other.value'); service.setItem('some.undefined.key', undefined); - assert.equal(service.getItem('some.undefined.key', 'some.default'), 'some.default'); + assert.strictEqual(service.getItem('some.undefined.key', 'some.default'), 'some.default'); service.setItem('some.null.key', null); - assert.equal(service.getItem('some.null.key', 'some.default'), 'some.default'); + assert.strictEqual(service.getItem('some.null.key', 'some.default'), 'some.default'); }); }); diff --git a/src/vs/platform/storage/test/common/storageService.test.ts b/src/vs/platform/storage/test/common/storageService.test.ts index 886efb2f8707743dd8c0ed81d91ba4fe554a10e2..182ff12af03d4e92f816c3b2777e9f6cfe2c4df0 100644 --- a/src/vs/platform/storage/test/common/storageService.test.ts +++ b/src/vs/platform/storage/test/common/storageService.test.ts @@ -3,7 +3,7 @@ * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ -import { strictEqual, ok, equal } from 'assert'; +import { strictEqual, ok } from 'assert'; import { StorageScope, InMemoryStorageService, StorageTarget, IStorageValueChangeEvent, IStorageTargetChangeEvent } from 'vs/platform/storage/common/storage'; suite('StorageService', function () { @@ -32,15 +32,15 @@ suite('StorageService', function () { storage.store('test.get', 'foobar', scope, StorageTarget.MACHINE); strictEqual(storage.get('test.get', scope, (undefined)!), 'foobar'); let storageValueChangeEvent = storageValueChangeEvents.find(e => e.key === 'test.get'); - equal(storageValueChangeEvent?.scope, scope); - equal(storageValueChangeEvent?.key, 'test.get'); + strictEqual(storageValueChangeEvent?.scope, scope); + strictEqual(storageValueChangeEvent?.key, 'test.get'); storageValueChangeEvents = []; storage.store('test.get', '', scope, StorageTarget.MACHINE); strictEqual(storage.get('test.get', scope, (undefined)!), ''); storageValueChangeEvent = storageValueChangeEvents.find(e => e.key === 'test.get'); - equal(storageValueChangeEvent!.scope, scope); - equal(storageValueChangeEvent!.key, 'test.get'); + strictEqual(storageValueChangeEvent!.scope, scope); + strictEqual(storageValueChangeEvent!.key, 'test.get'); storage.store('test.getNumber', 5, scope, StorageTarget.MACHINE); strictEqual(storage.getNumber('test.getNumber', scope, (undefined)!), 5); @@ -79,8 +79,8 @@ suite('StorageService', function () { storage.remove('test.remove', scope); ok(!storage.get('test.remove', scope, (undefined)!)); let storageValueChangeEvent = storageValueChangeEvents.find(e => e.key === 'test.remove'); - equal(storageValueChangeEvent?.scope, scope); - equal(storageValueChangeEvent?.key, 'test.remove'); + strictEqual(storageValueChangeEvent?.scope, scope); + strictEqual(storageValueChangeEvent?.key, 'test.remove'); } test('Keys (in-memory)', () => { @@ -107,20 +107,20 @@ suite('StorageService', function () { storage.store('test.target1', 'value1', scope, target); strictEqual(storage.keys(scope, target).length, 1); - equal(storageTargetEvent?.scope, scope); - equal(storageValueChangeEvent?.key, 'test.target1'); - equal(storageValueChangeEvent?.scope, scope); - equal(storageValueChangeEvent?.target, target); + strictEqual(storageTargetEvent?.scope, scope); + strictEqual(storageValueChangeEvent?.key, 'test.target1'); + strictEqual(storageValueChangeEvent?.scope, scope); + strictEqual(storageValueChangeEvent?.target, target); storageTargetEvent = undefined; storageValueChangeEvent = Object.create(null); storage.store('test.target1', 'otherValue1', scope, target); strictEqual(storage.keys(scope, target).length, 1); - equal(storageTargetEvent, undefined); - equal(storageValueChangeEvent?.key, 'test.target1'); - equal(storageValueChangeEvent?.scope, scope); - equal(storageValueChangeEvent?.target, target); + strictEqual(storageTargetEvent, undefined); + strictEqual(storageValueChangeEvent?.key, 'test.target1'); + strictEqual(storageValueChangeEvent?.scope, scope); + strictEqual(storageValueChangeEvent?.target, target); storage.store('test.target2', 'value2', scope, target); storage.store('test.target3', 'value3', scope, target); @@ -142,9 +142,9 @@ suite('StorageService', function () { storage.remove('test.target4', scope); strictEqual(storage.keys(scope, target).length, keysLength); - equal(storageTargetEvent?.scope, scope); - equal(storageValueChangeEvent?.key, 'test.target4'); - equal(storageValueChangeEvent?.scope, scope); + strictEqual(storageTargetEvent?.scope, scope); + strictEqual(storageValueChangeEvent?.key, 'test.target4'); + strictEqual(storageValueChangeEvent?.scope, scope); } } @@ -171,7 +171,7 @@ suite('StorageService', function () { storage.store('test.target1', undefined, scope, target); strictEqual(storage.keys(scope, target).length, 0); - equal(storageTargetEvent?.scope, scope); + strictEqual(storageTargetEvent?.scope, scope); storage.store('test.target1', '', scope, target); strictEqual(storage.keys(scope, target).length, 1); diff --git a/src/vs/platform/storage/test/electron-browser/storage.test.ts b/src/vs/platform/storage/test/electron-browser/storage.test.ts index 47457e87f476d7bb7c36151f3bba1bd09b39e490..56f0a638dd4415e41137c3e1d7b16d2f86448865 100644 --- a/src/vs/platform/storage/test/electron-browser/storage.test.ts +++ b/src/vs/platform/storage/test/electron-browser/storage.test.ts @@ -3,7 +3,7 @@ * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ -import { equal } from 'assert'; +import { strictEqual } from 'assert'; import { FileStorageDatabase } from 'vs/platform/storage/browser/storageService'; import { join } from 'vs/base/common/path'; import { tmpdir } from 'os'; @@ -54,9 +54,9 @@ suite('Storage', () => { storage.set('barNumber', 55); storage.set('barBoolean', true); - equal(storage.get('bar'), 'foo'); - equal(storage.get('barNumber'), '55'); - equal(storage.get('barBoolean'), 'true'); + strictEqual(storage.get('bar'), 'foo'); + strictEqual(storage.get('barNumber'), '55'); + strictEqual(storage.get('barBoolean'), 'true'); await storage.close(); @@ -64,17 +64,17 @@ suite('Storage', () => { await storage.init(); - equal(storage.get('bar'), 'foo'); - equal(storage.get('barNumber'), '55'); - equal(storage.get('barBoolean'), 'true'); + strictEqual(storage.get('bar'), 'foo'); + strictEqual(storage.get('barNumber'), '55'); + strictEqual(storage.get('barBoolean'), 'true'); storage.delete('bar'); storage.delete('barNumber'); storage.delete('barBoolean'); - equal(storage.get('bar', 'undefined'), 'undefined'); - equal(storage.get('barNumber', 'undefinedNumber'), 'undefinedNumber'); - equal(storage.get('barBoolean', 'undefinedBoolean'), 'undefinedBoolean'); + strictEqual(storage.get('bar', 'undefined'), 'undefined'); + strictEqual(storage.get('barNumber', 'undefinedNumber'), 'undefinedNumber'); + strictEqual(storage.get('barBoolean', 'undefinedBoolean'), 'undefinedBoolean'); await storage.close(); @@ -82,8 +82,8 @@ suite('Storage', () => { await storage.init(); - equal(storage.get('bar', 'undefined'), 'undefined'); - equal(storage.get('barNumber', 'undefinedNumber'), 'undefinedNumber'); - equal(storage.get('barBoolean', 'undefinedBoolean'), 'undefinedBoolean'); + strictEqual(storage.get('bar', 'undefined'), 'undefined'); + strictEqual(storage.get('barNumber', 'undefinedNumber'), 'undefinedNumber'); + strictEqual(storage.get('barBoolean', 'undefinedBoolean'), 'undefinedBoolean'); }); }); diff --git a/src/vs/platform/storage/test/node/storageService.test.ts b/src/vs/platform/storage/test/node/storageService.test.ts index e42901b3f8716a9b4c3783a2a705f00db9f7b122..6677ab24d583a3b4cdf948d0d5aab61ec5006ad9 100644 --- a/src/vs/platform/storage/test/node/storageService.test.ts +++ b/src/vs/platform/storage/test/node/storageService.test.ts @@ -3,7 +3,7 @@ * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ -import { equal } from 'assert'; +import { strictEqual } from 'assert'; import { StorageScope, StorageTarget } from 'vs/platform/storage/common/storage'; import { NativeStorageService } from 'vs/platform/storage/node/storageService'; import { tmpdir } from 'os'; @@ -53,15 +53,15 @@ flakySuite('NativeStorageService', function () { storage.store('barNumber', 55, StorageScope.WORKSPACE, StorageTarget.MACHINE); storage.store('barBoolean', true, StorageScope.GLOBAL, StorageTarget.MACHINE); - equal(storage.get('bar', StorageScope.WORKSPACE), 'foo'); - equal(storage.getNumber('barNumber', StorageScope.WORKSPACE), 55); - equal(storage.getBoolean('barBoolean', StorageScope.GLOBAL), true); + strictEqual(storage.get('bar', StorageScope.WORKSPACE), 'foo'); + strictEqual(storage.getNumber('barNumber', StorageScope.WORKSPACE), 55); + strictEqual(storage.getBoolean('barBoolean', StorageScope.GLOBAL), true); await storage.migrate({ id: String(Date.now() + 100) }); - equal(storage.get('bar', StorageScope.WORKSPACE), 'foo'); - equal(storage.getNumber('barNumber', StorageScope.WORKSPACE), 55); - equal(storage.getBoolean('barBoolean', StorageScope.GLOBAL), true); + strictEqual(storage.get('bar', StorageScope.WORKSPACE), 'foo'); + strictEqual(storage.getNumber('barNumber', StorageScope.WORKSPACE), 55); + strictEqual(storage.getBoolean('barBoolean', StorageScope.GLOBAL), true); await storage.close(); }); diff --git a/src/vs/platform/windows/test/electron-main/window.test.ts b/src/vs/platform/windows/test/electron-main/window.test.ts index 84b12f123d56b0d678b5b409b1efc75d5f47f0a7..cf976b05ae89dd8524c47df3ad146656654f72a5 100644 --- a/src/vs/platform/windows/test/electron-main/window.test.ts +++ b/src/vs/platform/windows/test/electron-main/window.test.ts @@ -88,22 +88,22 @@ suite('WindowsFinder', () => { }); test('Existing window with folder', () => { - assert.equal(findWindowOnFile(windows, URI.file(path.join(fixturesFolder, 'no_vscode_folder', 'file.txt')), localWorkspaceResolver), noVscodeFolderWindow); + assert.strictEqual(findWindowOnFile(windows, URI.file(path.join(fixturesFolder, 'no_vscode_folder', 'file.txt')), localWorkspaceResolver), noVscodeFolderWindow); - assert.equal(findWindowOnFile(windows, URI.file(path.join(fixturesFolder, 'vscode_folder', 'file.txt')), localWorkspaceResolver), vscodeFolderWindow); + assert.strictEqual(findWindowOnFile(windows, URI.file(path.join(fixturesFolder, 'vscode_folder', 'file.txt')), localWorkspaceResolver), vscodeFolderWindow); const window: ICodeWindow = createTestCodeWindow({ lastFocusTime: 1, openedFolderUri: URI.file(path.join(fixturesFolder, 'vscode_folder', 'nested_folder')) }); - assert.equal(findWindowOnFile([window], URI.file(path.join(fixturesFolder, 'vscode_folder', 'nested_folder', 'subfolder', 'file.txt')), localWorkspaceResolver), window); + assert.strictEqual(findWindowOnFile([window], URI.file(path.join(fixturesFolder, 'vscode_folder', 'nested_folder', 'subfolder', 'file.txt')), localWorkspaceResolver), window); }); test('More specific existing window wins', () => { const window: ICodeWindow = createTestCodeWindow({ lastFocusTime: 2, openedFolderUri: URI.file(path.join(fixturesFolder, 'no_vscode_folder')) }); const nestedFolderWindow: ICodeWindow = createTestCodeWindow({ lastFocusTime: 1, openedFolderUri: URI.file(path.join(fixturesFolder, 'no_vscode_folder', 'nested_folder')) }); - assert.equal(findWindowOnFile([window, nestedFolderWindow], URI.file(path.join(fixturesFolder, 'no_vscode_folder', 'nested_folder', 'subfolder', 'file.txt')), localWorkspaceResolver), nestedFolderWindow); + assert.strictEqual(findWindowOnFile([window, nestedFolderWindow], URI.file(path.join(fixturesFolder, 'no_vscode_folder', 'nested_folder', 'subfolder', 'file.txt')), localWorkspaceResolver), nestedFolderWindow); }); test('Workspace folder wins', () => { const window: ICodeWindow = createTestCodeWindow({ lastFocusTime: 1, openedWorkspace: testWorkspace }); - assert.equal(findWindowOnFile([window], URI.file(path.join(fixturesFolder, 'vscode_workspace_2_folder', 'nested_vscode_folder', 'subfolder', 'file.txt')), localWorkspaceResolver), window); + assert.strictEqual(findWindowOnFile([window], URI.file(path.join(fixturesFolder, 'vscode_workspace_2_folder', 'nested_vscode_folder', 'subfolder', 'file.txt')), localWorkspaceResolver), window); }); }); diff --git a/src/vs/platform/windows/test/electron-main/windowsStateHandler.test.ts b/src/vs/platform/windows/test/electron-main/windowsStateHandler.test.ts index d8377b2e30545217ecadb92b8884c32da32141fd..956ab942b046d5cf3e1fa0c76dceb58d81e14e3e 100644 --- a/src/vs/platform/windows/test/electron-main/windowsStateHandler.test.ts +++ b/src/vs/platform/windows/test/electron-main/windowsStateHandler.test.ts @@ -28,15 +28,15 @@ function toWorkspace(uri: URI): IWorkspaceIdentifier { }; } function assertEqualURI(u1: URI | undefined, u2: URI | undefined, message?: string): void { - assert.equal(u1 && u1.toString(), u2 && u2.toString(), message); + assert.strictEqual(u1 && u1.toString(), u2 && u2.toString(), message); } function assertEqualWorkspace(w1: IWorkspaceIdentifier | undefined, w2: IWorkspaceIdentifier | undefined, message?: string): void { if (!w1 || !w2) { - assert.equal(w1, w2, message); + assert.strictEqual(w1, w2, message); return; } - assert.equal(w1.id, w2.id, message); + assert.strictEqual(w1.id, w2.id, message); assertEqualURI(w1.configPath, w2.configPath, message); } @@ -45,9 +45,9 @@ function assertEqualWindowState(expected: IWindowState | undefined, actual: IWin assert.deepEqual(expected, actual, message); return; } - assert.equal(expected.backupPath, actual.backupPath, message); + assert.strictEqual(expected.backupPath, actual.backupPath, message); assertEqualURI(expected.folderUri, actual.folderUri, message); - assert.equal(expected.remoteAuthority, actual.remoteAuthority, message); + assert.strictEqual(expected.remoteAuthority, actual.remoteAuthority, message); assertEqualWorkspace(expected.workspace, actual.workspace, message); assert.deepEqual(expected.uiState, actual.uiState, message); } @@ -55,7 +55,7 @@ function assertEqualWindowState(expected: IWindowState | undefined, actual: IWin function assertEqualWindowsState(expected: IWindowsState, actual: IWindowsState, message?: string) { assertEqualWindowState(expected.lastPluginDevelopmentHostWindow, actual.lastPluginDevelopmentHostWindow, message); assertEqualWindowState(expected.lastActiveWindow, actual.lastActiveWindow, message); - assert.equal(expected.openedWindows.length, actual.openedWindows.length, message); + assert.strictEqual(expected.openedWindows.length, actual.openedWindows.length, message); for (let i = 0; i < expected.openedWindows.length; i++) { assertEqualWindowState(expected.openedWindows[i], actual.openedWindows[i], message); } diff --git a/src/vs/platform/workspaces/test/electron-main/workspacesHistoryStorage.test.ts b/src/vs/platform/workspaces/test/electron-main/workspacesHistoryStorage.test.ts index c16373206304e47a72359fd7072e4280db4b8abe..3439009aa919064f6fd861ca0ecfb79c30359450 100644 --- a/src/vs/platform/workspaces/test/electron-main/workspacesHistoryStorage.test.ts +++ b/src/vs/platform/workspaces/test/electron-main/workspacesHistoryStorage.test.ts @@ -17,25 +17,25 @@ function toWorkspace(uri: URI): IWorkspaceIdentifier { }; } function assertEqualURI(u1: URI | undefined, u2: URI | undefined, message?: string): void { - assert.equal(u1 && u1.toString(), u2 && u2.toString(), message); + assert.strictEqual(u1 && u1.toString(), u2 && u2.toString(), message); } function assertEqualWorkspace(w1: IWorkspaceIdentifier | undefined, w2: IWorkspaceIdentifier | undefined, message?: string): void { if (!w1 || !w2) { - assert.equal(w1, w2, message); + assert.strictEqual(w1, w2, message); return; } - assert.equal(w1.id, w2.id, message); + assert.strictEqual(w1.id, w2.id, message); assertEqualURI(w1.configPath, w2.configPath, message); } function assertEqualRecentlyOpened(actual: IRecentlyOpened, expected: IRecentlyOpened, message?: string) { - assert.equal(actual.files.length, expected.files.length, message); + assert.strictEqual(actual.files.length, expected.files.length, message); for (let i = 0; i < actual.files.length; i++) { assertEqualURI(actual.files[i].fileUri, expected.files[i].fileUri, message); - assert.equal(actual.files[i].label, expected.files[i].label); + assert.strictEqual(actual.files[i].label, expected.files[i].label); } - assert.equal(actual.workspaces.length, expected.workspaces.length, message); + assert.strictEqual(actual.workspaces.length, expected.workspaces.length, message); for (let i = 0; i < actual.workspaces.length; i++) { let expectedRecent = expected.workspaces[i]; let actualRecent = actual.workspaces[i]; @@ -44,7 +44,7 @@ function assertEqualRecentlyOpened(actual: IRecentlyOpened, expected: IRecentlyO } else { assertEqualWorkspace(actualRecent.workspace, (expectedRecent).workspace, message); } - assert.equal(actualRecent.label, expectedRecent.label); + assert.strictEqual(actualRecent.label, expectedRecent.label); } } diff --git a/src/vs/platform/workspaces/test/electron-main/workspacesManagementMainService.test.ts b/src/vs/platform/workspaces/test/electron-main/workspacesManagementMainService.test.ts index 94cd6f7bc893aa96b84c825b796314d5d84fb98c..7dfaf962c4d80ee9a02f6bceeb08a9284c7fe8c6 100644 --- a/src/vs/platform/workspaces/test/electron-main/workspacesManagementMainService.test.ts +++ b/src/vs/platform/workspaces/test/electron-main/workspacesManagementMainService.test.ts @@ -162,11 +162,11 @@ suite('WorkspacesManagementMainService', () => { p2 = normalizeDriveLetter(p2); } - assert.equal(p1, p2); + assert.strictEqual(p1, p2); } function assertEqualURI(u1: URI, u2: URI): void { - assert.equal(u1.toString(), u2.toString()); + assert.strictEqual(u1.toString(), u2.toString()); } test('createWorkspace (folders)', async () => { @@ -176,7 +176,7 @@ suite('WorkspacesManagementMainService', () => { assert.ok(service.isUntitledWorkspace(workspace)); const ws = (JSON.parse(fs.readFileSync(workspace.configPath.fsPath).toString()) as IStoredWorkspace); - assert.equal(ws.folders.length, 2); + assert.strictEqual(ws.folders.length, 2); assertPathEquals((ws.folders[0]).path, process.cwd()); assertPathEquals((ws.folders[1]).path, os.tmpdir()); assert.ok(!(ws.folders[0]).name); @@ -190,11 +190,11 @@ suite('WorkspacesManagementMainService', () => { assert.ok(service.isUntitledWorkspace(workspace)); const ws = (JSON.parse(fs.readFileSync(workspace.configPath.fsPath).toString()) as IStoredWorkspace); - assert.equal(ws.folders.length, 2); + assert.strictEqual(ws.folders.length, 2); assertPathEquals((ws.folders[0]).path, process.cwd()); assertPathEquals((ws.folders[1]).path, os.tmpdir()); - assert.equal((ws.folders[0]).name, 'currentworkingdirectory'); - assert.equal((ws.folders[1]).name, 'tempdir'); + assert.strictEqual((ws.folders[0]).name, 'currentworkingdirectory'); + assert.strictEqual((ws.folders[1]).name, 'tempdir'); }); test('createUntitledWorkspace (folders as other resource URIs)', async () => { @@ -207,12 +207,12 @@ suite('WorkspacesManagementMainService', () => { assert.ok(service.isUntitledWorkspace(workspace)); const ws = (JSON.parse(fs.readFileSync(workspace.configPath.fsPath).toString()) as IStoredWorkspace); - assert.equal(ws.folders.length, 2); - assert.equal((ws.folders[0]).uri, folder1URI.toString(true)); - assert.equal((ws.folders[1]).uri, folder2URI.toString(true)); + assert.strictEqual(ws.folders.length, 2); + assert.strictEqual((ws.folders[0]).uri, folder1URI.toString(true)); + assert.strictEqual((ws.folders[1]).uri, folder2URI.toString(true)); assert.ok(!(ws.folders[0]).name); assert.ok(!(ws.folders[1]).name); - assert.equal(ws.remoteAuthority, 'server'); + assert.strictEqual(ws.remoteAuthority, 'server'); }); test('createWorkspaceSync (folders)', () => { @@ -222,7 +222,7 @@ suite('WorkspacesManagementMainService', () => { assert.ok(service.isUntitledWorkspace(workspace)); const ws = JSON.parse(fs.readFileSync(workspace.configPath.fsPath).toString()) as IStoredWorkspace; - assert.equal(ws.folders.length, 2); + assert.strictEqual(ws.folders.length, 2); assertPathEquals((ws.folders[0]).path, process.cwd()); assertPathEquals((ws.folders[1]).path, os.tmpdir()); @@ -237,12 +237,12 @@ suite('WorkspacesManagementMainService', () => { assert.ok(service.isUntitledWorkspace(workspace)); const ws = JSON.parse(fs.readFileSync(workspace.configPath.fsPath).toString()) as IStoredWorkspace; - assert.equal(ws.folders.length, 2); + assert.strictEqual(ws.folders.length, 2); assertPathEquals((ws.folders[0]).path, process.cwd()); assertPathEquals((ws.folders[1]).path, os.tmpdir()); - assert.equal((ws.folders[0]).name, 'currentworkingdirectory'); - assert.equal((ws.folders[1]).name, 'tempdir'); + assert.strictEqual((ws.folders[0]).name, 'currentworkingdirectory'); + assert.strictEqual((ws.folders[1]).name, 'tempdir'); }); test('createUntitledWorkspaceSync (folders as other resource URIs)', () => { @@ -255,9 +255,9 @@ suite('WorkspacesManagementMainService', () => { assert.ok(service.isUntitledWorkspace(workspace)); const ws = JSON.parse(fs.readFileSync(workspace.configPath.fsPath).toString()) as IStoredWorkspace; - assert.equal(ws.folders.length, 2); - assert.equal((ws.folders[0]).uri, folder1URI.toString(true)); - assert.equal((ws.folders[1]).uri, folder2URI.toString(true)); + assert.strictEqual(ws.folders.length, 2); + assert.strictEqual((ws.folders[0]).uri, folder1URI.toString(true)); + assert.strictEqual((ws.folders[1]).uri, folder2URI.toString(true)); assert.ok(!(ws.folders[0]).name); assert.ok(!(ws.folders[1]).name); @@ -273,7 +273,7 @@ suite('WorkspacesManagementMainService', () => { workspace.configPath = URI.file(newPath); const resolved = service.resolveLocalWorkspaceSync(workspace.configPath); - assert.equal(2, resolved!.folders.length); + assert.strictEqual(2, resolved!.folders.length); assertEqualURI(resolved!.configPath, workspace.configPath); assert.ok(resolved!.id); fs.writeFileSync(workspace.configPath.fsPath, JSON.stringify({ something: 'something' })); // invalid workspace @@ -327,7 +327,7 @@ suite('WorkspacesManagementMainService', () => { let workspaceConfigPath = URI.file(path.join(tmpDir, 'inside', 'myworkspace1.code-workspace')); let newContent = rewriteWorkspaceFileForNewLocation(origContent, origConfigPath, false, workspaceConfigPath, extUriBiasedIgnorePathCase); let ws = (JSON.parse(newContent) as IStoredWorkspace); - assert.equal(ws.folders.length, 3); + assert.strictEqual(ws.folders.length, 3); assertPathEquals((ws.folders[0]).path, folder1); // absolute path because outside of tmpdir assertPathEquals((ws.folders[1]).path, '.'); assertPathEquals((ws.folders[2]).path, 'somefolder'); @@ -336,7 +336,7 @@ suite('WorkspacesManagementMainService', () => { workspaceConfigPath = URI.file(path.join(tmpDir, 'myworkspace2.code-workspace')); newContent = rewriteWorkspaceFileForNewLocation(newContent, origConfigPath, false, workspaceConfigPath, extUriBiasedIgnorePathCase); ws = (JSON.parse(newContent) as IStoredWorkspace); - assert.equal(ws.folders.length, 3); + assert.strictEqual(ws.folders.length, 3); assertPathEquals((ws.folders[0]).path, folder1); assertPathEquals((ws.folders[1]).path, 'inside'); assertPathEquals((ws.folders[2]).path, isWindows ? 'inside\\somefolder' : 'inside/somefolder'); @@ -345,7 +345,7 @@ suite('WorkspacesManagementMainService', () => { workspaceConfigPath = URI.file(path.join(tmpDir, 'other', 'myworkspace2.code-workspace')); newContent = rewriteWorkspaceFileForNewLocation(newContent, origConfigPath, false, workspaceConfigPath, extUriBiasedIgnorePathCase); ws = (JSON.parse(newContent) as IStoredWorkspace); - assert.equal(ws.folders.length, 3); + assert.strictEqual(ws.folders.length, 3); assertPathEquals((ws.folders[0]).path, folder1); assertPathEquals((ws.folders[1]).path, isWindows ? '..\\inside' : '../inside'); assertPathEquals((ws.folders[2]).path, isWindows ? '..\\inside\\somefolder' : '../inside/somefolder'); @@ -354,10 +354,10 @@ suite('WorkspacesManagementMainService', () => { workspaceConfigPath = URI.parse('foo://foo/bar/myworkspace2.code-workspace'); newContent = rewriteWorkspaceFileForNewLocation(newContent, origConfigPath, false, workspaceConfigPath, extUriBiasedIgnorePathCase); ws = (JSON.parse(newContent) as IStoredWorkspace); - assert.equal(ws.folders.length, 3); - assert.equal((ws.folders[0]).uri, URI.file(folder1).toString(true)); - assert.equal((ws.folders[1]).uri, URI.file(tmpInsideDir).toString(true)); - assert.equal((ws.folders[2]).uri, URI.file(path.join(tmpInsideDir, 'somefolder')).toString(true)); + assert.strictEqual(ws.folders.length, 3); + assert.strictEqual((ws.folders[0]).uri, URI.file(folder1).toString(true)); + assert.strictEqual((ws.folders[1]).uri, URI.file(tmpInsideDir).toString(true)); + assert.strictEqual((ws.folders[2]).uri, URI.file(path.join(tmpInsideDir, 'somefolder')).toString(true)); fs.unlinkSync(firstConfigPath); }); @@ -370,7 +370,7 @@ suite('WorkspacesManagementMainService', () => { origContent = `// this is a comment\n${origContent}`; let newContent = rewriteWorkspaceFileForNewLocation(origContent, workspace.configPath, false, workspaceConfigPath, extUriBiasedIgnorePathCase); - assert.equal(0, newContent.indexOf('// this is a comment')); + assert.strictEqual(0, newContent.indexOf('// this is a comment')); service.deleteUntitledWorkspaceSync(workspace); }); @@ -419,14 +419,14 @@ suite('WorkspacesManagementMainService', () => { test('getUntitledWorkspaceSync', async function () { let untitled = service.getUntitledWorkspacesSync(); - assert.equal(untitled.length, 0); + assert.strictEqual(untitled.length, 0); const untitledOne = await createUntitledWorkspace([process.cwd(), os.tmpdir()]); assert.ok(fs.existsSync(untitledOne.configPath.fsPath)); untitled = service.getUntitledWorkspacesSync(); - assert.equal(1, untitled.length); - assert.equal(untitledOne.id, untitled[0].workspace.id); + assert.strictEqual(1, untitled.length); + assert.strictEqual(untitledOne.id, untitled[0].workspace.id); const untitledTwo = await createUntitledWorkspace([os.tmpdir(), process.cwd()]); assert.ok(fs.existsSync(untitledTwo.configPath.fsPath)); @@ -438,15 +438,15 @@ suite('WorkspacesManagementMainService', () => { if (untitled.length === 1) { assert.fail(`Unexpected workspaces count of 1 (expected 2), all workspaces:\n ${fs.readdirSync(untitledHome.fsPath).map(name => fs.readFileSync(joinPath(untitledHome, name, 'workspace.json').fsPath, 'utf8'))}, before getUntitledWorkspacesSync: ${beforeGettingUntitledWorkspaces}`); } - assert.equal(2, untitled.length); + assert.strictEqual(2, untitled.length); service.deleteUntitledWorkspaceSync(untitledOne); untitled = service.getUntitledWorkspacesSync(); - assert.equal(1, untitled.length); + assert.strictEqual(1, untitled.length); service.deleteUntitledWorkspaceSync(untitledTwo); untitled = service.getUntitledWorkspacesSync(); - assert.equal(0, untitled.length); + assert.strictEqual(0, untitled.length); }); test('getSingleWorkspaceIdentifier', async function () { diff --git a/src/vs/workbench/contrib/backup/test/browser/backupRestorer.test.ts b/src/vs/workbench/contrib/backup/test/browser/backupRestorer.test.ts index 7fc055f32460c807bd1bcc53d7cb51be1f84d396..1835bff59c6943de9608e580345beca177b2720f 100644 --- a/src/vs/workbench/contrib/backup/test/browser/backupRestorer.test.ts +++ b/src/vs/workbench/contrib/backup/test/browser/backupRestorer.test.ts @@ -62,7 +62,7 @@ suite('BackupRestorer', () => { // Verify backups restored and opened as dirty await restorer.doRestoreBackups(); - assert.equal(editorService.count, 4); + assert.strictEqual(editorService.count, 4); assert.ok(editorService.editors.every(editor => editor.isDirty())); let counter = 0; @@ -101,7 +101,7 @@ suite('BackupRestorer', () => { } } - assert.equal(counter, 4); + assert.strictEqual(counter, 4); part.dispose(); tracker.dispose(); diff --git a/src/vs/workbench/contrib/backup/test/browser/backupTracker.test.ts b/src/vs/workbench/contrib/backup/test/browser/backupTracker.test.ts index 0d6de15e3a26bcd4ee714ec3ecd6baae401eb010..a75a319c7e5877d2df63539f950f5bd286842fe8 100644 --- a/src/vs/workbench/contrib/backup/test/browser/backupTracker.test.ts +++ b/src/vs/workbench/contrib/backup/test/browser/backupTracker.test.ts @@ -86,13 +86,13 @@ suite('BackupTracker (browser)', function () { await backupFileService.joinBackupResource(); - assert.equal(backupFileService.hasBackupSync(untitledEditor.resource), true); + assert.strictEqual(backupFileService.hasBackupSync(untitledEditor.resource), true); untitledModel.dispose(); await backupFileService.joinDiscardBackup(); - assert.equal(backupFileService.hasBackupSync(untitledEditor.resource), false); + assert.strictEqual(backupFileService.hasBackupSync(untitledEditor.resource), false); cleanup(); } @@ -131,23 +131,23 @@ suite('BackupTracker (browser)', function () { // Normal customWorkingCopy.setDirty(true); await backupFileService.joinBackupResource(); - assert.equal(backupFileService.hasBackupSync(resource), true); + assert.strictEqual(backupFileService.hasBackupSync(resource), true); customWorkingCopy.setDirty(false); customWorkingCopy.setDirty(true); await backupFileService.joinBackupResource(); - assert.equal(backupFileService.hasBackupSync(resource), true); + assert.strictEqual(backupFileService.hasBackupSync(resource), true); customWorkingCopy.setDirty(false); await backupFileService.joinDiscardBackup(); - assert.equal(backupFileService.hasBackupSync(resource), false); + assert.strictEqual(backupFileService.hasBackupSync(resource), false); // Cancellation customWorkingCopy.setDirty(true); await timeout(0); customWorkingCopy.setDirty(false); await backupFileService.joinDiscardBackup(); - assert.equal(backupFileService.hasBackupSync(resource), false); + assert.strictEqual(backupFileService.hasBackupSync(resource), false); customWorkingCopy.dispose(); await cleanup(); diff --git a/src/vs/workbench/contrib/backup/test/electron-browser/backupTracker.test.ts b/src/vs/workbench/contrib/backup/test/electron-browser/backupTracker.test.ts index fdc0b1d1b1577faa4d19505cd39899b94fd63482..1b0c10f4898a7426ace5bfe6aa9d66cf0ea506b0 100644 --- a/src/vs/workbench/contrib/backup/test/electron-browser/backupTracker.test.ts +++ b/src/vs/workbench/contrib/backup/test/electron-browser/backupTracker.test.ts @@ -183,13 +183,13 @@ flakySuite('BackupTracker (native)', function () { await accessor.backupFileService.joinBackupResource(); - assert.equal(accessor.backupFileService.hasBackupSync(resource), true); + assert.strictEqual(accessor.backupFileService.hasBackupSync(resource), true); fileModel?.dispose(); await accessor.backupFileService.joinDiscardBackup(); - assert.equal(accessor.backupFileService.hasBackupSync(resource), false); + assert.strictEqual(accessor.backupFileService.hasBackupSync(resource), false); await cleanup(); }); @@ -222,7 +222,7 @@ flakySuite('BackupTracker (native)', function () { await model?.load(); model?.textEditorModel?.setValue('foo'); - assert.equal(accessor.workingCopyService.dirtyCount, 1); + assert.strictEqual(accessor.workingCopyService.dirtyCount, 1); const event = new BeforeShutdownEventImpl(); accessor.lifecycleService.fireWillShutdown(event); @@ -243,7 +243,7 @@ flakySuite('BackupTracker (native)', function () { await model?.load(); model?.textEditorModel?.setValue('foo'); - assert.equal(accessor.workingCopyService.dirtyCount, 1); + assert.strictEqual(accessor.workingCopyService.dirtyCount, 1); const event = new BeforeShutdownEventImpl(); accessor.lifecycleService.fireWillShutdown(event); @@ -251,7 +251,7 @@ flakySuite('BackupTracker (native)', function () { const veto = await event.value; assert.ok(!veto); - assert.equal(accessor.workingCopyService.dirtyCount, 0); + assert.strictEqual(accessor.workingCopyService.dirtyCount, 0); await cleanup(); }); @@ -269,7 +269,7 @@ flakySuite('BackupTracker (native)', function () { await model?.load(); model?.textEditorModel?.setValue('foo'); - assert.equal(accessor.workingCopyService.dirtyCount, 1); + assert.strictEqual(accessor.workingCopyService.dirtyCount, 1); const event = new BeforeShutdownEventImpl(); accessor.lifecycleService.fireWillShutdown(event); @@ -293,7 +293,7 @@ flakySuite('BackupTracker (native)', function () { await model?.load(); model?.textEditorModel?.setValue('foo'); - assert.equal(accessor.workingCopyService.dirtyCount, 1); + assert.strictEqual(accessor.workingCopyService.dirtyCount, 1); const event = new BeforeShutdownEventImpl(); accessor.lifecycleService.fireWillShutdown(event); @@ -433,15 +433,15 @@ flakySuite('BackupTracker (native)', function () { await model?.load(); model?.textEditorModel?.setValue('foo'); - assert.equal(accessor.workingCopyService.dirtyCount, 1); + assert.strictEqual(accessor.workingCopyService.dirtyCount, 1); const event = new BeforeShutdownEventImpl(); event.reason = shutdownReason; accessor.lifecycleService.fireWillShutdown(event); const veto = await event.value; - assert.equal(accessor.backupFileService.discardedBackups.length, 0); // When hot exit is set, backups should never be cleaned since the confirm result is cancel - assert.equal(veto, shouldVeto); + assert.strictEqual(accessor.backupFileService.discardedBackups.length, 0); // When hot exit is set, backups should never be cleaned since the confirm result is cancel + assert.strictEqual(veto, shouldVeto); await cleanup(); } diff --git a/src/vs/workbench/contrib/codeEditor/test/browser/saveParticipant.test.ts b/src/vs/workbench/contrib/codeEditor/test/browser/saveParticipant.test.ts index f7e084d031a81854a03bb44ce0caa8743c3a809b..4e693565f9f2d210e48ad66b089f08b163d034ab 100644 --- a/src/vs/workbench/contrib/codeEditor/test/browser/saveParticipant.test.ts +++ b/src/vs/workbench/contrib/codeEditor/test/browser/saveParticipant.test.ts @@ -42,25 +42,25 @@ suite('Save Participants', function () { let lineContent = ''; model.textEditorModel.setValue(lineContent); await participant.participate(model, { reason: SaveReason.EXPLICIT }); - assert.equal(snapshotToString(model.createSnapshot()!), lineContent); + assert.strictEqual(snapshotToString(model.createSnapshot()!), lineContent); // No new line if last line already empty lineContent = `Hello New Line${model.textEditorModel.getEOL()}`; model.textEditorModel.setValue(lineContent); await participant.participate(model, { reason: SaveReason.EXPLICIT }); - assert.equal(snapshotToString(model.createSnapshot()!), lineContent); + assert.strictEqual(snapshotToString(model.createSnapshot()!), lineContent); // New empty line added (single line) lineContent = 'Hello New Line'; model.textEditorModel.setValue(lineContent); await participant.participate(model, { reason: SaveReason.EXPLICIT }); - assert.equal(snapshotToString(model.createSnapshot()!), `${lineContent}${model.textEditorModel.getEOL()}`); + assert.strictEqual(snapshotToString(model.createSnapshot()!), `${lineContent}${model.textEditorModel.getEOL()}`); // New empty line added (multi line) lineContent = `Hello New Line${model.textEditorModel.getEOL()}Hello New Line${model.textEditorModel.getEOL()}Hello New Line`; model.textEditorModel.setValue(lineContent); await participant.participate(model, { reason: SaveReason.EXPLICIT }); - assert.equal(snapshotToString(model.createSnapshot()!), `${lineContent}${model.textEditorModel.getEOL()}`); + assert.strictEqual(snapshotToString(model.createSnapshot()!), `${lineContent}${model.textEditorModel.getEOL()}`); }); test('trim final new lines', async function () { @@ -77,25 +77,25 @@ suite('Save Participants', function () { let lineContent = `${textContent}`; model.textEditorModel.setValue(lineContent); await participant.participate(model, { reason: SaveReason.EXPLICIT }); - assert.equal(snapshotToString(model.createSnapshot()!), lineContent); + assert.strictEqual(snapshotToString(model.createSnapshot()!), lineContent); // No new line removal if last line is single new line lineContent = `${textContent}${eol}`; model.textEditorModel.setValue(lineContent); await participant.participate(model, { reason: SaveReason.EXPLICIT }); - assert.equal(snapshotToString(model.createSnapshot()!), lineContent); + assert.strictEqual(snapshotToString(model.createSnapshot()!), lineContent); // Remove new line (single line with two new lines) lineContent = `${textContent}${eol}${eol}`; model.textEditorModel.setValue(lineContent); await participant.participate(model, { reason: SaveReason.EXPLICIT }); - assert.equal(snapshotToString(model.createSnapshot()!), `${textContent}${eol}`); + assert.strictEqual(snapshotToString(model.createSnapshot()!), `${textContent}${eol}`); // Remove new lines (multiple lines with multiple new lines) lineContent = `${textContent}${eol}${textContent}${eol}${eol}${eol}`; model.textEditorModel.setValue(lineContent); await participant.participate(model, { reason: SaveReason.EXPLICIT }); - assert.equal(snapshotToString(model.createSnapshot()!), `${textContent}${eol}${textContent}${eol}`); + assert.strictEqual(snapshotToString(model.createSnapshot()!), `${textContent}${eol}${textContent}${eol}`); }); test('trim final new lines bug#39750', async function () { @@ -117,12 +117,12 @@ suite('Save Participants', function () { // undo await model.textEditorModel.undo(); - assert.equal(snapshotToString(model.createSnapshot()!), `${textContent}`); + assert.strictEqual(snapshotToString(model.createSnapshot()!), `${textContent}`); // trim final new lines should not mess the undo stack await participant.participate(model, { reason: SaveReason.EXPLICIT }); await model.textEditorModel.redo(); - assert.equal(snapshotToString(model.createSnapshot()!), `${textContent}.`); + assert.strictEqual(snapshotToString(model.createSnapshot()!), `${textContent}.`); }); test('trim final new lines bug#46075', async function () { @@ -143,13 +143,13 @@ suite('Save Participants', function () { } // confirm trimming - assert.equal(snapshotToString(model.createSnapshot()!), `${textContent}${eol}`); + assert.strictEqual(snapshotToString(model.createSnapshot()!), `${textContent}${eol}`); // undo should go back to previous content immediately await model.textEditorModel.undo(); - assert.equal(snapshotToString(model.createSnapshot()!), `${textContent}${eol}${eol}`); + assert.strictEqual(snapshotToString(model.createSnapshot()!), `${textContent}${eol}${eol}`); await model.textEditorModel.redo(); - assert.equal(snapshotToString(model.createSnapshot()!), `${textContent}${eol}`); + assert.strictEqual(snapshotToString(model.createSnapshot()!), `${textContent}${eol}`); }); test('trim whitespace', async function () { @@ -169,6 +169,6 @@ suite('Save Participants', function () { } // confirm trimming - assert.equal(snapshotToString(model.createSnapshot()!), `${textContent}`); + assert.strictEqual(snapshotToString(model.createSnapshot()!), `${textContent}`); }); }); diff --git a/src/vs/workbench/contrib/files/test/browser/fileEditorInput.test.ts b/src/vs/workbench/contrib/files/test/browser/fileEditorInput.test.ts index 0df2ed5d57bb07b455f2bb22b715aa313ac25ae7..bb2a00ddaa3260ff9c8012f8a388c669688da319 100644 --- a/src/vs/workbench/contrib/files/test/browser/fileEditorInput.test.ts +++ b/src/vs/workbench/contrib/files/test/browser/fileEditorInput.test.ts @@ -102,28 +102,28 @@ suite('Files - FileEditorInput', () => { const preferredResource = toResource.call(this, '/foo/bar/UPDATEFILE.js'); const inputWithoutPreferredResource = createFileInput(resource); - assert.equal(inputWithoutPreferredResource.resource.toString(), resource.toString()); - assert.equal(inputWithoutPreferredResource.preferredResource.toString(), resource.toString()); + assert.strictEqual(inputWithoutPreferredResource.resource.toString(), resource.toString()); + assert.strictEqual(inputWithoutPreferredResource.preferredResource.toString(), resource.toString()); const inputWithPreferredResource = createFileInput(resource, preferredResource); - assert.equal(inputWithPreferredResource.resource.toString(), resource.toString()); - assert.equal(inputWithPreferredResource.preferredResource.toString(), preferredResource.toString()); + assert.strictEqual(inputWithPreferredResource.resource.toString(), resource.toString()); + assert.strictEqual(inputWithPreferredResource.preferredResource.toString(), preferredResource.toString()); let didChangeLabel = false; const listener = inputWithPreferredResource.onDidChangeLabel(e => { didChangeLabel = true; }); - assert.equal(inputWithPreferredResource.getName(), 'UPDATEFILE.js'); + assert.strictEqual(inputWithPreferredResource.getName(), 'UPDATEFILE.js'); const otherPreferredResource = toResource.call(this, '/FOO/BAR/updateFILE.js'); inputWithPreferredResource.setPreferredResource(otherPreferredResource); - assert.equal(inputWithPreferredResource.resource.toString(), resource.toString()); - assert.equal(inputWithPreferredResource.preferredResource.toString(), otherPreferredResource.toString()); - assert.equal(inputWithPreferredResource.getName(), 'updateFILE.js'); - assert.equal(didChangeLabel, true); + assert.strictEqual(inputWithPreferredResource.resource.toString(), resource.toString()); + assert.strictEqual(inputWithPreferredResource.preferredResource.toString(), otherPreferredResource.toString()); + assert.strictEqual(inputWithPreferredResource.getName(), 'updateFILE.js'); + assert.strictEqual(didChangeLabel, true); listener.dispose(); }); @@ -135,20 +135,20 @@ suite('Files - FileEditorInput', () => { }); const input = createFileInput(toResource.call(this, '/foo/bar/file.js'), undefined, mode); - assert.equal(input.getPreferredMode(), mode); + assert.strictEqual(input.getPreferredMode(), mode); const model = await input.resolve() as TextFileEditorModel; - assert.equal(model.textEditorModel!.getModeId(), mode); + assert.strictEqual(model.textEditorModel!.getModeId(), mode); input.setMode('text'); - assert.equal(input.getPreferredMode(), 'text'); - assert.equal(model.textEditorModel!.getModeId(), PLAINTEXT_MODE_ID); + assert.strictEqual(input.getPreferredMode(), 'text'); + assert.strictEqual(model.textEditorModel!.getModeId(), PLAINTEXT_MODE_ID); const input2 = createFileInput(toResource.call(this, '/foo/bar/file.js')); input2.setPreferredMode(mode); const model2 = await input2.resolve() as TextFileEditorModel; - assert.equal(model2.textEditorModel!.getModeId(), mode); + assert.strictEqual(model2.textEditorModel!.getModeId(), mode); }); test('matches', function () { @@ -169,10 +169,10 @@ suite('Files - FileEditorInput', () => { const input = createFileInput(toResource.call(this, '/foo/bar/updatefile.js')); input.setEncoding('utf16', EncodingMode.Encode); - assert.equal(input.getEncoding(), 'utf16'); + assert.strictEqual(input.getEncoding(), 'utf16'); const resolved = await input.resolve() as TextFileEditorModel; - assert.equal(input.getEncoding(), resolved.getEncoding()); + assert.strictEqual(input.getEncoding(), resolved.getEncoding()); resolved.dispose(); }); @@ -237,7 +237,7 @@ suite('Files - FileEditorInput', () => { const model = await accessor.textFileService.files.resolve(input.resource); model.textEditorModel?.setValue('hello world'); - assert.equal(listenerCount, 1); + assert.strictEqual(listenerCount, 1); assert.ok(input.isDirty()); input.dispose(); @@ -269,7 +269,7 @@ suite('Files - FileEditorInput', () => { assert.fail('File Editor Input Factory missing'); } - assert.equal(factory.canSerialize(input), true); + assert.strictEqual(factory.canSerialize(input), true); const inputSerialized = factory.serialize(input); if (!inputSerialized) { @@ -277,7 +277,7 @@ suite('Files - FileEditorInput', () => { } const inputDeserialized = factory.deserialize(instantiationService, inputSerialized); - assert.equal(input.matches(inputDeserialized), true); + assert.strictEqual(input.matches(inputDeserialized), true); const preferredResource = toResource.call(this, '/foo/bar/UPDATEfile.js'); const inputWithPreferredResource = createFileInput(toResource.call(this, '/foo/bar/updatefile.js'), preferredResource); @@ -288,8 +288,8 @@ suite('Files - FileEditorInput', () => { } const inputWithPreferredResourceDeserialized = factory.deserialize(instantiationService, inputWithPreferredResourceSerialized) as FileEditorInput; - assert.equal(inputWithPreferredResource.resource.toString(), inputWithPreferredResourceDeserialized.resource.toString()); - assert.equal(inputWithPreferredResource.preferredResource.toString(), inputWithPreferredResourceDeserialized.preferredResource.toString()); + assert.strictEqual(inputWithPreferredResource.resource.toString(), inputWithPreferredResourceDeserialized.resource.toString()); + assert.strictEqual(inputWithPreferredResource.preferredResource.toString(), inputWithPreferredResourceDeserialized.preferredResource.toString()); }); test('preferred name/description', async function () { @@ -302,16 +302,16 @@ suite('Files - FileEditorInput', () => { didChangeLabelCounter++; }); - assert.equal(customFileInput.getName(), 'My Name'); - assert.equal(customFileInput.getDescription(), 'My Description'); + assert.strictEqual(customFileInput.getName(), 'My Name'); + assert.strictEqual(customFileInput.getDescription(), 'My Description'); customFileInput.setPreferredName('My Name 2'); customFileInput.setPreferredDescription('My Description 2'); - assert.equal(customFileInput.getName(), 'My Name 2'); - assert.equal(customFileInput.getDescription(), 'My Description 2'); + assert.strictEqual(customFileInput.getName(), 'My Name 2'); + assert.strictEqual(customFileInput.getDescription(), 'My Description 2'); - assert.equal(didChangeLabelCounter, 2); + assert.strictEqual(didChangeLabelCounter, 2); customFileInput.dispose(); @@ -332,7 +332,7 @@ suite('Files - FileEditorInput', () => { assert.notEqual(fileInput.getName(), 'My Name 2'); assert.notEqual(fileInput.getDescription(), 'My Description 2'); - assert.equal(didChangeLabelCounter, 0); + assert.strictEqual(didChangeLabelCounter, 0); fileInput.dispose(); }); diff --git a/src/vs/workbench/contrib/files/test/browser/fileOnDiskProvider.test.ts b/src/vs/workbench/contrib/files/test/browser/fileOnDiskProvider.test.ts index 70c2fa9e2d4a8e26685f5183f0166b2489fc18a4..00b36384a89bc865f9d9895d1fcf6fe2f317ae09 100644 --- a/src/vs/workbench/contrib/files/test/browser/fileOnDiskProvider.test.ts +++ b/src/vs/workbench/contrib/files/test/browser/fileOnDiskProvider.test.ts @@ -27,8 +27,8 @@ suite('Files - FileOnDiskContentProvider', () => { const content = await provider.provideTextContent(uri.with({ scheme: 'conflictResolution', query: JSON.stringify({ scheme: uri.scheme }) })); assert.ok(content); - assert.equal(snapshotToString(content!.createSnapshot()), 'Hello Html'); - assert.equal(accessor.fileService.getLastReadFileUri().scheme, uri.scheme); - assert.equal(accessor.fileService.getLastReadFileUri().path, uri.path); + assert.strictEqual(snapshotToString(content!.createSnapshot()), 'Hello Html'); + assert.strictEqual(accessor.fileService.getLastReadFileUri().scheme, uri.scheme); + assert.strictEqual(accessor.fileService.getLastReadFileUri().path, uri.path); }); }); diff --git a/src/vs/workbench/contrib/files/test/browser/textFileEditorTracker.test.ts b/src/vs/workbench/contrib/files/test/browser/textFileEditorTracker.test.ts index 01481b1c855f75b07bd37bd9200e9ea6ce66340a..2ce57b49a97fbd31e21ce08467a83dc03ff0d18a 100644 --- a/src/vs/workbench/contrib/files/test/browser/textFileEditorTracker.test.ts +++ b/src/vs/workbench/contrib/files/test/browser/textFileEditorTracker.test.ts @@ -94,7 +94,7 @@ suite('Files - TextFileEditorTracker', () => { const model = await accessor.textFileService.files.resolve(resource) as IResolvedTextFileEditorModel; model.textEditorModel.setValue('Super Good'); - assert.equal(snapshotToString(model.createSnapshot()!), 'Super Good'); + assert.strictEqual(snapshotToString(model.createSnapshot()!), 'Super Good'); await model.save(); @@ -103,7 +103,7 @@ suite('Files - TextFileEditorTracker', () => { await timeout(0); // due to event updating model async - assert.equal(snapshotToString(model.createSnapshot()!), 'Hello Html'); + assert.strictEqual(snapshotToString(model.createSnapshot()!), 'Hello Html'); tracker.dispose(); (accessor.textFileService.files).dispose(); diff --git a/src/vs/workbench/services/editor/test/browser/editorGroupsService.test.ts b/src/vs/workbench/services/editor/test/browser/editorGroupsService.test.ts index f4a54339f7cf720d81751a35b31e54ef61230652..d12b33a11d4c8a749c37170d4ab3fb5d97aeab84 100644 --- a/src/vs/workbench/services/editor/test/browser/editorGroupsService.test.ts +++ b/src/vs/workbench/services/editor/test/browser/editorGroupsService.test.ts @@ -63,31 +63,31 @@ suite('EditorGroupsService', () => { // always a root group const rootGroup = part.groups[0]; - assert.equal(part.groups.length, 1); - assert.equal(part.count, 1); - assert.equal(rootGroup, part.getGroup(rootGroup.id)); + assert.strictEqual(part.groups.length, 1); + assert.strictEqual(part.count, 1); + assert.strictEqual(rootGroup, part.getGroup(rootGroup.id)); assert.ok(part.activeGroup === rootGroup); - assert.equal(rootGroup.label, 'Group 1'); + assert.strictEqual(rootGroup.label, 'Group 1'); let mru = part.getGroups(GroupsOrder.MOST_RECENTLY_ACTIVE); - assert.equal(mru.length, 1); - assert.equal(mru[0], rootGroup); + assert.strictEqual(mru.length, 1); + assert.strictEqual(mru[0], rootGroup); const rightGroup = part.addGroup(rootGroup, GroupDirection.RIGHT); - assert.equal(rightGroup, part.getGroup(rightGroup.id)); - assert.equal(groupAddedCounter, 1); - assert.equal(part.groups.length, 2); - assert.equal(part.count, 2); + assert.strictEqual(rightGroup, part.getGroup(rightGroup.id)); + assert.strictEqual(groupAddedCounter, 1); + assert.strictEqual(part.groups.length, 2); + assert.strictEqual(part.count, 2); assert.ok(part.activeGroup === rootGroup); - assert.equal(rootGroup.label, 'Group 1'); - assert.equal(rightGroup.label, 'Group 2'); + assert.strictEqual(rootGroup.label, 'Group 1'); + assert.strictEqual(rightGroup.label, 'Group 2'); mru = part.getGroups(GroupsOrder.MOST_RECENTLY_ACTIVE); - assert.equal(mru.length, 2); - assert.equal(mru[0], rootGroup); - assert.equal(mru[1], rightGroup); + assert.strictEqual(mru.length, 2); + assert.strictEqual(mru[0], rootGroup); + assert.strictEqual(mru[1], rightGroup); - assert.equal(activeGroupChangeCounter, 0); + assert.strictEqual(activeGroupChangeCounter, 0); let rootGroupActiveChangeCounter = 0; const rootGroupChangeListener = rootGroup.onDidGroupChange(e => { @@ -105,62 +105,62 @@ suite('EditorGroupsService', () => { part.activateGroup(rightGroup); assert.ok(part.activeGroup === rightGroup); - assert.equal(activeGroupChangeCounter, 1); - assert.equal(rootGroupActiveChangeCounter, 1); - assert.equal(rightGroupActiveChangeCounter, 1); + assert.strictEqual(activeGroupChangeCounter, 1); + assert.strictEqual(rootGroupActiveChangeCounter, 1); + assert.strictEqual(rightGroupActiveChangeCounter, 1); rootGroupChangeListener.dispose(); rightGroupChangeListener.dispose(); mru = part.getGroups(GroupsOrder.MOST_RECENTLY_ACTIVE); - assert.equal(mru.length, 2); - assert.equal(mru[0], rightGroup); - assert.equal(mru[1], rootGroup); + assert.strictEqual(mru.length, 2); + assert.strictEqual(mru[0], rightGroup); + assert.strictEqual(mru[1], rootGroup); const downGroup = part.addGroup(rightGroup, GroupDirection.DOWN); let didDispose = false; downGroup.onWillDispose(() => { didDispose = true; }); - assert.equal(groupAddedCounter, 2); - assert.equal(part.groups.length, 3); + assert.strictEqual(groupAddedCounter, 2); + assert.strictEqual(part.groups.length, 3); assert.ok(part.activeGroup === rightGroup); assert.ok(!downGroup.activeEditorPane); - assert.equal(rootGroup.label, 'Group 1'); - assert.equal(rightGroup.label, 'Group 2'); - assert.equal(downGroup.label, 'Group 3'); + assert.strictEqual(rootGroup.label, 'Group 1'); + assert.strictEqual(rightGroup.label, 'Group 2'); + assert.strictEqual(downGroup.label, 'Group 3'); mru = part.getGroups(GroupsOrder.MOST_RECENTLY_ACTIVE); - assert.equal(mru.length, 3); - assert.equal(mru[0], rightGroup); - assert.equal(mru[1], rootGroup); - assert.equal(mru[2], downGroup); + assert.strictEqual(mru.length, 3); + assert.strictEqual(mru[0], rightGroup); + assert.strictEqual(mru[1], rootGroup); + assert.strictEqual(mru[2], downGroup); const gridOrder = part.getGroups(GroupsOrder.GRID_APPEARANCE); - assert.equal(gridOrder.length, 3); - assert.equal(gridOrder[0], rootGroup); - assert.equal(gridOrder[0].index, 0); - assert.equal(gridOrder[1], rightGroup); - assert.equal(gridOrder[1].index, 1); - assert.equal(gridOrder[2], downGroup); - assert.equal(gridOrder[2].index, 2); + assert.strictEqual(gridOrder.length, 3); + assert.strictEqual(gridOrder[0], rootGroup); + assert.strictEqual(gridOrder[0].index, 0); + assert.strictEqual(gridOrder[1], rightGroup); + assert.strictEqual(gridOrder[1].index, 1); + assert.strictEqual(gridOrder[2], downGroup); + assert.strictEqual(gridOrder[2].index, 2); part.moveGroup(downGroup, rightGroup, GroupDirection.DOWN); - assert.equal(groupMovedCounter, 1); + assert.strictEqual(groupMovedCounter, 1); part.removeGroup(downGroup); assert.ok(!part.getGroup(downGroup.id)); - assert.equal(didDispose, true); - assert.equal(groupRemovedCounter, 1); - assert.equal(part.groups.length, 2); + assert.strictEqual(didDispose, true); + assert.strictEqual(groupRemovedCounter, 1); + assert.strictEqual(part.groups.length, 2); assert.ok(part.activeGroup === rightGroup); - assert.equal(rootGroup.label, 'Group 1'); - assert.equal(rightGroup.label, 'Group 2'); + assert.strictEqual(rootGroup.label, 'Group 1'); + assert.strictEqual(rightGroup.label, 'Group 2'); mru = part.getGroups(GroupsOrder.MOST_RECENTLY_ACTIVE); - assert.equal(mru.length, 2); - assert.equal(mru[0], rightGroup); - assert.equal(mru[1], rootGroup); + assert.strictEqual(mru.length, 2); + assert.strictEqual(mru[0], rightGroup); + assert.strictEqual(mru[1], rootGroup); const rightGroupContextKeyService = part.activeGroup.scopedContextKeyService; const rootGroupContextKeyService = rootGroup.scopedContextKeyService; @@ -170,17 +170,17 @@ suite('EditorGroupsService', () => { assert.ok(rightGroupContextKeyService !== rootGroupContextKeyService); part.removeGroup(rightGroup); - assert.equal(groupRemovedCounter, 2); - assert.equal(part.groups.length, 1); + assert.strictEqual(groupRemovedCounter, 2); + assert.strictEqual(part.groups.length, 1); assert.ok(part.activeGroup === rootGroup); mru = part.getGroups(GroupsOrder.MOST_RECENTLY_ACTIVE); - assert.equal(mru.length, 1); - assert.equal(mru[0], rootGroup); + assert.strictEqual(mru.length, 1); + assert.strictEqual(mru[0], rootGroup); part.removeGroup(rootGroup); // cannot remove root group - assert.equal(part.groups.length, 1); - assert.equal(groupRemovedCounter, 2); + assert.strictEqual(part.groups.length, 1); + assert.strictEqual(groupRemovedCounter, 2); assert.ok(part.activeGroup === rootGroup); part.setGroupOrientation(part.orientation === GroupOrientation.HORIZONTAL ? GroupOrientation.VERTICAL : GroupOrientation.HORIZONTAL); @@ -206,14 +206,14 @@ suite('EditorGroupsService', () => { const rightGroupInput = new TestFileEditorInput(URI.file('foo/bar2'), TEST_EDITOR_INPUT_ID); await rightGroup.openEditor(rightGroupInput, EditorOptions.create({ pinned: true })); - assert.equal(part.groups.length, 3); + assert.strictEqual(part.groups.length, 3); part.saveState(); part.dispose(); let [restoredPart] = createPart(instantiationService); - assert.equal(restoredPart.groups.length, 3); + assert.strictEqual(restoredPart.groups.length, 3); assert.ok(restoredPart.getGroup(rootGroup.id)); assert.ok(restoredPart.getGroup(rightGroup.id)); assert.ok(restoredPart.getGroup(downGroup.id)); @@ -241,38 +241,38 @@ suite('EditorGroupsService', () => { } }); - assert.equal(rootGroup.index, 0); - assert.equal(rightGroup.index, 1); - assert.equal(downGroup.index, 2); - assert.equal(rootGroup.label, 'Group 1'); - assert.equal(rightGroup.label, 'Group 2'); - assert.equal(downGroup.label, 'Group 3'); + assert.strictEqual(rootGroup.index, 0); + assert.strictEqual(rightGroup.index, 1); + assert.strictEqual(downGroup.index, 2); + assert.strictEqual(rootGroup.label, 'Group 1'); + assert.strictEqual(rightGroup.label, 'Group 2'); + assert.strictEqual(downGroup.label, 'Group 3'); part.removeGroup(rightGroup); - assert.equal(rootGroup.index, 0); - assert.equal(downGroup.index, 1); - assert.equal(rootGroup.label, 'Group 1'); - assert.equal(downGroup.label, 'Group 2'); - assert.equal(indexChangeCounter, 1); - assert.equal(groupIndexChangedCounter, 1); + assert.strictEqual(rootGroup.index, 0); + assert.strictEqual(downGroup.index, 1); + assert.strictEqual(rootGroup.label, 'Group 1'); + assert.strictEqual(downGroup.label, 'Group 2'); + assert.strictEqual(indexChangeCounter, 1); + assert.strictEqual(groupIndexChangedCounter, 1); part.moveGroup(downGroup, rootGroup, GroupDirection.UP); - assert.equal(downGroup.index, 0); - assert.equal(rootGroup.index, 1); - assert.equal(downGroup.label, 'Group 1'); - assert.equal(rootGroup.label, 'Group 2'); - assert.equal(indexChangeCounter, 2); - assert.equal(groupIndexChangedCounter, 3); + assert.strictEqual(downGroup.index, 0); + assert.strictEqual(rootGroup.index, 1); + assert.strictEqual(downGroup.label, 'Group 1'); + assert.strictEqual(rootGroup.label, 'Group 2'); + assert.strictEqual(indexChangeCounter, 2); + assert.strictEqual(groupIndexChangedCounter, 3); const newFirstGroup = part.addGroup(downGroup, GroupDirection.UP); - assert.equal(newFirstGroup.index, 0); - assert.equal(downGroup.index, 1); - assert.equal(rootGroup.index, 2); - assert.equal(newFirstGroup.label, 'Group 1'); - assert.equal(downGroup.label, 'Group 2'); - assert.equal(rootGroup.label, 'Group 3'); - assert.equal(indexChangeCounter, 3); - assert.equal(groupIndexChangedCounter, 6); + assert.strictEqual(newFirstGroup.index, 0); + assert.strictEqual(downGroup.index, 1); + assert.strictEqual(rootGroup.index, 2); + assert.strictEqual(newFirstGroup.label, 'Group 1'); + assert.strictEqual(downGroup.label, 'Group 2'); + assert.strictEqual(rootGroup.label, 'Group 3'); + assert.strictEqual(indexChangeCounter, 3); + assert.strictEqual(groupIndexChangedCounter, 6); labelChangeListener.dispose(); groupIndexChangedListener.dispose(); @@ -304,17 +304,17 @@ suite('EditorGroupsService', () => { await rootGroup.openEditor(input, EditorOptions.create({ pinned: true })); const rightGroup = part.addGroup(rootGroup, GroupDirection.RIGHT, { activate: true }); const downGroup = part.copyGroup(rootGroup, rightGroup, GroupDirection.DOWN); - assert.equal(groupAddedCounter, 2); - assert.equal(downGroup.count, 1); + assert.strictEqual(groupAddedCounter, 2); + assert.strictEqual(downGroup.count, 1); assert.ok(downGroup.activeEditor instanceof TestFileEditorInput); part.mergeGroup(rootGroup, rightGroup, { mode: MergeGroupMode.COPY_EDITORS }); - assert.equal(rightGroup.count, 1); + assert.strictEqual(rightGroup.count, 1); assert.ok(rightGroup.activeEditor instanceof TestFileEditorInput); part.mergeGroup(rootGroup, rightGroup, { mode: MergeGroupMode.MOVE_EDITORS }); - assert.equal(rootGroup.count, 0); + assert.strictEqual(rootGroup.count, 0); part.mergeGroup(rootGroup, downGroup); - assert.equal(groupRemovedCounter, 1); - assert.equal(rootGroupDisposed, true); + assert.strictEqual(groupRemovedCounter, 1); + assert.strictEqual(rootGroupDisposed, true); groupAddedListener.dispose(); groupRemovedListener.dispose(); disposeListener.dispose(); @@ -343,9 +343,9 @@ suite('EditorGroupsService', () => { assert.ok(currentOptions); part.enforcePartOptions({ showTabs: false }); - assert.equal(part.partOptions.showTabs, false); - assert.equal(newOptions.showTabs, false); - assert.equal(oldOptions, currentOptions); + assert.strictEqual(part.partOptions.showTabs, false); + assert.strictEqual(newOptions.showTabs, false); + assert.strictEqual(oldOptions, currentOptions); part.dispose(); }); @@ -353,7 +353,7 @@ suite('EditorGroupsService', () => { test('editor basics', async function () { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); await part.whenRestored; @@ -402,56 +402,56 @@ suite('EditorGroupsService', () => { await group.openEditor(input, EditorOptions.create({ pinned: true })); await group.openEditor(inputInactive, EditorOptions.create({ inactive: true })); - assert.equal(group.isActive(input), true); - assert.equal(group.isActive(inputInactive), false); - assert.equal(group.isOpened(input), true); - assert.equal(group.isOpened(inputInactive), true); - assert.equal(group.isEmpty, false); - assert.equal(group.count, 2); - assert.equal(editorWillOpenCounter, 2); - assert.equal(editorDidOpenCounter, 2); - assert.equal(activeEditorChangeCounter, 1); - assert.equal(group.getEditorByIndex(0), input); - assert.equal(group.getEditorByIndex(1), inputInactive); - assert.equal(group.getIndexOfEditor(input), 0); - assert.equal(group.getIndexOfEditor(inputInactive), 1); - - assert.equal(group.previewEditor, inputInactive); - assert.equal(group.isPinned(inputInactive), false); + assert.strictEqual(group.isActive(input), true); + assert.strictEqual(group.isActive(inputInactive), false); + assert.strictEqual(group.isOpened(input), true); + assert.strictEqual(group.isOpened(inputInactive), true); + assert.strictEqual(group.isEmpty, false); + assert.strictEqual(group.count, 2); + assert.strictEqual(editorWillOpenCounter, 2); + assert.strictEqual(editorDidOpenCounter, 2); + assert.strictEqual(activeEditorChangeCounter, 1); + assert.strictEqual(group.getEditorByIndex(0), input); + assert.strictEqual(group.getEditorByIndex(1), inputInactive); + assert.strictEqual(group.getIndexOfEditor(input), 0); + assert.strictEqual(group.getIndexOfEditor(inputInactive), 1); + + assert.strictEqual(group.previewEditor, inputInactive); + assert.strictEqual(group.isPinned(inputInactive), false); group.pinEditor(inputInactive); - assert.equal(editorPinCounter, 1); - assert.equal(group.isPinned(inputInactive), true); + assert.strictEqual(editorPinCounter, 1); + assert.strictEqual(group.isPinned(inputInactive), true); assert.ok(!group.previewEditor); - assert.equal(group.activeEditor, input); - assert.equal(group.activeEditorPane?.getId(), TEST_EDITOR_ID); - assert.equal(group.count, 2); + assert.strictEqual(group.activeEditor, input); + assert.strictEqual(group.activeEditorPane?.getId(), TEST_EDITOR_ID); + assert.strictEqual(group.count, 2); const mru = group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE); - assert.equal(mru[0], input); - assert.equal(mru[1], inputInactive); + assert.strictEqual(mru[0], input); + assert.strictEqual(mru[1], inputInactive); await group.openEditor(inputInactive); - assert.equal(activeEditorChangeCounter, 2); - assert.equal(group.activeEditor, inputInactive); + assert.strictEqual(activeEditorChangeCounter, 2); + assert.strictEqual(group.activeEditor, inputInactive); await group.openEditor(input); await group.closeEditor(inputInactive); - assert.equal(activeEditorChangeCounter, 3); - assert.equal(editorCloseCounter, 1); - assert.equal(editorCloseCounter1, 1); - assert.equal(editorWillCloseCounter, 1); + assert.strictEqual(activeEditorChangeCounter, 3); + assert.strictEqual(editorCloseCounter, 1); + assert.strictEqual(editorCloseCounter1, 1); + assert.strictEqual(editorWillCloseCounter, 1); assert.ok(inputInactive.gotDisposed); - assert.equal(group.activeEditor, input); + assert.strictEqual(group.activeEditor, input); - assert.equal(editorStickyCounter, 0); + assert.strictEqual(editorStickyCounter, 0); group.stickEditor(input); - assert.equal(editorStickyCounter, 1); + assert.strictEqual(editorStickyCounter, 1); group.unstickEditor(input); - assert.equal(editorStickyCounter, 2); + assert.strictEqual(editorStickyCounter, 2); editorCloseListener.dispose(); editorWillCloseListener.dispose(); @@ -463,7 +463,7 @@ suite('EditorGroupsService', () => { test('openEditors / closeEditors', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const input = new TestFileEditorInput(URI.file('foo/bar'), TEST_EDITOR_INPUT_ID); const inputInactive = new TestFileEditorInput(URI.file('foo/bar/inactive'), TEST_EDITOR_INPUT_ID); @@ -473,23 +473,23 @@ suite('EditorGroupsService', () => { { editor: inputInactive } ]); - assert.equal(group.count, 2); - assert.equal(group.getEditorByIndex(0), input); - assert.equal(group.getEditorByIndex(1), inputInactive); + assert.strictEqual(group.count, 2); + assert.strictEqual(group.getEditorByIndex(0), input); + assert.strictEqual(group.getEditorByIndex(1), inputInactive); await group.closeEditors([input, inputInactive]); assert.ok(input.gotDisposed); assert.ok(inputInactive.gotDisposed); - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); part.dispose(); }); test('closeEditors (one, opened in multiple groups)', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const rightGroup = part.addGroup(group, GroupDirection.RIGHT); @@ -511,7 +511,7 @@ suite('EditorGroupsService', () => { test('closeEditors (except one)', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const input1 = new TestFileEditorInput(URI.file('foo/bar1'), TEST_EDITOR_INPUT_ID); const input2 = new TestFileEditorInput(URI.file('foo/bar2'), TEST_EDITOR_INPUT_ID); @@ -523,21 +523,21 @@ suite('EditorGroupsService', () => { { editor: input3 } ]); - assert.equal(group.count, 3); - assert.equal(group.getEditorByIndex(0), input1); - assert.equal(group.getEditorByIndex(1), input2); - assert.equal(group.getEditorByIndex(2), input3); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.getEditorByIndex(0), input1); + assert.strictEqual(group.getEditorByIndex(1), input2); + assert.strictEqual(group.getEditorByIndex(2), input3); await group.closeEditors({ except: input2 }); - assert.equal(group.count, 1); - assert.equal(group.getEditorByIndex(0), input2); + assert.strictEqual(group.count, 1); + assert.strictEqual(group.getEditorByIndex(0), input2); part.dispose(); }); test('closeEditors (except one, sticky editor)', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const input1 = new TestFileEditorInput(URI.file('foo/bar1'), TEST_EDITOR_INPUT_ID); const input2 = new TestFileEditorInput(URI.file('foo/bar2'), TEST_EDITOR_INPUT_ID); @@ -549,31 +549,31 @@ suite('EditorGroupsService', () => { { editor: input3 } ]); - assert.equal(group.count, 3); - assert.equal(group.stickyCount, 1); - assert.equal(group.getEditorByIndex(0), input1); - assert.equal(group.getEditorByIndex(1), input2); - assert.equal(group.getEditorByIndex(2), input3); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.stickyCount, 1); + assert.strictEqual(group.getEditorByIndex(0), input1); + assert.strictEqual(group.getEditorByIndex(1), input2); + assert.strictEqual(group.getEditorByIndex(2), input3); await group.closeEditors({ except: input2, excludeSticky: true }); - assert.equal(group.count, 2); - assert.equal(group.stickyCount, 1); - assert.equal(group.getEditorByIndex(0), input1); - assert.equal(group.getEditorByIndex(1), input2); + assert.strictEqual(group.count, 2); + assert.strictEqual(group.stickyCount, 1); + assert.strictEqual(group.getEditorByIndex(0), input1); + assert.strictEqual(group.getEditorByIndex(1), input2); await group.closeEditors({ except: input2 }); - assert.equal(group.count, 1); - assert.equal(group.stickyCount, 0); - assert.equal(group.getEditorByIndex(0), input2); + assert.strictEqual(group.count, 1); + assert.strictEqual(group.stickyCount, 0); + assert.strictEqual(group.getEditorByIndex(0), input2); part.dispose(); }); test('closeEditors (saved only)', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const input1 = new TestFileEditorInput(URI.file('foo/bar1'), TEST_EDITOR_INPUT_ID); const input2 = new TestFileEditorInput(URI.file('foo/bar2'), TEST_EDITOR_INPUT_ID); @@ -585,20 +585,20 @@ suite('EditorGroupsService', () => { { editor: input3 } ]); - assert.equal(group.count, 3); - assert.equal(group.getEditorByIndex(0), input1); - assert.equal(group.getEditorByIndex(1), input2); - assert.equal(group.getEditorByIndex(2), input3); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.getEditorByIndex(0), input1); + assert.strictEqual(group.getEditorByIndex(1), input2); + assert.strictEqual(group.getEditorByIndex(2), input3); await group.closeEditors({ savedOnly: true }); - assert.equal(group.count, 0); + assert.strictEqual(group.count, 0); part.dispose(); }); test('closeEditors (saved only, sticky editor)', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const input1 = new TestFileEditorInput(URI.file('foo/bar1'), TEST_EDITOR_INPUT_ID); const input2 = new TestFileEditorInput(URI.file('foo/bar2'), TEST_EDITOR_INPUT_ID); @@ -610,27 +610,27 @@ suite('EditorGroupsService', () => { { editor: input3 } ]); - assert.equal(group.count, 3); - assert.equal(group.stickyCount, 1); - assert.equal(group.getEditorByIndex(0), input1); - assert.equal(group.getEditorByIndex(1), input2); - assert.equal(group.getEditorByIndex(2), input3); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.stickyCount, 1); + assert.strictEqual(group.getEditorByIndex(0), input1); + assert.strictEqual(group.getEditorByIndex(1), input2); + assert.strictEqual(group.getEditorByIndex(2), input3); await group.closeEditors({ savedOnly: true, excludeSticky: true }); - assert.equal(group.count, 1); - assert.equal(group.stickyCount, 1); - assert.equal(group.getEditorByIndex(0), input1); + assert.strictEqual(group.count, 1); + assert.strictEqual(group.stickyCount, 1); + assert.strictEqual(group.getEditorByIndex(0), input1); await group.closeEditors({ savedOnly: true }); - assert.equal(group.count, 0); + assert.strictEqual(group.count, 0); part.dispose(); }); test('closeEditors (direction: right)', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const input1 = new TestFileEditorInput(URI.file('foo/bar1'), TEST_EDITOR_INPUT_ID); const input2 = new TestFileEditorInput(URI.file('foo/bar2'), TEST_EDITOR_INPUT_ID); @@ -642,22 +642,22 @@ suite('EditorGroupsService', () => { { editor: input3 } ]); - assert.equal(group.count, 3); - assert.equal(group.getEditorByIndex(0), input1); - assert.equal(group.getEditorByIndex(1), input2); - assert.equal(group.getEditorByIndex(2), input3); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.getEditorByIndex(0), input1); + assert.strictEqual(group.getEditorByIndex(1), input2); + assert.strictEqual(group.getEditorByIndex(2), input3); await group.closeEditors({ direction: CloseDirection.RIGHT, except: input2 }); - assert.equal(group.count, 2); - assert.equal(group.getEditorByIndex(0), input1); - assert.equal(group.getEditorByIndex(1), input2); + assert.strictEqual(group.count, 2); + assert.strictEqual(group.getEditorByIndex(0), input1); + assert.strictEqual(group.getEditorByIndex(1), input2); part.dispose(); }); test('closeEditors (direction: right, sticky editor)', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const input1 = new TestFileEditorInput(URI.file('foo/bar1'), TEST_EDITOR_INPUT_ID); const input2 = new TestFileEditorInput(URI.file('foo/bar2'), TEST_EDITOR_INPUT_ID); @@ -669,29 +669,29 @@ suite('EditorGroupsService', () => { { editor: input3 } ]); - assert.equal(group.count, 3); - assert.equal(group.stickyCount, 1); - assert.equal(group.getEditorByIndex(0), input1); - assert.equal(group.getEditorByIndex(1), input2); - assert.equal(group.getEditorByIndex(2), input3); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.stickyCount, 1); + assert.strictEqual(group.getEditorByIndex(0), input1); + assert.strictEqual(group.getEditorByIndex(1), input2); + assert.strictEqual(group.getEditorByIndex(2), input3); await group.closeEditors({ direction: CloseDirection.RIGHT, except: input2, excludeSticky: true }); - assert.equal(group.count, 2); - assert.equal(group.stickyCount, 1); - assert.equal(group.getEditorByIndex(0), input1); - assert.equal(group.getEditorByIndex(1), input2); + assert.strictEqual(group.count, 2); + assert.strictEqual(group.stickyCount, 1); + assert.strictEqual(group.getEditorByIndex(0), input1); + assert.strictEqual(group.getEditorByIndex(1), input2); await group.closeEditors({ direction: CloseDirection.RIGHT, except: input2 }); - assert.equal(group.count, 2); - assert.equal(group.getEditorByIndex(0), input1); - assert.equal(group.getEditorByIndex(1), input2); + assert.strictEqual(group.count, 2); + assert.strictEqual(group.getEditorByIndex(0), input1); + assert.strictEqual(group.getEditorByIndex(1), input2); part.dispose(); }); test('closeEditors (direction: left)', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const input1 = new TestFileEditorInput(URI.file('foo/bar1'), TEST_EDITOR_INPUT_ID); const input2 = new TestFileEditorInput(URI.file('foo/bar2'), TEST_EDITOR_INPUT_ID); @@ -703,22 +703,22 @@ suite('EditorGroupsService', () => { { editor: input3 } ]); - assert.equal(group.count, 3); - assert.equal(group.getEditorByIndex(0), input1); - assert.equal(group.getEditorByIndex(1), input2); - assert.equal(group.getEditorByIndex(2), input3); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.getEditorByIndex(0), input1); + assert.strictEqual(group.getEditorByIndex(1), input2); + assert.strictEqual(group.getEditorByIndex(2), input3); await group.closeEditors({ direction: CloseDirection.LEFT, except: input2 }); - assert.equal(group.count, 2); - assert.equal(group.getEditorByIndex(0), input2); - assert.equal(group.getEditorByIndex(1), input3); + assert.strictEqual(group.count, 2); + assert.strictEqual(group.getEditorByIndex(0), input2); + assert.strictEqual(group.getEditorByIndex(1), input3); part.dispose(); }); test('closeEditors (direction: left, sticky editor)', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const input1 = new TestFileEditorInput(URI.file('foo/bar1'), TEST_EDITOR_INPUT_ID); const input2 = new TestFileEditorInput(URI.file('foo/bar2'), TEST_EDITOR_INPUT_ID); @@ -730,30 +730,30 @@ suite('EditorGroupsService', () => { { editor: input3 } ]); - assert.equal(group.count, 3); - assert.equal(group.stickyCount, 1); - assert.equal(group.getEditorByIndex(0), input1); - assert.equal(group.getEditorByIndex(1), input2); - assert.equal(group.getEditorByIndex(2), input3); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.stickyCount, 1); + assert.strictEqual(group.getEditorByIndex(0), input1); + assert.strictEqual(group.getEditorByIndex(1), input2); + assert.strictEqual(group.getEditorByIndex(2), input3); await group.closeEditors({ direction: CloseDirection.LEFT, except: input2, excludeSticky: true }); - assert.equal(group.count, 3); - assert.equal(group.stickyCount, 1); - assert.equal(group.getEditorByIndex(0), input1); - assert.equal(group.getEditorByIndex(1), input2); - assert.equal(group.getEditorByIndex(2), input3); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.stickyCount, 1); + assert.strictEqual(group.getEditorByIndex(0), input1); + assert.strictEqual(group.getEditorByIndex(1), input2); + assert.strictEqual(group.getEditorByIndex(2), input3); await group.closeEditors({ direction: CloseDirection.LEFT, except: input2 }); - assert.equal(group.count, 2); - assert.equal(group.getEditorByIndex(0), input2); - assert.equal(group.getEditorByIndex(1), input3); + assert.strictEqual(group.count, 2); + assert.strictEqual(group.getEditorByIndex(0), input2); + assert.strictEqual(group.getEditorByIndex(1), input3); part.dispose(); }); test('closeAllEditors', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const input = new TestFileEditorInput(URI.file('foo/bar'), TEST_EDITOR_INPUT_ID); const inputInactive = new TestFileEditorInput(URI.file('foo/bar/inactive'), TEST_EDITOR_INPUT_ID); @@ -763,19 +763,19 @@ suite('EditorGroupsService', () => { { editor: inputInactive } ]); - assert.equal(group.count, 2); - assert.equal(group.getEditorByIndex(0), input); - assert.equal(group.getEditorByIndex(1), inputInactive); + assert.strictEqual(group.count, 2); + assert.strictEqual(group.getEditorByIndex(0), input); + assert.strictEqual(group.getEditorByIndex(1), inputInactive); await group.closeAllEditors(); - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); part.dispose(); }); test('closeAllEditors (sticky editor)', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const input = new TestFileEditorInput(URI.file('foo/bar'), TEST_EDITOR_INPUT_ID); const inputInactive = new TestFileEditorInput(URI.file('foo/bar/inactive'), TEST_EDITOR_INPUT_ID); @@ -785,18 +785,18 @@ suite('EditorGroupsService', () => { { editor: inputInactive } ]); - assert.equal(group.count, 2); - assert.equal(group.stickyCount, 1); + assert.strictEqual(group.count, 2); + assert.strictEqual(group.stickyCount, 1); await group.closeAllEditors({ excludeSticky: true }); - assert.equal(group.count, 1); - assert.equal(group.stickyCount, 1); - assert.equal(group.getEditorByIndex(0), input); + assert.strictEqual(group.count, 1); + assert.strictEqual(group.stickyCount, 1); + assert.strictEqual(group.getEditorByIndex(0), input); await group.closeAllEditors(); - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); part.dispose(); }); @@ -804,7 +804,7 @@ suite('EditorGroupsService', () => { test('moveEditor (same group)', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const input = new TestFileEditorInput(URI.file('foo/bar'), TEST_EDITOR_INPUT_ID); const inputInactive = new TestFileEditorInput(URI.file('foo/bar/inactive'), TEST_EDITOR_INPUT_ID); @@ -818,13 +818,13 @@ suite('EditorGroupsService', () => { }); await group.openEditors([{ editor: input, options: { pinned: true } }, { editor: inputInactive }]); - assert.equal(group.count, 2); - assert.equal(group.getEditorByIndex(0), input); - assert.equal(group.getEditorByIndex(1), inputInactive); + assert.strictEqual(group.count, 2); + assert.strictEqual(group.getEditorByIndex(0), input); + assert.strictEqual(group.getEditorByIndex(1), inputInactive); group.moveEditor(inputInactive, group, { index: 0 }); - assert.equal(editorMoveCounter, 1); - assert.equal(group.getEditorByIndex(0), inputInactive); - assert.equal(group.getEditorByIndex(1), input); + assert.strictEqual(editorMoveCounter, 1); + assert.strictEqual(group.getEditorByIndex(0), inputInactive); + assert.strictEqual(group.getEditorByIndex(1), input); editorGroupChangeListener.dispose(); part.dispose(); }); @@ -832,7 +832,7 @@ suite('EditorGroupsService', () => { test('moveEditor (across groups)', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const rightGroup = part.addGroup(group, GroupDirection.RIGHT); @@ -840,21 +840,21 @@ suite('EditorGroupsService', () => { const inputInactive = new TestFileEditorInput(URI.file('foo/bar/inactive'), TEST_EDITOR_INPUT_ID); await group.openEditors([{ editor: input, options: { pinned: true } }, { editor: inputInactive }]); - assert.equal(group.count, 2); - assert.equal(group.getEditorByIndex(0), input); - assert.equal(group.getEditorByIndex(1), inputInactive); + assert.strictEqual(group.count, 2); + assert.strictEqual(group.getEditorByIndex(0), input); + assert.strictEqual(group.getEditorByIndex(1), inputInactive); group.moveEditor(inputInactive, rightGroup, { index: 0 }); - assert.equal(group.count, 1); - assert.equal(group.getEditorByIndex(0), input); - assert.equal(rightGroup.count, 1); - assert.equal(rightGroup.getEditorByIndex(0), inputInactive); + assert.strictEqual(group.count, 1); + assert.strictEqual(group.getEditorByIndex(0), input); + assert.strictEqual(rightGroup.count, 1); + assert.strictEqual(rightGroup.getEditorByIndex(0), inputInactive); part.dispose(); }); test('copyEditor (across groups)', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const rightGroup = part.addGroup(group, GroupDirection.RIGHT); @@ -862,33 +862,33 @@ suite('EditorGroupsService', () => { const inputInactive = new TestFileEditorInput(URI.file('foo/bar/inactive'), TEST_EDITOR_INPUT_ID); await group.openEditors([{ editor: input, options: { pinned: true } }, { editor: inputInactive }]); - assert.equal(group.count, 2); - assert.equal(group.getEditorByIndex(0), input); - assert.equal(group.getEditorByIndex(1), inputInactive); + assert.strictEqual(group.count, 2); + assert.strictEqual(group.getEditorByIndex(0), input); + assert.strictEqual(group.getEditorByIndex(1), inputInactive); group.copyEditor(inputInactive, rightGroup, { index: 0 }); - assert.equal(group.count, 2); - assert.equal(group.getEditorByIndex(0), input); - assert.equal(group.getEditorByIndex(1), inputInactive); - assert.equal(rightGroup.count, 1); - assert.equal(rightGroup.getEditorByIndex(0), inputInactive); + assert.strictEqual(group.count, 2); + assert.strictEqual(group.getEditorByIndex(0), input); + assert.strictEqual(group.getEditorByIndex(1), inputInactive); + assert.strictEqual(rightGroup.count, 1); + assert.strictEqual(rightGroup.getEditorByIndex(0), inputInactive); part.dispose(); }); test('replaceEditors', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const input = new TestFileEditorInput(URI.file('foo/bar'), TEST_EDITOR_INPUT_ID); const inputInactive = new TestFileEditorInput(URI.file('foo/bar/inactive'), TEST_EDITOR_INPUT_ID); await group.openEditor(input); - assert.equal(group.count, 1); - assert.equal(group.getEditorByIndex(0), input); + assert.strictEqual(group.count, 1); + assert.strictEqual(group.getEditorByIndex(0), input); await group.replaceEditors([{ editor: input, replacement: inputInactive }]); - assert.equal(group.count, 1); - assert.equal(group.getEditorByIndex(0), inputInactive); + assert.strictEqual(group.count, 1); + assert.strictEqual(group.getEditorByIndex(0), inputInactive); part.dispose(); }); @@ -897,8 +897,8 @@ suite('EditorGroupsService', () => { const rootGroup = part.activeGroup; const rightGroup = part.addGroup(rootGroup, GroupDirection.RIGHT); - assert.equal(rightGroup, part.findGroup({ direction: GroupDirection.RIGHT }, rootGroup)); - assert.equal(rootGroup, part.findGroup({ direction: GroupDirection.LEFT }, rightGroup)); + assert.strictEqual(rightGroup, part.findGroup({ direction: GroupDirection.RIGHT }, rootGroup)); + assert.strictEqual(rootGroup, part.findGroup({ direction: GroupDirection.LEFT }, rightGroup)); part.dispose(); }); @@ -908,8 +908,8 @@ suite('EditorGroupsService', () => { const rootGroup = part.activeGroup; const downGroup = part.addGroup(rootGroup, GroupDirection.DOWN); - assert.equal(downGroup, part.findGroup({ direction: GroupDirection.DOWN }, rootGroup)); - assert.equal(rootGroup, part.findGroup({ direction: GroupDirection.UP }, downGroup)); + assert.strictEqual(downGroup, part.findGroup({ direction: GroupDirection.DOWN }, rootGroup)); + assert.strictEqual(rootGroup, part.findGroup({ direction: GroupDirection.UP }, downGroup)); part.dispose(); }); @@ -920,14 +920,14 @@ suite('EditorGroupsService', () => { const rightGroup = part.addGroup(rootGroup, GroupDirection.RIGHT); const downGroup = part.addGroup(rightGroup, GroupDirection.DOWN); - assert.equal(rootGroup, part.findGroup({ location: GroupLocation.FIRST })); - assert.equal(downGroup, part.findGroup({ location: GroupLocation.LAST })); + assert.strictEqual(rootGroup, part.findGroup({ location: GroupLocation.FIRST })); + assert.strictEqual(downGroup, part.findGroup({ location: GroupLocation.LAST })); - assert.equal(rightGroup, part.findGroup({ location: GroupLocation.NEXT }, rootGroup)); - assert.equal(rootGroup, part.findGroup({ location: GroupLocation.PREVIOUS }, rightGroup)); + assert.strictEqual(rightGroup, part.findGroup({ location: GroupLocation.NEXT }, rootGroup)); + assert.strictEqual(rootGroup, part.findGroup({ location: GroupLocation.PREVIOUS }, rightGroup)); - assert.equal(downGroup, part.findGroup({ location: GroupLocation.NEXT }, rightGroup)); - assert.equal(rightGroup, part.findGroup({ location: GroupLocation.PREVIOUS }, downGroup)); + assert.strictEqual(downGroup, part.findGroup({ location: GroupLocation.NEXT }, rightGroup)); + assert.strictEqual(rightGroup, part.findGroup({ location: GroupLocation.PREVIOUS }, downGroup)); part.dispose(); }); @@ -937,7 +937,7 @@ suite('EditorGroupsService', () => { part.applyLayout({ groups: [{ groups: [{}, {}] }, { groups: [{}, {}] }], orientation: GroupOrientation.HORIZONTAL }); - assert.equal(part.groups.length, 4); + assert.strictEqual(part.groups.length, 4); part.dispose(); }); @@ -947,7 +947,7 @@ suite('EditorGroupsService', () => { part.centerLayout(true); - assert.equal(part.isLayoutCentered(), true); + assert.strictEqual(part.isLayoutCentered(), true); part.dispose(); }); @@ -958,11 +958,11 @@ suite('EditorGroupsService', () => { await part.whenRestored; - assert.equal(group.stickyCount, 0); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL).length, 0); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }).length, 0); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true }).length, 0); + assert.strictEqual(group.stickyCount, 0); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL).length, 0); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }).length, 0); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true }).length, 0); const input = new TestFileEditorInput(URI.file('foo/bar'), TEST_EDITOR_INPUT_ID); const inputInactive = new TestFileEditorInput(URI.file('foo/bar/inactive'), TEST_EDITOR_INPUT_ID); @@ -970,39 +970,39 @@ suite('EditorGroupsService', () => { await group.openEditor(input, EditorOptions.create({ pinned: true })); await group.openEditor(inputInactive, EditorOptions.create({ inactive: true })); - assert.equal(group.stickyCount, 0); - assert.equal(group.isSticky(input), false); - assert.equal(group.isSticky(inputInactive), false); + assert.strictEqual(group.stickyCount, 0); + assert.strictEqual(group.isSticky(input), false); + assert.strictEqual(group.isSticky(inputInactive), false); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL).length, 2); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 2); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }).length, 2); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true }).length, 2); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL).length, 2); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 2); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }).length, 2); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true }).length, 2); group.stickEditor(input); - assert.equal(group.stickyCount, 1); - assert.equal(group.isSticky(input), true); - assert.equal(group.isSticky(inputInactive), false); + assert.strictEqual(group.stickyCount, 1); + assert.strictEqual(group.isSticky(input), true); + assert.strictEqual(group.isSticky(inputInactive), false); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL).length, 2); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 2); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }).length, 1); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true }).length, 1); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL).length, 2); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 2); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }).length, 1); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true }).length, 1); group.unstickEditor(input); - assert.equal(group.stickyCount, 0); - assert.equal(group.isSticky(input), false); - assert.equal(group.isSticky(inputInactive), false); + assert.strictEqual(group.stickyCount, 0); + assert.strictEqual(group.isSticky(input), false); + assert.strictEqual(group.isSticky(inputInactive), false); - assert.equal(group.getIndexOfEditor(input), 0); - assert.equal(group.getIndexOfEditor(inputInactive), 1); + assert.strictEqual(group.getIndexOfEditor(input), 0); + assert.strictEqual(group.getIndexOfEditor(inputInactive), 1); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL).length, 2); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 2); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }).length, 2); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true }).length, 2); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL).length, 2); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 2); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }).length, 2); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true }).length, 2); let editorMoveCounter = 0; const editorGroupChangeListener = group.onDidGroupChange(e => { @@ -1014,42 +1014,42 @@ suite('EditorGroupsService', () => { group.stickEditor(inputInactive); - assert.equal(group.stickyCount, 1); - assert.equal(group.isSticky(input), false); - assert.equal(group.isSticky(inputInactive), true); + assert.strictEqual(group.stickyCount, 1); + assert.strictEqual(group.isSticky(input), false); + assert.strictEqual(group.isSticky(inputInactive), true); - assert.equal(group.getIndexOfEditor(input), 1); - assert.equal(group.getIndexOfEditor(inputInactive), 0); - assert.equal(editorMoveCounter, 1); + assert.strictEqual(group.getIndexOfEditor(input), 1); + assert.strictEqual(group.getIndexOfEditor(inputInactive), 0); + assert.strictEqual(editorMoveCounter, 1); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL).length, 2); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 2); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }).length, 1); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true }).length, 1); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL).length, 2); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 2); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }).length, 1); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true }).length, 1); const inputSticky = new TestFileEditorInput(URI.file('foo/bar/sticky'), TEST_EDITOR_INPUT_ID); await group.openEditor(inputSticky, EditorOptions.create({ sticky: true })); - assert.equal(group.stickyCount, 2); - assert.equal(group.isSticky(input), false); - assert.equal(group.isSticky(inputInactive), true); - assert.equal(group.isSticky(inputSticky), true); + assert.strictEqual(group.stickyCount, 2); + assert.strictEqual(group.isSticky(input), false); + assert.strictEqual(group.isSticky(inputInactive), true); + assert.strictEqual(group.isSticky(inputSticky), true); - assert.equal(group.getIndexOfEditor(inputInactive), 0); - assert.equal(group.getIndexOfEditor(inputSticky), 1); - assert.equal(group.getIndexOfEditor(input), 2); + assert.strictEqual(group.getIndexOfEditor(inputInactive), 0); + assert.strictEqual(group.getIndexOfEditor(inputSticky), 1); + assert.strictEqual(group.getIndexOfEditor(input), 2); await group.openEditor(input, EditorOptions.create({ sticky: true })); - assert.equal(group.stickyCount, 3); - assert.equal(group.isSticky(input), true); - assert.equal(group.isSticky(inputInactive), true); - assert.equal(group.isSticky(inputSticky), true); + assert.strictEqual(group.stickyCount, 3); + assert.strictEqual(group.isSticky(input), true); + assert.strictEqual(group.isSticky(inputInactive), true); + assert.strictEqual(group.isSticky(inputSticky), true); - assert.equal(group.getIndexOfEditor(inputInactive), 0); - assert.equal(group.getIndexOfEditor(inputSticky), 1); - assert.equal(group.getIndexOfEditor(input), 2); + assert.strictEqual(group.getIndexOfEditor(inputInactive), 0); + assert.strictEqual(group.getIndexOfEditor(inputSticky), 1); + assert.strictEqual(group.getIndexOfEditor(input), 2); editorGroupChangeListener.dispose(); part.dispose(); @@ -1058,7 +1058,7 @@ suite('EditorGroupsService', () => { test('moveEditor with context (across groups)', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const rightGroup = part.addGroup(group, GroupDirection.RIGHT); @@ -1069,7 +1069,7 @@ suite('EditorGroupsService', () => { firstOpenEditorContext = e.context; }); await group.openEditors([{ editor: input, options: { pinned: true } }, { editor: inputInactive }]); - assert.equal(firstOpenEditorContext, undefined); + assert.strictEqual(firstOpenEditorContext, undefined); const waitForEditorWillOpen = new Promise(resolve => { Event.once(rightGroup.onWillOpenEditor)(e => resolve(e.context)); @@ -1077,14 +1077,14 @@ suite('EditorGroupsService', () => { group.moveEditor(inputInactive, rightGroup, { index: 0 }); const context = await waitForEditorWillOpen; - assert.equal(context, OpenEditorContext.MOVE_EDITOR); + assert.strictEqual(context, OpenEditorContext.MOVE_EDITOR); part.dispose(); }); test('copyEditor with context (across groups)', async () => { const [part] = createPart(); const group = part.activeGroup; - assert.equal(group.isEmpty, true); + assert.strictEqual(group.isEmpty, true); const rightGroup = part.addGroup(group, GroupDirection.RIGHT); const input = new TestFileEditorInput(URI.file('foo/bar'), TEST_EDITOR_INPUT_ID); @@ -1096,7 +1096,7 @@ suite('EditorGroupsService', () => { group.copyEditor(inputInactive, rightGroup, { index: 0 }); const context = await waitForEditorWillOpen; - assert.equal(context, OpenEditorContext.COPY_EDITOR); + assert.strictEqual(context, OpenEditorContext.COPY_EDITOR); part.dispose(); }); }); diff --git a/src/vs/workbench/services/editor/test/browser/editorService.test.ts b/src/vs/workbench/services/editor/test/browser/editorService.test.ts index 5451b25bddfe5a04c17b0cf6ee0fdf54582f9c0e..96ce45db5e578ed74ad7d1b48fe44645cdd480aa 100644 --- a/src/vs/workbench/services/editor/test/browser/editorService.test.ts +++ b/src/vs/workbench/services/editor/test/browser/editorService.test.ts @@ -94,36 +94,36 @@ suite('EditorService', () => { // Open input let editor = await service.openEditor(input, { pinned: true }); - assert.equal(editor?.getId(), TEST_EDITOR_ID); - assert.equal(editor, service.activeEditorPane); - assert.equal(1, service.count); - assert.equal(input, service.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0].editor); - assert.equal(input, service.getEditors(EditorsOrder.SEQUENTIAL)[0].editor); - assert.equal(input, service.activeEditor); - assert.equal(service.visibleEditorPanes.length, 1); - assert.equal(service.visibleEditorPanes[0], editor); + assert.strictEqual(editor?.getId(), TEST_EDITOR_ID); + assert.strictEqual(editor, service.activeEditorPane); + assert.strictEqual(1, service.count); + assert.strictEqual(input, service.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0].editor); + assert.strictEqual(input, service.getEditors(EditorsOrder.SEQUENTIAL)[0].editor); + assert.strictEqual(input, service.activeEditor); + assert.strictEqual(service.visibleEditorPanes.length, 1); + assert.strictEqual(service.visibleEditorPanes[0], editor); assert.ok(!service.activeTextEditorControl); assert.ok(!service.activeTextEditorMode); - assert.equal(service.visibleTextEditorControls.length, 0); - assert.equal(service.isOpen(input), true); - assert.equal(service.isOpen({ resource: input.resource }), true); - assert.equal(activeEditorChangeEventCounter, 1); - assert.equal(visibleEditorChangeEventCounter, 1); + assert.strictEqual(service.visibleTextEditorControls.length, 0); + assert.strictEqual(service.isOpen(input), true); + assert.strictEqual(service.isOpen({ resource: input.resource }), true); + assert.strictEqual(activeEditorChangeEventCounter, 1); + assert.strictEqual(visibleEditorChangeEventCounter, 1); // Close input await editor?.group?.closeEditor(input); - assert.equal(0, service.count); - assert.equal(0, service.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length); - assert.equal(0, service.getEditors(EditorsOrder.SEQUENTIAL).length); - assert.equal(didCloseEditorListenerCounter, 1); - assert.equal(activeEditorChangeEventCounter, 2); - assert.equal(visibleEditorChangeEventCounter, 2); + assert.strictEqual(0, service.count); + assert.strictEqual(0, service.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length); + assert.strictEqual(0, service.getEditors(EditorsOrder.SEQUENTIAL).length); + assert.strictEqual(didCloseEditorListenerCounter, 1); + assert.strictEqual(activeEditorChangeEventCounter, 2); + assert.strictEqual(visibleEditorChangeEventCounter, 2); assert.ok(input.gotDisposed); // Open again 2 inputs (disposed editors are ignored!) await service.openEditor(input, { pinned: true }); - assert.equal(0, service.count); + assert.strictEqual(0, service.count); // Open again 2 inputs (recreate because disposed) input = new TestFileEditorInput(URI.parse('my://resource-basics'), TEST_EDITOR_INPUT_ID); @@ -132,40 +132,40 @@ suite('EditorService', () => { await service.openEditor(input, { pinned: true }); editor = await service.openEditor(otherInput, { pinned: true }); - assert.equal(2, service.count); - assert.equal(otherInput, service.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0].editor); - assert.equal(input, service.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[1].editor); - assert.equal(input, service.getEditors(EditorsOrder.SEQUENTIAL)[0].editor); - assert.equal(otherInput, service.getEditors(EditorsOrder.SEQUENTIAL)[1].editor); - assert.equal(service.visibleEditorPanes.length, 1); - assert.equal(service.isOpen(input), true); - assert.equal(service.isOpen({ resource: input.resource }), true); - assert.equal(service.isOpen(otherInput), true); - assert.equal(service.isOpen({ resource: otherInput.resource }), true); + assert.strictEqual(2, service.count); + assert.strictEqual(otherInput, service.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0].editor); + assert.strictEqual(input, service.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[1].editor); + assert.strictEqual(input, service.getEditors(EditorsOrder.SEQUENTIAL)[0].editor); + assert.strictEqual(otherInput, service.getEditors(EditorsOrder.SEQUENTIAL)[1].editor); + assert.strictEqual(service.visibleEditorPanes.length, 1); + assert.strictEqual(service.isOpen(input), true); + assert.strictEqual(service.isOpen({ resource: input.resource }), true); + assert.strictEqual(service.isOpen(otherInput), true); + assert.strictEqual(service.isOpen({ resource: otherInput.resource }), true); - assert.equal(activeEditorChangeEventCounter, 4); - assert.equal(visibleEditorChangeEventCounter, 4); + assert.strictEqual(activeEditorChangeEventCounter, 4); + assert.strictEqual(visibleEditorChangeEventCounter, 4); const stickyInput = new TestFileEditorInput(URI.parse('my://resource3-basics'), TEST_EDITOR_INPUT_ID); await service.openEditor(stickyInput, { sticky: true }); - assert.equal(3, service.count); + assert.strictEqual(3, service.count); const allSequentialEditors = service.getEditors(EditorsOrder.SEQUENTIAL); - assert.equal(allSequentialEditors.length, 3); - assert.equal(stickyInput, allSequentialEditors[0].editor); - assert.equal(input, allSequentialEditors[1].editor); - assert.equal(otherInput, allSequentialEditors[2].editor); + assert.strictEqual(allSequentialEditors.length, 3); + assert.strictEqual(stickyInput, allSequentialEditors[0].editor); + assert.strictEqual(input, allSequentialEditors[1].editor); + assert.strictEqual(otherInput, allSequentialEditors[2].editor); const sequentialEditorsExcludingSticky = service.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }); - assert.equal(sequentialEditorsExcludingSticky.length, 2); - assert.equal(input, sequentialEditorsExcludingSticky[0].editor); - assert.equal(otherInput, sequentialEditorsExcludingSticky[1].editor); + assert.strictEqual(sequentialEditorsExcludingSticky.length, 2); + assert.strictEqual(input, sequentialEditorsExcludingSticky[0].editor); + assert.strictEqual(otherInput, sequentialEditorsExcludingSticky[1].editor); const mruEditorsExcludingSticky = service.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true }); - assert.equal(mruEditorsExcludingSticky.length, 2); - assert.equal(input, sequentialEditorsExcludingSticky[0].editor); - assert.equal(otherInput, sequentialEditorsExcludingSticky[1].editor); + assert.strictEqual(mruEditorsExcludingSticky.length, 2); + assert.strictEqual(input, sequentialEditorsExcludingSticky[0].editor); + assert.strictEqual(otherInput, sequentialEditorsExcludingSticky[1].editor); activeEditorChangeListener.dispose(); visibleEditorChangeListener.dispose(); @@ -184,39 +184,39 @@ suite('EditorService', () => { await part.whenRestored; const editor1 = await service.openEditor(sideBySideInput, { pinned: true }); - assert.equal(part.activeGroup.count, 1); + assert.strictEqual(part.activeGroup.count, 1); - assert.equal(service.isOpen(input), false); - assert.equal(service.isOpen(otherInput), false); - assert.equal(service.isOpen(sideBySideInput), true); - assert.equal(service.isOpen({ resource: input.resource }), false); - assert.equal(service.isOpen({ resource: otherInput.resource }), true); + assert.strictEqual(service.isOpen(input), false); + assert.strictEqual(service.isOpen(otherInput), false); + assert.strictEqual(service.isOpen(sideBySideInput), true); + assert.strictEqual(service.isOpen({ resource: input.resource }), false); + assert.strictEqual(service.isOpen({ resource: otherInput.resource }), true); const editor2 = await service.openEditor(input, { pinned: true }); - assert.equal(part.activeGroup.count, 2); + assert.strictEqual(part.activeGroup.count, 2); - assert.equal(service.isOpen(input), true); - assert.equal(service.isOpen(otherInput), false); - assert.equal(service.isOpen(sideBySideInput), true); - assert.equal(service.isOpen({ resource: input.resource }), true); - assert.equal(service.isOpen({ resource: otherInput.resource }), true); + assert.strictEqual(service.isOpen(input), true); + assert.strictEqual(service.isOpen(otherInput), false); + assert.strictEqual(service.isOpen(sideBySideInput), true); + assert.strictEqual(service.isOpen({ resource: input.resource }), true); + assert.strictEqual(service.isOpen({ resource: otherInput.resource }), true); await editor2?.group?.closeEditor(input); - assert.equal(part.activeGroup.count, 1); + assert.strictEqual(part.activeGroup.count, 1); - assert.equal(service.isOpen(input), false); - assert.equal(service.isOpen(otherInput), false); - assert.equal(service.isOpen(sideBySideInput), true); - assert.equal(service.isOpen({ resource: input.resource }), false); - assert.equal(service.isOpen({ resource: otherInput.resource }), true); + assert.strictEqual(service.isOpen(input), false); + assert.strictEqual(service.isOpen(otherInput), false); + assert.strictEqual(service.isOpen(sideBySideInput), true); + assert.strictEqual(service.isOpen({ resource: input.resource }), false); + assert.strictEqual(service.isOpen({ resource: otherInput.resource }), true); await editor1?.group?.closeEditor(sideBySideInput); - assert.equal(service.isOpen(input), false); - assert.equal(service.isOpen(otherInput), false); - assert.equal(service.isOpen(sideBySideInput), false); - assert.equal(service.isOpen({ resource: input.resource }), false); - assert.equal(service.isOpen({ resource: otherInput.resource }), false); + assert.strictEqual(service.isOpen(input), false); + assert.strictEqual(service.isOpen(otherInput), false); + assert.strictEqual(service.isOpen(sideBySideInput), false); + assert.strictEqual(service.isOpen({ resource: input.resource }), false); + assert.strictEqual(service.isOpen({ resource: otherInput.resource }), false); part.dispose(); }); @@ -232,12 +232,12 @@ suite('EditorService', () => { // Open editors await service.openEditors([{ editor: input }, { editor: otherInput }]); - assert.equal(part.activeGroup.count, 2); + assert.strictEqual(part.activeGroup.count, 2); // Replace editors await service.replaceEditors([{ editor: input, replacement: replaceInput }], part.activeGroup); - assert.equal(part.activeGroup.count, 2); - assert.equal(part.activeGroup.getIndexOfEditor(replaceInput), 0); + assert.strictEqual(part.activeGroup.count, 2); + assert.strictEqual(part.activeGroup.getIndexOfEditor(replaceInput), 0); part.dispose(); }); @@ -255,17 +255,17 @@ suite('EditorService', () => { const fileEditorInput2 = service.createEditorInput({ resource: fileResource2 }); assert.ok(fileEditorInput2); - assert.notEqual(fileEditorInput1, fileEditorInput2); + assert.notStrictEqual(fileEditorInput1, fileEditorInput2); const fileEditorInput1Again = service.createEditorInput({ resource: fileResource1 }); - assert.equal(fileEditorInput1Again, fileEditorInput1); + assert.strictEqual(fileEditorInput1Again, fileEditorInput1); fileEditorInput1Again.dispose(); assert.ok(fileEditorInput1.isDisposed()); const fileEditorInput1AgainAndAgain = service.createEditorInput({ resource: fileResource1 }); - assert.notEqual(fileEditorInput1AgainAndAgain, fileEditorInput1); + assert.notStrictEqual(fileEditorInput1AgainAndAgain, fileEditorInput1); assert.ok(!fileEditorInput1AgainAndAgain.isDisposed()); // Cached Input (Resource) @@ -277,17 +277,17 @@ suite('EditorService', () => { const input2 = service.createEditorInput({ resource: resource2 }); assert.ok(input2); - assert.notEqual(input1, input2); + assert.notStrictEqual(input1, input2); const input1Again = service.createEditorInput({ resource: resource1 }); - assert.equal(input1Again, input1); + assert.strictEqual(input1Again, input1); input1Again.dispose(); assert.ok(input1.isDisposed()); const input1AgainAndAgain = service.createEditorInput({ resource: resource1 }); - assert.notEqual(input1AgainAndAgain, input1); + assert.notStrictEqual(input1AgainAndAgain, input1); assert.ok(!input1AgainAndAgain.isDisposed()); }); @@ -311,34 +311,34 @@ suite('EditorService', () => { let inputDifferentCase = service.createEditorInput({ resource: toResource.call(this, '/INDEX.html') }); if (!isLinux) { - assert.equal(input, inputDifferentCase); - assert.equal(input.resource?.toString(), inputDifferentCase.resource?.toString()); + assert.strictEqual(input, inputDifferentCase); + assert.strictEqual(input.resource?.toString(), inputDifferentCase.resource?.toString()); } else { - assert.notEqual(input, inputDifferentCase); - assert.notEqual(input.resource?.toString(), inputDifferentCase.resource?.toString()); + assert.notStrictEqual(input, inputDifferentCase); + assert.notStrictEqual(input.resource?.toString(), inputDifferentCase.resource?.toString()); } // Typed Input - assert.equal(service.createEditorInput(input), input); - assert.equal(service.createEditorInput({ editor: input }), input); + assert.strictEqual(service.createEditorInput(input), input); + assert.strictEqual(service.createEditorInput({ editor: input }), input); // Untyped Input (file, encoding) input = service.createEditorInput({ resource: toResource.call(this, '/index.html'), encoding: 'utf16le', options: { selection: { startLineNumber: 1, startColumn: 1 } } }); assert(input instanceof FileEditorInput); contentInput = input; - assert.equal(contentInput.getPreferredEncoding(), 'utf16le'); + assert.strictEqual(contentInput.getPreferredEncoding(), 'utf16le'); // Untyped Input (file, mode) input = service.createEditorInput({ resource: toResource.call(this, '/index.html'), mode }); assert(input instanceof FileEditorInput); contentInput = input; - assert.equal(contentInput.getPreferredMode(), mode); + assert.strictEqual(contentInput.getPreferredMode(), mode); // Untyped Input (file, different mode) input = service.createEditorInput({ resource: toResource.call(this, '/index.html'), mode: 'text' }); assert(input instanceof FileEditorInput); contentInput = input; - assert.equal(contentInput.getPreferredMode(), 'text'); + assert.strictEqual(contentInput.getPreferredMode(), 'text'); // Untyped Input (untitled) input = service.createEditorInput({ options: { selection: { startLineNumber: 1, startColumn: 1 } } }); @@ -348,13 +348,13 @@ suite('EditorService', () => { input = service.createEditorInput({ contents: 'Hello Untitled', options: { selection: { startLineNumber: 1, startColumn: 1 } } }); assert(input instanceof UntitledTextEditorInput); let model = await input.resolve() as UntitledTextEditorModel; - assert.equal(model.textEditorModel?.getValue(), 'Hello Untitled'); + assert.strictEqual(model.textEditorModel?.getValue(), 'Hello Untitled'); // Untyped Input (untitled with mode) input = service.createEditorInput({ mode, options: { selection: { startLineNumber: 1, startColumn: 1 } } }); assert(input instanceof UntitledTextEditorInput); model = await input.resolve() as UntitledTextEditorModel; - assert.equal(model.getMode(), mode); + assert.strictEqual(model.getMode(), mode); // Untyped Input (untitled with file path) input = service.createEditorInput({ resource: URI.file('/some/path.txt'), forceUntitled: true, options: { selection: { startLineNumber: 1, startColumn: 1 } } }); @@ -434,16 +434,16 @@ suite('EditorService', () => { await service.openEditor(input, { pinned: true }, rightGroup); const editors = service.editors; - assert.equal(editors.length, 2); - assert.equal(editors[0], input); - assert.equal(editors[1], input); + assert.strictEqual(editors.length, 2); + assert.strictEqual(editors[0], input); + assert.strictEqual(editors[1], input); // Close input await rootGroup.closeEditor(input); - assert.equal(input.isDisposed(), false); + assert.strictEqual(input.isDisposed(), false); await rightGroup.closeEditor(input); - assert.equal(input.isDisposed(), true); + assert.strictEqual(input.isDisposed(), true); part.dispose(); }); @@ -461,15 +461,15 @@ suite('EditorService', () => { await service.openEditor(input1, { pinned: true }, rootGroup); let editor = await service.openEditor(input1, { pinned: true, preserveFocus: true }, SIDE_GROUP); - assert.equal(part.activeGroup, rootGroup); - assert.equal(part.count, 2); - assert.equal(editor?.group, part.groups[1]); + assert.strictEqual(part.activeGroup, rootGroup); + assert.strictEqual(part.count, 2); + assert.strictEqual(editor?.group, part.groups[1]); // Open to the side uses existing neighbour group if any editor = await service.openEditor(input2, { pinned: true, preserveFocus: true }, SIDE_GROUP); - assert.equal(part.activeGroup, rootGroup); - assert.equal(part.count, 2); - assert.equal(editor?.group, part.groups[1]); + assert.strictEqual(part.activeGroup, rootGroup); + assert.strictEqual(part.count, 2); + assert.strictEqual(editor?.group, part.groups[1]); part.dispose(); }); @@ -488,23 +488,23 @@ suite('EditorService', () => { let editor = await service.openEditor(input2, { pinned: true, preserveFocus: true, activation: EditorActivation.ACTIVATE }, SIDE_GROUP); const sideGroup = editor?.group; - assert.equal(part.activeGroup, sideGroup); + assert.strictEqual(part.activeGroup, sideGroup); editor = await service.openEditor(input1, { pinned: true, preserveFocus: true, activation: EditorActivation.PRESERVE }, rootGroup); - assert.equal(part.activeGroup, sideGroup); + assert.strictEqual(part.activeGroup, sideGroup); editor = await service.openEditor(input1, { pinned: true, preserveFocus: true, activation: EditorActivation.ACTIVATE }, rootGroup); - assert.equal(part.activeGroup, rootGroup); + assert.strictEqual(part.activeGroup, rootGroup); editor = await service.openEditor(input2, { pinned: true, activation: EditorActivation.PRESERVE }, sideGroup); - assert.equal(part.activeGroup, rootGroup); + assert.strictEqual(part.activeGroup, rootGroup); editor = await service.openEditor(input2, { pinned: true, activation: EditorActivation.ACTIVATE }, sideGroup); - assert.equal(part.activeGroup, sideGroup); + assert.strictEqual(part.activeGroup, sideGroup); part.arrangeGroups(GroupsArrangement.MINIMIZE_OTHERS); editor = await service.openEditor(input1, { pinned: true, preserveFocus: true, activation: EditorActivation.RESTORE }, rootGroup); - assert.equal(part.activeGroup, sideGroup); + assert.strictEqual(part.activeGroup, sideGroup); part.dispose(); }); @@ -526,12 +526,12 @@ suite('EditorService', () => { }); function assertActiveEditorChangedEvent(expected: boolean) { - assert.equal(activeEditorChangeEventFired, expected, `Unexpected active editor change state (got ${activeEditorChangeEventFired}, expected ${expected})`); + assert.strictEqual(activeEditorChangeEventFired, expected, `Unexpected active editor change state (got ${activeEditorChangeEventFired}, expected ${expected})`); activeEditorChangeEventFired = false; } function assertVisibleEditorsChangedEvent(expected: boolean) { - assert.equal(visibleEditorChangeEventFired, expected, `Unexpected visible editors change state (got ${visibleEditorChangeEventFired}, expected ${expected})`); + assert.strictEqual(visibleEditorChangeEventFired, expected, `Unexpected visible editors change state (got ${visibleEditorChangeEventFired}, expected ${expected})`); visibleEditorChangeEventFired = false; } @@ -740,7 +740,7 @@ suite('EditorService', () => { }); function assertActiveEditorChangedEvent(expected: number) { - assert.equal(activeEditorChangeEvents, expected, `Unexpected active editor change state (got ${activeEditorChangeEvents}, expected ${expected})`); + assert.strictEqual(activeEditorChangeEvents, expected, `Unexpected active editor change state (got ${activeEditorChangeEvents}, expected ${expected})`); activeEditorChangeEvents = 0; } @@ -774,9 +774,9 @@ suite('EditorService', () => { // Open untitled input let editor = await service.openEditor({}); - assert.equal(service.activeEditorPane, editor); - assert.equal(service.activeTextEditorControl, editor?.getControl()); - assert.equal(service.activeTextEditorMode, 'plaintext'); + assert.strictEqual(service.activeEditorPane, editor); + assert.strictEqual(service.activeTextEditorControl, editor?.getControl()); + assert.strictEqual(service.activeTextEditorMode, 'plaintext'); part.dispose(); }); @@ -822,7 +822,7 @@ suite('EditorService', () => { await service.openEditor(sameInput1, { pinned: true }, SIDE_GROUP); await service.save({ groupId: rootGroup.id, editor: input1 }); - assert.equal(input1.gotSaved, true); + assert.strictEqual(input1.gotSaved, true); input1.gotSaved = false; input1.gotSavedAs = false; @@ -833,7 +833,7 @@ suite('EditorService', () => { sameInput1.dirty = true; await service.save({ groupId: rootGroup.id, editor: input1 }, { saveAs: true }); - assert.equal(input1.gotSavedAs, true); + assert.strictEqual(input1.gotSavedAs, true); input1.gotSaved = false; input1.gotSavedAs = false; @@ -844,8 +844,8 @@ suite('EditorService', () => { sameInput1.dirty = true; const revertRes = await service.revertAll(); - assert.equal(revertRes, true); - assert.equal(input1.gotReverted, true); + assert.strictEqual(revertRes, true); + assert.strictEqual(input1.gotReverted, true); input1.gotSaved = false; input1.gotSavedAs = false; @@ -856,9 +856,9 @@ suite('EditorService', () => { sameInput1.dirty = true; const saveRes = await service.saveAll(); - assert.equal(saveRes, true); - assert.equal(input1.gotSaved, true); - assert.equal(input2.gotSaved, true); + assert.strictEqual(saveRes, true); + assert.strictEqual(input1.gotSaved, true); + assert.strictEqual(input2.gotSaved, true); input1.gotSaved = false; input1.gotSavedAs = false; @@ -873,13 +873,13 @@ suite('EditorService', () => { await service.saveAll({ saveAs: true }); - assert.equal(input1.gotSavedAs, true); - assert.equal(input2.gotSavedAs, true); + assert.strictEqual(input1.gotSavedAs, true); + assert.strictEqual(input2.gotSavedAs, true); // services dedupes inputs automatically - assert.equal(sameInput1.gotSaved, false); - assert.equal(sameInput1.gotSavedAs, false); - assert.equal(sameInput1.gotReverted, false); + assert.strictEqual(sameInput1.gotSaved, false); + assert.strictEqual(sameInput1.gotSavedAs, false); + assert.strictEqual(sameInput1.gotReverted, false); part.dispose(); }); @@ -901,9 +901,9 @@ suite('EditorService', () => { await service.openEditor(sameInput1, { pinned: true }, SIDE_GROUP); const revertRes = await service.revertAll({ excludeSticky: true }); - assert.equal(revertRes, true); - assert.equal(input1.gotReverted, false); - assert.equal(sameInput1.gotReverted, true); + assert.strictEqual(revertRes, true); + assert.strictEqual(input1.gotReverted, false); + assert.strictEqual(sameInput1.gotReverted, true); input1.gotSaved = false; input1.gotSavedAs = false; @@ -918,10 +918,10 @@ suite('EditorService', () => { sameInput1.dirty = true; const saveRes = await service.saveAll({ excludeSticky: true }); - assert.equal(saveRes, true); - assert.equal(input1.gotSaved, false); - assert.equal(input2.gotSaved, true); - assert.equal(sameInput1.gotSaved, true); + assert.strictEqual(saveRes, true); + assert.strictEqual(input1.gotSaved, false); + assert.strictEqual(input2.gotSaved, true); + assert.strictEqual(sameInput1.gotSaved, true); part.dispose(); }); @@ -949,7 +949,7 @@ suite('EditorService', () => { await service.openEditor(input1, { pinned: true }); await service.openEditor(input2, { pinned: true }); - assert.equal(rootGroup.activeEditor, input2); + assert.strictEqual(rootGroup.activeEditor, input2); const activeEditorChangePromise = awaitActiveEditorChange(service); accessor.fileService.fireAfterOperation(new FileOperationEvent(input2.resource, FileOperation.DELETE)); @@ -958,9 +958,9 @@ suite('EditorService', () => { } if (dirty) { - assert.equal(rootGroup.activeEditor, input2); + assert.strictEqual(rootGroup.activeEditor, input2); } else { - assert.equal(rootGroup.activeEditor, input1); + assert.strictEqual(rootGroup.activeEditor, input1); } part.dispose(); @@ -993,7 +993,7 @@ suite('EditorService', () => { })); await activeEditorChangePromise; - assert.equal(rootGroup.activeEditor, movedInput); + assert.strictEqual(rootGroup.activeEditor, movedInput); part.dispose(); }); @@ -1011,15 +1011,15 @@ suite('EditorService', () => { await part.whenRestored; await service.openEditor(input1, { pinned: true }); - assert.equal(accessor.fileService.watches.length, 1); - assert.equal(accessor.fileService.watches[0].toString(), input1.resource.toString()); + assert.strictEqual(accessor.fileService.watches.length, 1); + assert.strictEqual(accessor.fileService.watches[0].toString(), input1.resource.toString()); const editor = await service.openEditor(input2, { pinned: true }); - assert.equal(accessor.fileService.watches.length, 1); - assert.equal(accessor.fileService.watches[0].toString(), input2.resource.toString()); + assert.strictEqual(accessor.fileService.watches.length, 1); + assert.strictEqual(accessor.fileService.watches[0].toString(), input2.resource.toString()); await editor?.group?.closeAllEditors(); - assert.equal(accessor.fileService.watches.length, 0); + assert.strictEqual(accessor.fileService.watches.length, 0); part.dispose(); }); @@ -1067,7 +1067,7 @@ suite('EditorService', () => { await service.openEditor(input1, { pinned: true }); assert.ok(overrideCalled); - assert.equal(service.activeEditor, input2); + assert.strictEqual(service.activeEditor, input2); handler.dispose(); part.dispose(); @@ -1103,24 +1103,24 @@ suite('EditorService', () => { // Open editors await service.openEditors([{ editor: input }, { editor: otherInput }]); - assert.equal(part.activeGroup.count, 2); + assert.strictEqual(part.activeGroup.count, 2); // Try using find editors for opened editors { const found = service.findEditors(input.resource, part.activeGroup); - assert.equal(found.length, 1); - assert.equal(found[0], input); + assert.strictEqual(found.length, 1); + assert.strictEqual(found[0], input); } { const found = service.findEditors(otherInput.resource, part.activeGroup); - assert.equal(found.length, 1); - assert.equal(found[0], otherInput); + assert.strictEqual(found.length, 1); + assert.strictEqual(found[0], otherInput); } // Make sure we don't find non-opened editors { const found = service.findEditors(URI.parse('my://no-such-resource'), part.activeGroup); - assert.equal(found.length, 0); + assert.strictEqual(found.length, 0); } // Make sure we don't find editors across groups @@ -1128,14 +1128,14 @@ suite('EditorService', () => { const newEditor = await service.openEditor(new TestFileEditorInput(URI.parse('my://other-group-resource'), TEST_EDITOR_INPUT_ID), { pinned: true, preserveFocus: true }, SIDE_GROUP); const found = service.findEditors(input.resource, newEditor!.group!.id); - assert.equal(found.length, 0); + assert.strictEqual(found.length, 0); } // Check we don't find editors after closing them await part.activeGroup.closeAllEditors(); { const found = service.findEditors(input.resource, part.activeGroup); - assert.equal(found.length, 0); + assert.strictEqual(found.length, 0); } part.dispose(); diff --git a/src/vs/workbench/services/editor/test/browser/editorsObserver.test.ts b/src/vs/workbench/services/editor/test/browser/editorsObserver.test.ts index 4bc82ab5096b05d710859889256fc4b3fb1695f4..a1353fad43617731a26aac20a1d1258062c98df3 100644 --- a/src/vs/workbench/services/editor/test/browser/editorsObserver.test.ts +++ b/src/vs/workbench/services/editor/test/browser/editorsObserver.test.ts @@ -65,19 +65,19 @@ suite('EditorsObserver', function () { }); let currentEditorsMRU = observer.editors; - assert.equal(currentEditorsMRU.length, 0); - assert.equal(onDidMostRecentlyActiveEditorsChangeCalled, false); + assert.strictEqual(currentEditorsMRU.length, 0); + assert.strictEqual(onDidMostRecentlyActiveEditorsChangeCalled, false); const input1 = new TestFileEditorInput(URI.parse('foo://bar1'), TEST_SERIALIZABLE_EDITOR_INPUT_ID); await part.activeGroup.openEditor(input1, EditorOptions.create({ pinned: true })); currentEditorsMRU = observer.editors; - assert.equal(currentEditorsMRU.length, 1); - assert.equal(currentEditorsMRU[0].groupId, part.activeGroup.id); - assert.equal(currentEditorsMRU[0].editor, input1); - assert.equal(onDidMostRecentlyActiveEditorsChangeCalled, true); - assert.equal(observer.hasEditor(input1.resource), true); + assert.strictEqual(currentEditorsMRU.length, 1); + assert.strictEqual(currentEditorsMRU[0].groupId, part.activeGroup.id); + assert.strictEqual(currentEditorsMRU[0].editor, input1); + assert.strictEqual(onDidMostRecentlyActiveEditorsChangeCalled, true); + assert.strictEqual(observer.hasEditor(input1.resource), true); const input2 = new TestFileEditorInput(URI.parse('foo://bar2'), TEST_SERIALIZABLE_EDITOR_INPUT_ID); const input3 = new TestFileEditorInput(URI.parse('foo://bar3'), TEST_SERIALIZABLE_EDITOR_INPUT_ID); @@ -86,50 +86,50 @@ suite('EditorsObserver', function () { await part.activeGroup.openEditor(input3, EditorOptions.create({ pinned: true })); currentEditorsMRU = observer.editors; - assert.equal(currentEditorsMRU.length, 3); - assert.equal(currentEditorsMRU[0].groupId, part.activeGroup.id); - assert.equal(currentEditorsMRU[0].editor, input3); - assert.equal(currentEditorsMRU[1].groupId, part.activeGroup.id); - assert.equal(currentEditorsMRU[1].editor, input2); - assert.equal(currentEditorsMRU[2].groupId, part.activeGroup.id); - assert.equal(currentEditorsMRU[2].editor, input1); - assert.equal(observer.hasEditor(input2.resource), true); - assert.equal(observer.hasEditor(input3.resource), true); + assert.strictEqual(currentEditorsMRU.length, 3); + assert.strictEqual(currentEditorsMRU[0].groupId, part.activeGroup.id); + assert.strictEqual(currentEditorsMRU[0].editor, input3); + assert.strictEqual(currentEditorsMRU[1].groupId, part.activeGroup.id); + assert.strictEqual(currentEditorsMRU[1].editor, input2); + assert.strictEqual(currentEditorsMRU[2].groupId, part.activeGroup.id); + assert.strictEqual(currentEditorsMRU[2].editor, input1); + assert.strictEqual(observer.hasEditor(input2.resource), true); + assert.strictEqual(observer.hasEditor(input3.resource), true); await part.activeGroup.openEditor(input2, EditorOptions.create({ pinned: true })); currentEditorsMRU = observer.editors; - assert.equal(currentEditorsMRU.length, 3); - assert.equal(currentEditorsMRU[0].groupId, part.activeGroup.id); - assert.equal(currentEditorsMRU[0].editor, input2); - assert.equal(currentEditorsMRU[1].groupId, part.activeGroup.id); - assert.equal(currentEditorsMRU[1].editor, input3); - assert.equal(currentEditorsMRU[2].groupId, part.activeGroup.id); - assert.equal(currentEditorsMRU[2].editor, input1); - assert.equal(observer.hasEditor(input1.resource), true); - assert.equal(observer.hasEditor(input2.resource), true); - assert.equal(observer.hasEditor(input3.resource), true); + assert.strictEqual(currentEditorsMRU.length, 3); + assert.strictEqual(currentEditorsMRU[0].groupId, part.activeGroup.id); + assert.strictEqual(currentEditorsMRU[0].editor, input2); + assert.strictEqual(currentEditorsMRU[1].groupId, part.activeGroup.id); + assert.strictEqual(currentEditorsMRU[1].editor, input3); + assert.strictEqual(currentEditorsMRU[2].groupId, part.activeGroup.id); + assert.strictEqual(currentEditorsMRU[2].editor, input1); + assert.strictEqual(observer.hasEditor(input1.resource), true); + assert.strictEqual(observer.hasEditor(input2.resource), true); + assert.strictEqual(observer.hasEditor(input3.resource), true); onDidMostRecentlyActiveEditorsChangeCalled = false; await part.activeGroup.closeEditor(input1); currentEditorsMRU = observer.editors; - assert.equal(currentEditorsMRU.length, 2); - assert.equal(currentEditorsMRU[0].groupId, part.activeGroup.id); - assert.equal(currentEditorsMRU[0].editor, input2); - assert.equal(currentEditorsMRU[1].groupId, part.activeGroup.id); - assert.equal(currentEditorsMRU[1].editor, input3); - assert.equal(onDidMostRecentlyActiveEditorsChangeCalled, true); - assert.equal(observer.hasEditor(input1.resource), false); - assert.equal(observer.hasEditor(input2.resource), true); - assert.equal(observer.hasEditor(input3.resource), true); + assert.strictEqual(currentEditorsMRU.length, 2); + assert.strictEqual(currentEditorsMRU[0].groupId, part.activeGroup.id); + assert.strictEqual(currentEditorsMRU[0].editor, input2); + assert.strictEqual(currentEditorsMRU[1].groupId, part.activeGroup.id); + assert.strictEqual(currentEditorsMRU[1].editor, input3); + assert.strictEqual(onDidMostRecentlyActiveEditorsChangeCalled, true); + assert.strictEqual(observer.hasEditor(input1.resource), false); + assert.strictEqual(observer.hasEditor(input2.resource), true); + assert.strictEqual(observer.hasEditor(input3.resource), true); await part.activeGroup.closeAllEditors(); currentEditorsMRU = observer.editors; - assert.equal(currentEditorsMRU.length, 0); - assert.equal(observer.hasEditor(input1.resource), false); - assert.equal(observer.hasEditor(input2.resource), false); - assert.equal(observer.hasEditor(input3.resource), false); + assert.strictEqual(currentEditorsMRU.length, 0); + assert.strictEqual(observer.hasEditor(input1.resource), false); + assert.strictEqual(observer.hasEditor(input2.resource), false); + assert.strictEqual(observer.hasEditor(input3.resource), false); part.dispose(); listener.dispose(); @@ -141,7 +141,7 @@ suite('EditorsObserver', function () { const rootGroup = part.activeGroup; let currentEditorsMRU = observer.editors; - assert.equal(currentEditorsMRU.length, 0); + assert.strictEqual(currentEditorsMRU.length, 0); const sideGroup = part.addGroup(rootGroup, GroupDirection.RIGHT); @@ -151,22 +151,22 @@ suite('EditorsObserver', function () { await sideGroup.openEditor(input1, EditorOptions.create({ pinned: true, activation: EditorActivation.ACTIVATE })); currentEditorsMRU = observer.editors; - assert.equal(currentEditorsMRU.length, 2); - assert.equal(currentEditorsMRU[0].groupId, sideGroup.id); - assert.equal(currentEditorsMRU[0].editor, input1); - assert.equal(currentEditorsMRU[1].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[1].editor, input1); - assert.equal(observer.hasEditor(input1.resource), true); + assert.strictEqual(currentEditorsMRU.length, 2); + assert.strictEqual(currentEditorsMRU[0].groupId, sideGroup.id); + assert.strictEqual(currentEditorsMRU[0].editor, input1); + assert.strictEqual(currentEditorsMRU[1].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[1].editor, input1); + assert.strictEqual(observer.hasEditor(input1.resource), true); await rootGroup.openEditor(input1, EditorOptions.create({ pinned: true, activation: EditorActivation.ACTIVATE })); currentEditorsMRU = observer.editors; - assert.equal(currentEditorsMRU.length, 2); - assert.equal(currentEditorsMRU[0].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[0].editor, input1); - assert.equal(currentEditorsMRU[1].groupId, sideGroup.id); - assert.equal(currentEditorsMRU[1].editor, input1); - assert.equal(observer.hasEditor(input1.resource), true); + assert.strictEqual(currentEditorsMRU.length, 2); + assert.strictEqual(currentEditorsMRU[0].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[0].editor, input1); + assert.strictEqual(currentEditorsMRU[1].groupId, sideGroup.id); + assert.strictEqual(currentEditorsMRU[1].editor, input1); + assert.strictEqual(observer.hasEditor(input1.resource), true); // Opening an editor inactive should not change // the most recent editor, but rather put it behind @@ -175,31 +175,31 @@ suite('EditorsObserver', function () { await rootGroup.openEditor(input2, EditorOptions.create({ inactive: true })); currentEditorsMRU = observer.editors; - assert.equal(currentEditorsMRU.length, 3); - assert.equal(currentEditorsMRU[0].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[0].editor, input1); - assert.equal(currentEditorsMRU[1].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[1].editor, input2); - assert.equal(currentEditorsMRU[2].groupId, sideGroup.id); - assert.equal(currentEditorsMRU[2].editor, input1); - assert.equal(observer.hasEditor(input1.resource), true); - assert.equal(observer.hasEditor(input2.resource), true); + assert.strictEqual(currentEditorsMRU.length, 3); + assert.strictEqual(currentEditorsMRU[0].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[0].editor, input1); + assert.strictEqual(currentEditorsMRU[1].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[1].editor, input2); + assert.strictEqual(currentEditorsMRU[2].groupId, sideGroup.id); + assert.strictEqual(currentEditorsMRU[2].editor, input1); + assert.strictEqual(observer.hasEditor(input1.resource), true); + assert.strictEqual(observer.hasEditor(input2.resource), true); await rootGroup.closeAllEditors(); currentEditorsMRU = observer.editors; - assert.equal(currentEditorsMRU.length, 1); - assert.equal(currentEditorsMRU[0].groupId, sideGroup.id); - assert.equal(currentEditorsMRU[0].editor, input1); - assert.equal(observer.hasEditor(input1.resource), true); - assert.equal(observer.hasEditor(input2.resource), false); + assert.strictEqual(currentEditorsMRU.length, 1); + assert.strictEqual(currentEditorsMRU[0].groupId, sideGroup.id); + assert.strictEqual(currentEditorsMRU[0].editor, input1); + assert.strictEqual(observer.hasEditor(input1.resource), true); + assert.strictEqual(observer.hasEditor(input2.resource), false); await sideGroup.closeAllEditors(); currentEditorsMRU = observer.editors; - assert.equal(currentEditorsMRU.length, 0); - assert.equal(observer.hasEditor(input1.resource), false); - assert.equal(observer.hasEditor(input2.resource), false); + assert.strictEqual(currentEditorsMRU.length, 0); + assert.strictEqual(observer.hasEditor(input1.resource), false); + assert.strictEqual(observer.hasEditor(input2.resource), false); part.dispose(); }); @@ -218,16 +218,16 @@ suite('EditorsObserver', function () { await rootGroup.openEditor(input3, EditorOptions.create({ pinned: true })); let currentEditorsMRU = observer.editors; - assert.equal(currentEditorsMRU.length, 3); - assert.equal(currentEditorsMRU[0].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[0].editor, input3); - assert.equal(currentEditorsMRU[1].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[1].editor, input2); - assert.equal(currentEditorsMRU[2].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[2].editor, input1); - assert.equal(observer.hasEditor(input1.resource), true); - assert.equal(observer.hasEditor(input2.resource), true); - assert.equal(observer.hasEditor(input3.resource), true); + assert.strictEqual(currentEditorsMRU.length, 3); + assert.strictEqual(currentEditorsMRU[0].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[0].editor, input3); + assert.strictEqual(currentEditorsMRU[1].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[1].editor, input2); + assert.strictEqual(currentEditorsMRU[2].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[2].editor, input1); + assert.strictEqual(observer.hasEditor(input1.resource), true); + assert.strictEqual(observer.hasEditor(input2.resource), true); + assert.strictEqual(observer.hasEditor(input3.resource), true); const copiedGroup = part.copyGroup(rootGroup, rootGroup, GroupDirection.RIGHT); await copiedGroup.whenRestored; @@ -235,34 +235,34 @@ suite('EditorsObserver', function () { copiedGroup.focus(); currentEditorsMRU = observer.editors; - assert.equal(currentEditorsMRU.length, 6); - assert.equal(currentEditorsMRU[0].groupId, copiedGroup.id); - assert.equal(currentEditorsMRU[0].editor, input3); - assert.equal(currentEditorsMRU[1].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[1].editor, input3); - assert.equal(currentEditorsMRU[2].groupId, copiedGroup.id); - assert.equal(currentEditorsMRU[2].editor, input2); - assert.equal(currentEditorsMRU[3].groupId, copiedGroup.id); - assert.equal(currentEditorsMRU[3].editor, input1); - assert.equal(currentEditorsMRU[4].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[4].editor, input2); - assert.equal(currentEditorsMRU[5].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[5].editor, input1); - assert.equal(observer.hasEditor(input1.resource), true); - assert.equal(observer.hasEditor(input2.resource), true); - assert.equal(observer.hasEditor(input3.resource), true); + assert.strictEqual(currentEditorsMRU.length, 6); + assert.strictEqual(currentEditorsMRU[0].groupId, copiedGroup.id); + assert.strictEqual(currentEditorsMRU[0].editor, input3); + assert.strictEqual(currentEditorsMRU[1].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[1].editor, input3); + assert.strictEqual(currentEditorsMRU[2].groupId, copiedGroup.id); + assert.strictEqual(currentEditorsMRU[2].editor, input2); + assert.strictEqual(currentEditorsMRU[3].groupId, copiedGroup.id); + assert.strictEqual(currentEditorsMRU[3].editor, input1); + assert.strictEqual(currentEditorsMRU[4].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[4].editor, input2); + assert.strictEqual(currentEditorsMRU[5].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[5].editor, input1); + assert.strictEqual(observer.hasEditor(input1.resource), true); + assert.strictEqual(observer.hasEditor(input2.resource), true); + assert.strictEqual(observer.hasEditor(input3.resource), true); await rootGroup.closeAllEditors(); - assert.equal(observer.hasEditor(input1.resource), true); - assert.equal(observer.hasEditor(input2.resource), true); - assert.equal(observer.hasEditor(input3.resource), true); + assert.strictEqual(observer.hasEditor(input1.resource), true); + assert.strictEqual(observer.hasEditor(input2.resource), true); + assert.strictEqual(observer.hasEditor(input3.resource), true); await copiedGroup.closeAllEditors(); - assert.equal(observer.hasEditor(input1.resource), false); - assert.equal(observer.hasEditor(input2.resource), false); - assert.equal(observer.hasEditor(input3.resource), false); + assert.strictEqual(observer.hasEditor(input1.resource), false); + assert.strictEqual(observer.hasEditor(input2.resource), false); + assert.strictEqual(observer.hasEditor(input3.resource), false); part.dispose(); }); @@ -285,16 +285,16 @@ suite('EditorsObserver', function () { await part.whenRestored; let currentEditorsMRU = observer.editors; - assert.equal(currentEditorsMRU.length, 3); - assert.equal(currentEditorsMRU[0].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[0].editor, input3); - assert.equal(currentEditorsMRU[1].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[1].editor, input2); - assert.equal(currentEditorsMRU[2].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[2].editor, input1); - assert.equal(observer.hasEditor(input1.resource), true); - assert.equal(observer.hasEditor(input2.resource), true); - assert.equal(observer.hasEditor(input3.resource), true); + assert.strictEqual(currentEditorsMRU.length, 3); + assert.strictEqual(currentEditorsMRU[0].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[0].editor, input3); + assert.strictEqual(currentEditorsMRU[1].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[1].editor, input2); + assert.strictEqual(currentEditorsMRU[2].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[2].editor, input1); + assert.strictEqual(observer.hasEditor(input1.resource), true); + assert.strictEqual(observer.hasEditor(input2.resource), true); + assert.strictEqual(observer.hasEditor(input3.resource), true); storage.emitWillSaveState(WillSaveStateReason.SHUTDOWN); @@ -302,16 +302,16 @@ suite('EditorsObserver', function () { await part.whenRestored; currentEditorsMRU = restoredObserver.editors; - assert.equal(currentEditorsMRU.length, 3); - assert.equal(currentEditorsMRU[0].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[0].editor, input3); - assert.equal(currentEditorsMRU[1].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[1].editor, input2); - assert.equal(currentEditorsMRU[2].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[2].editor, input1); - assert.equal(observer.hasEditor(input1.resource), true); - assert.equal(observer.hasEditor(input2.resource), true); - assert.equal(observer.hasEditor(input3.resource), true); + assert.strictEqual(currentEditorsMRU.length, 3); + assert.strictEqual(currentEditorsMRU[0].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[0].editor, input3); + assert.strictEqual(currentEditorsMRU[1].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[1].editor, input2); + assert.strictEqual(currentEditorsMRU[2].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[2].editor, input1); + assert.strictEqual(observer.hasEditor(input1.resource), true); + assert.strictEqual(observer.hasEditor(input2.resource), true); + assert.strictEqual(observer.hasEditor(input3.resource), true); part.clearState(); part.dispose(); @@ -337,16 +337,16 @@ suite('EditorsObserver', function () { await part.whenRestored; let currentEditorsMRU = observer.editors; - assert.equal(currentEditorsMRU.length, 3); - assert.equal(currentEditorsMRU[0].groupId, sideGroup.id); - assert.equal(currentEditorsMRU[0].editor, input3); - assert.equal(currentEditorsMRU[1].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[1].editor, input2); - assert.equal(currentEditorsMRU[2].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[2].editor, input1); - assert.equal(observer.hasEditor(input1.resource), true); - assert.equal(observer.hasEditor(input2.resource), true); - assert.equal(observer.hasEditor(input3.resource), true); + assert.strictEqual(currentEditorsMRU.length, 3); + assert.strictEqual(currentEditorsMRU[0].groupId, sideGroup.id); + assert.strictEqual(currentEditorsMRU[0].editor, input3); + assert.strictEqual(currentEditorsMRU[1].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[1].editor, input2); + assert.strictEqual(currentEditorsMRU[2].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[2].editor, input1); + assert.strictEqual(observer.hasEditor(input1.resource), true); + assert.strictEqual(observer.hasEditor(input2.resource), true); + assert.strictEqual(observer.hasEditor(input3.resource), true); storage.emitWillSaveState(WillSaveStateReason.SHUTDOWN); @@ -354,16 +354,16 @@ suite('EditorsObserver', function () { await part.whenRestored; currentEditorsMRU = restoredObserver.editors; - assert.equal(currentEditorsMRU.length, 3); - assert.equal(currentEditorsMRU[0].groupId, sideGroup.id); - assert.equal(currentEditorsMRU[0].editor, input3); - assert.equal(currentEditorsMRU[1].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[1].editor, input2); - assert.equal(currentEditorsMRU[2].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[2].editor, input1); - assert.equal(restoredObserver.hasEditor(input1.resource), true); - assert.equal(restoredObserver.hasEditor(input2.resource), true); - assert.equal(restoredObserver.hasEditor(input3.resource), true); + assert.strictEqual(currentEditorsMRU.length, 3); + assert.strictEqual(currentEditorsMRU[0].groupId, sideGroup.id); + assert.strictEqual(currentEditorsMRU[0].editor, input3); + assert.strictEqual(currentEditorsMRU[1].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[1].editor, input2); + assert.strictEqual(currentEditorsMRU[2].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[2].editor, input1); + assert.strictEqual(restoredObserver.hasEditor(input1.resource), true); + assert.strictEqual(restoredObserver.hasEditor(input2.resource), true); + assert.strictEqual(restoredObserver.hasEditor(input3.resource), true); part.clearState(); part.dispose(); @@ -383,10 +383,10 @@ suite('EditorsObserver', function () { await part.whenRestored; let currentEditorsMRU = observer.editors; - assert.equal(currentEditorsMRU.length, 1); - assert.equal(currentEditorsMRU[0].groupId, rootGroup.id); - assert.equal(currentEditorsMRU[0].editor, input1); - assert.equal(observer.hasEditor(input1.resource), true); + assert.strictEqual(currentEditorsMRU.length, 1); + assert.strictEqual(currentEditorsMRU[0].groupId, rootGroup.id); + assert.strictEqual(currentEditorsMRU[0].editor, input1); + assert.strictEqual(observer.hasEditor(input1.resource), true); storage.emitWillSaveState(WillSaveStateReason.SHUTDOWN); @@ -394,8 +394,8 @@ suite('EditorsObserver', function () { await part.whenRestored; currentEditorsMRU = restoredObserver.editors; - assert.equal(currentEditorsMRU.length, 0); - assert.equal(restoredObserver.hasEditor(input1.resource), false); + assert.strictEqual(currentEditorsMRU.length, 0); + assert.strictEqual(restoredObserver.hasEditor(input1.resource), false); part.clearState(); part.dispose(); @@ -421,45 +421,45 @@ suite('EditorsObserver', function () { await rootGroup.openEditor(input3, EditorOptions.create({ pinned: true })); await rootGroup.openEditor(input4, EditorOptions.create({ pinned: true })); - assert.equal(rootGroup.count, 3); - assert.equal(rootGroup.isOpened(input1), false); - assert.equal(rootGroup.isOpened(input2), true); - assert.equal(rootGroup.isOpened(input3), true); - assert.equal(rootGroup.isOpened(input4), true); - assert.equal(observer.hasEditor(input1.resource), false); - assert.equal(observer.hasEditor(input2.resource), true); - assert.equal(observer.hasEditor(input3.resource), true); - assert.equal(observer.hasEditor(input4.resource), true); + assert.strictEqual(rootGroup.count, 3); + assert.strictEqual(rootGroup.isOpened(input1), false); + assert.strictEqual(rootGroup.isOpened(input2), true); + assert.strictEqual(rootGroup.isOpened(input3), true); + assert.strictEqual(rootGroup.isOpened(input4), true); + assert.strictEqual(observer.hasEditor(input1.resource), false); + assert.strictEqual(observer.hasEditor(input2.resource), true); + assert.strictEqual(observer.hasEditor(input3.resource), true); + assert.strictEqual(observer.hasEditor(input4.resource), true); input2.setDirty(); part.enforcePartOptions({ limit: { enabled: true, value: 1 } }); await timeout(0); - assert.equal(rootGroup.count, 2); - assert.equal(rootGroup.isOpened(input1), false); - assert.equal(rootGroup.isOpened(input2), true); // dirty - assert.equal(rootGroup.isOpened(input3), false); - assert.equal(rootGroup.isOpened(input4), true); - assert.equal(observer.hasEditor(input1.resource), false); - assert.equal(observer.hasEditor(input2.resource), true); - assert.equal(observer.hasEditor(input3.resource), false); - assert.equal(observer.hasEditor(input4.resource), true); + assert.strictEqual(rootGroup.count, 2); + assert.strictEqual(rootGroup.isOpened(input1), false); + assert.strictEqual(rootGroup.isOpened(input2), true); // dirty + assert.strictEqual(rootGroup.isOpened(input3), false); + assert.strictEqual(rootGroup.isOpened(input4), true); + assert.strictEqual(observer.hasEditor(input1.resource), false); + assert.strictEqual(observer.hasEditor(input2.resource), true); + assert.strictEqual(observer.hasEditor(input3.resource), false); + assert.strictEqual(observer.hasEditor(input4.resource), true); const input5 = new TestFileEditorInput(URI.parse('foo://bar5'), TEST_EDITOR_INPUT_ID); await sideGroup.openEditor(input5, EditorOptions.create({ pinned: true })); - assert.equal(rootGroup.count, 1); - assert.equal(rootGroup.isOpened(input1), false); - assert.equal(rootGroup.isOpened(input2), true); // dirty - assert.equal(rootGroup.isOpened(input3), false); - assert.equal(rootGroup.isOpened(input4), false); - assert.equal(sideGroup.isOpened(input5), true); - assert.equal(observer.hasEditor(input1.resource), false); - assert.equal(observer.hasEditor(input2.resource), true); - assert.equal(observer.hasEditor(input3.resource), false); - assert.equal(observer.hasEditor(input4.resource), false); - assert.equal(observer.hasEditor(input5.resource), true); + assert.strictEqual(rootGroup.count, 1); + assert.strictEqual(rootGroup.isOpened(input1), false); + assert.strictEqual(rootGroup.isOpened(input2), true); // dirty + assert.strictEqual(rootGroup.isOpened(input3), false); + assert.strictEqual(rootGroup.isOpened(input4), false); + assert.strictEqual(sideGroup.isOpened(input5), true); + assert.strictEqual(observer.hasEditor(input1.resource), false); + assert.strictEqual(observer.hasEditor(input2.resource), true); + assert.strictEqual(observer.hasEditor(input3.resource), false); + assert.strictEqual(observer.hasEditor(input4.resource), false); + assert.strictEqual(observer.hasEditor(input5.resource), true); observer.dispose(); part.dispose(); @@ -485,51 +485,51 @@ suite('EditorsObserver', function () { await rootGroup.openEditor(input3, EditorOptions.create({ pinned: true })); await rootGroup.openEditor(input4, EditorOptions.create({ pinned: true })); - assert.equal(rootGroup.count, 3); // 1 editor got closed due to our limit! - assert.equal(rootGroup.isOpened(input1), false); - assert.equal(rootGroup.isOpened(input2), true); - assert.equal(rootGroup.isOpened(input3), true); - assert.equal(rootGroup.isOpened(input4), true); - assert.equal(observer.hasEditor(input1.resource), false); - assert.equal(observer.hasEditor(input2.resource), true); - assert.equal(observer.hasEditor(input3.resource), true); - assert.equal(observer.hasEditor(input4.resource), true); + assert.strictEqual(rootGroup.count, 3); // 1 editor got closed due to our limit! + assert.strictEqual(rootGroup.isOpened(input1), false); + assert.strictEqual(rootGroup.isOpened(input2), true); + assert.strictEqual(rootGroup.isOpened(input3), true); + assert.strictEqual(rootGroup.isOpened(input4), true); + assert.strictEqual(observer.hasEditor(input1.resource), false); + assert.strictEqual(observer.hasEditor(input2.resource), true); + assert.strictEqual(observer.hasEditor(input3.resource), true); + assert.strictEqual(observer.hasEditor(input4.resource), true); await sideGroup.openEditor(input1, EditorOptions.create({ pinned: true })); await sideGroup.openEditor(input2, EditorOptions.create({ pinned: true })); await sideGroup.openEditor(input3, EditorOptions.create({ pinned: true })); await sideGroup.openEditor(input4, EditorOptions.create({ pinned: true })); - assert.equal(sideGroup.count, 3); - assert.equal(sideGroup.isOpened(input1), false); - assert.equal(sideGroup.isOpened(input2), true); - assert.equal(sideGroup.isOpened(input3), true); - assert.equal(sideGroup.isOpened(input4), true); - assert.equal(observer.hasEditor(input1.resource), false); - assert.equal(observer.hasEditor(input2.resource), true); - assert.equal(observer.hasEditor(input3.resource), true); - assert.equal(observer.hasEditor(input4.resource), true); + assert.strictEqual(sideGroup.count, 3); + assert.strictEqual(sideGroup.isOpened(input1), false); + assert.strictEqual(sideGroup.isOpened(input2), true); + assert.strictEqual(sideGroup.isOpened(input3), true); + assert.strictEqual(sideGroup.isOpened(input4), true); + assert.strictEqual(observer.hasEditor(input1.resource), false); + assert.strictEqual(observer.hasEditor(input2.resource), true); + assert.strictEqual(observer.hasEditor(input3.resource), true); + assert.strictEqual(observer.hasEditor(input4.resource), true); part.enforcePartOptions({ limit: { enabled: true, value: 1, perEditorGroup: true } }); await timeout(10); - assert.equal(rootGroup.count, 1); - assert.equal(rootGroup.isOpened(input1), false); - assert.equal(rootGroup.isOpened(input2), false); - assert.equal(rootGroup.isOpened(input3), false); - assert.equal(rootGroup.isOpened(input4), true); + assert.strictEqual(rootGroup.count, 1); + assert.strictEqual(rootGroup.isOpened(input1), false); + assert.strictEqual(rootGroup.isOpened(input2), false); + assert.strictEqual(rootGroup.isOpened(input3), false); + assert.strictEqual(rootGroup.isOpened(input4), true); - assert.equal(sideGroup.count, 1); - assert.equal(sideGroup.isOpened(input1), false); - assert.equal(sideGroup.isOpened(input2), false); - assert.equal(sideGroup.isOpened(input3), false); - assert.equal(sideGroup.isOpened(input4), true); + assert.strictEqual(sideGroup.count, 1); + assert.strictEqual(sideGroup.isOpened(input1), false); + assert.strictEqual(sideGroup.isOpened(input2), false); + assert.strictEqual(sideGroup.isOpened(input3), false); + assert.strictEqual(sideGroup.isOpened(input4), true); - assert.equal(observer.hasEditor(input1.resource), false); - assert.equal(observer.hasEditor(input2.resource), false); - assert.equal(observer.hasEditor(input3.resource), false); - assert.equal(observer.hasEditor(input4.resource), true); + assert.strictEqual(observer.hasEditor(input1.resource), false); + assert.strictEqual(observer.hasEditor(input2.resource), false); + assert.strictEqual(observer.hasEditor(input3.resource), false); + assert.strictEqual(observer.hasEditor(input4.resource), true); observer.dispose(); part.dispose(); @@ -554,15 +554,15 @@ suite('EditorsObserver', function () { await rootGroup.openEditor(input3, EditorOptions.create({ pinned: true })); await rootGroup.openEditor(input4, EditorOptions.create({ pinned: true })); - assert.equal(rootGroup.count, 3); - assert.equal(rootGroup.isOpened(input1), true); - assert.equal(rootGroup.isOpened(input2), false); - assert.equal(rootGroup.isOpened(input3), true); - assert.equal(rootGroup.isOpened(input4), true); - assert.equal(observer.hasEditor(input1.resource), true); - assert.equal(observer.hasEditor(input2.resource), false); - assert.equal(observer.hasEditor(input3.resource), true); - assert.equal(observer.hasEditor(input4.resource), true); + assert.strictEqual(rootGroup.count, 3); + assert.strictEqual(rootGroup.isOpened(input1), true); + assert.strictEqual(rootGroup.isOpened(input2), false); + assert.strictEqual(rootGroup.isOpened(input3), true); + assert.strictEqual(rootGroup.isOpened(input4), true); + assert.strictEqual(observer.hasEditor(input1.resource), true); + assert.strictEqual(observer.hasEditor(input2.resource), false); + assert.strictEqual(observer.hasEditor(input3.resource), true); + assert.strictEqual(observer.hasEditor(input4.resource), true); observer.dispose(); part.dispose(); diff --git a/src/vs/workbench/services/textfile/test/browser/textFileEditorModel.test.ts b/src/vs/workbench/services/textfile/test/browser/textFileEditorModel.test.ts index 801a1f0626214e77aae6cbbbfc1030151d96943d..a4e49939352f10e1a76e5be1ab389453ba88bd23 100644 --- a/src/vs/workbench/services/textfile/test/browser/textFileEditorModel.test.ts +++ b/src/vs/workbench/services/textfile/test/browser/textFileEditorModel.test.ts @@ -48,7 +48,7 @@ suite('Files - TextFileEditorModel', () => { await model.load(); - assert.equal(onDidLoadCounter, 1); + assert.strictEqual(onDidLoadCounter, 1); let onDidChangeContentCounter = 0; model.onDidChangeContent(() => onDidChangeContentCounter++); @@ -58,17 +58,17 @@ suite('Files - TextFileEditorModel', () => { model.updateTextEditorModel(createTextBufferFactory('bar')); - assert.equal(onDidChangeContentCounter, 1); - assert.equal(onDidChangeDirtyCounter, 1); + assert.strictEqual(onDidChangeContentCounter, 1); + assert.strictEqual(onDidChangeDirtyCounter, 1); model.updateTextEditorModel(createTextBufferFactory('foo')); - assert.equal(onDidChangeContentCounter, 2); - assert.equal(onDidChangeDirtyCounter, 1); + assert.strictEqual(onDidChangeContentCounter, 2); + assert.strictEqual(onDidChangeDirtyCounter, 1); await model.revert(); - assert.equal(onDidChangeDirtyCounter, 2); + assert.strictEqual(onDidChangeDirtyCounter, 2); model.dispose(); }); @@ -76,7 +76,7 @@ suite('Files - TextFileEditorModel', () => { test('isTextFileEditorModel', async function () { const model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/index_async.txt'), 'utf8', undefined); - assert.equal(isTextFileEditorModel(model), true); + assert.strictEqual(isTextFileEditorModel(model), true); model.dispose(); }); @@ -86,7 +86,7 @@ suite('Files - TextFileEditorModel', () => { await model.load(); - assert.equal(accessor.workingCopyService.dirtyCount, 0); + assert.strictEqual(accessor.workingCopyService.dirtyCount, 0); let savedEvent = false; model.onDidSave(() => savedEvent = true); @@ -98,8 +98,8 @@ suite('Files - TextFileEditorModel', () => { assert.ok(getLastModifiedTime(model) <= Date.now()); assert.ok(model.hasState(TextFileEditorModelState.DIRTY)); - assert.equal(accessor.workingCopyService.dirtyCount, 1); - assert.equal(accessor.workingCopyService.isDirty(model.resource), true); + assert.strictEqual(accessor.workingCopyService.dirtyCount, 1); + assert.strictEqual(accessor.workingCopyService.isDirty(model.resource), true); let workingCopyEvent = false; accessor.workingCopyService.onDidChangeDirty(e => { @@ -118,8 +118,8 @@ suite('Files - TextFileEditorModel', () => { assert.ok(savedEvent); assert.ok(workingCopyEvent); - assert.equal(accessor.workingCopyService.dirtyCount, 0); - assert.equal(accessor.workingCopyService.isDirty(model.resource), false); + assert.strictEqual(accessor.workingCopyService.dirtyCount, 0); + assert.strictEqual(accessor.workingCopyService.isDirty(model.resource), false); savedEvent = false; @@ -173,8 +173,8 @@ suite('Files - TextFileEditorModel', () => { assert.ok(model.isDirty()); assert.ok(saveErrorEvent); - assert.equal(accessor.workingCopyService.dirtyCount, 1); - assert.equal(accessor.workingCopyService.isDirty(model.resource), true); + assert.strictEqual(accessor.workingCopyService.dirtyCount, 1); + assert.strictEqual(accessor.workingCopyService.isDirty(model.resource), true); } finally { accessor.fileService.writeShouldThrowError = undefined; } @@ -209,8 +209,8 @@ suite('Files - TextFileEditorModel', () => { assert.ok(model.isDirty()); assert.ok(saveErrorEvent); - assert.equal(accessor.workingCopyService.dirtyCount, 1); - assert.equal(accessor.workingCopyService.isDirty(model.resource), true); + assert.strictEqual(accessor.workingCopyService.dirtyCount, 1); + assert.strictEqual(accessor.workingCopyService.isDirty(model.resource), true); model.dispose(); } finally { @@ -239,8 +239,8 @@ suite('Files - TextFileEditorModel', () => { assert.ok(model.isDirty()); assert.ok(saveErrorEvent); - assert.equal(accessor.workingCopyService.dirtyCount, 1); - assert.equal(accessor.workingCopyService.isDirty(model.resource), true); + assert.strictEqual(accessor.workingCopyService.dirtyCount, 1); + assert.strictEqual(accessor.workingCopyService.isDirty(model.resource), true); model.dispose(); } finally { @@ -255,7 +255,7 @@ suite('Files - TextFileEditorModel', () => { model.onDidChangeEncoding(() => encodingEvent = true); model.setEncoding('utf8', EncodingMode.Encode); // no-op - assert.equal(getLastModifiedTime(model), -1); + assert.strictEqual(getLastModifiedTime(model), -1); assert.ok(!encodingEvent); @@ -288,7 +288,7 @@ suite('Files - TextFileEditorModel', () => { await model.load(); - assert.equal(model.textEditorModel!.getModeId(), mode); + assert.strictEqual(model.textEditorModel!.getModeId(), mode); model.dispose(); assert.ok(!accessor.modelService.getModel(model.resource)); @@ -334,13 +334,13 @@ suite('Files - TextFileEditorModel', () => { await model.load({ contents: createTextBufferFactory('Hello World') }); - assert.equal(model.textEditorModel?.getValue(), 'Hello World'); - assert.equal(model.isDirty(), true); + assert.strictEqual(model.textEditorModel?.getValue(), 'Hello World'); + assert.strictEqual(model.isDirty(), true); await model.load({ contents: createTextBufferFactory('Hello Changes') }); - assert.equal(model.textEditorModel?.getValue(), 'Hello Changes'); - assert.equal(model.isDirty(), true); + assert.strictEqual(model.textEditorModel?.getValue(), 'Hello Changes'); + assert.strictEqual(model.isDirty(), true); // verify that we do not mark the model as saved when undoing once because // we never really had a saved state @@ -369,17 +369,17 @@ suite('Files - TextFileEditorModel', () => { model.updateTextEditorModel(createTextBufferFactory('foo')); assert.ok(model.isDirty()); - assert.equal(accessor.workingCopyService.dirtyCount, 1); - assert.equal(accessor.workingCopyService.isDirty(model.resource), true); + assert.strictEqual(accessor.workingCopyService.dirtyCount, 1); + assert.strictEqual(accessor.workingCopyService.isDirty(model.resource), true); await model.revert(); assert.strictEqual(model.isDirty(), false); - assert.equal(model.textEditorModel!.getValue(), 'Hello Html'); - assert.equal(eventCounter, 1); + assert.strictEqual(model.textEditorModel!.getValue(), 'Hello Html'); + assert.strictEqual(eventCounter, 1); assert.ok(workingCopyEvent); - assert.equal(accessor.workingCopyService.dirtyCount, 0); - assert.equal(accessor.workingCopyService.isDirty(model.resource), false); + assert.strictEqual(accessor.workingCopyService.dirtyCount, 0); + assert.strictEqual(accessor.workingCopyService.isDirty(model.resource), false); model.dispose(); }); @@ -402,17 +402,17 @@ suite('Files - TextFileEditorModel', () => { model.updateTextEditorModel(createTextBufferFactory('foo')); assert.ok(model.isDirty()); - assert.equal(accessor.workingCopyService.dirtyCount, 1); - assert.equal(accessor.workingCopyService.isDirty(model.resource), true); + assert.strictEqual(accessor.workingCopyService.dirtyCount, 1); + assert.strictEqual(accessor.workingCopyService.isDirty(model.resource), true); await model.revert({ soft: true }); assert.strictEqual(model.isDirty(), false); - assert.equal(model.textEditorModel!.getValue(), 'foo'); - assert.equal(eventCounter, 1); + assert.strictEqual(model.textEditorModel!.getValue(), 'foo'); + assert.strictEqual(eventCounter, 1); assert.ok(workingCopyEvent); - assert.equal(accessor.workingCopyService.dirtyCount, 0); - assert.equal(accessor.workingCopyService.isDirty(model.resource), false); + assert.strictEqual(accessor.workingCopyService.dirtyCount, 0); + assert.strictEqual(accessor.workingCopyService.isDirty(model.resource), false); model.dispose(); }); @@ -436,8 +436,8 @@ suite('Files - TextFileEditorModel', () => { await model.textEditorModel!.undo(); assert.ok(model.isDirty()); - assert.equal(accessor.workingCopyService.dirtyCount, 1); - assert.equal(accessor.workingCopyService.isDirty(model.resource), true); + assert.strictEqual(accessor.workingCopyService.dirtyCount, 1); + assert.strictEqual(accessor.workingCopyService.isDirty(model.resource), true); }); test('Update Dirty', async function () { @@ -466,12 +466,12 @@ suite('Files - TextFileEditorModel', () => { model.setDirty(true); assert.ok(model.isDirty()); - assert.equal(eventCounter, 1); + assert.strictEqual(eventCounter, 1); assert.ok(workingCopyEvent); model.setDirty(false); assert.strictEqual(model.isDirty(), false); - assert.equal(eventCounter, 2); + assert.strictEqual(eventCounter, 2); model.dispose(); }); @@ -496,7 +496,7 @@ suite('Files - TextFileEditorModel', () => { assert.ok(!model.isDirty()); await model.save({ force: true }); - assert.equal(saveEvent, false); + assert.strictEqual(saveEvent, false); await model.revert({ soft: true }); assert.ok(!model.isDirty()); @@ -517,7 +517,7 @@ suite('Files - TextFileEditorModel', () => { model = await model.load() as TextFileEditorModel; assert.ok(model); - assert.equal(getLastModifiedTime(model), mtime); + assert.strictEqual(getLastModifiedTime(model), mtime); model.dispose(); }); @@ -569,7 +569,7 @@ suite('Files - TextFileEditorModel', () => { const model: TextFileEditorModel = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/index_async.txt'), 'utf8', undefined); model.onDidSave(() => { - assert.equal(snapshotToString(model.createSnapshot()!), eventCounter === 1 ? 'bar' : 'foobar'); + assert.strictEqual(snapshotToString(model.createSnapshot()!), eventCounter === 1 ? 'bar' : 'foobar'); assert.ok(!model.isDirty()); eventCounter++; }); @@ -588,14 +588,14 @@ suite('Files - TextFileEditorModel', () => { assert.ok(model.isDirty()); await model.save(); - assert.equal(eventCounter, 2); + assert.strictEqual(eventCounter, 2); participant.dispose(); model.updateTextEditorModel(createTextBufferFactory('foobar')); assert.ok(model.isDirty()); await model.save(); - assert.equal(eventCounter, 3); + assert.strictEqual(eventCounter, 3); model.dispose(); }); @@ -614,7 +614,7 @@ suite('Files - TextFileEditorModel', () => { model.updateTextEditorModel(createTextBufferFactory('foo')); await model.save({ skipSaveParticipants: true }); - assert.equal(eventCounter, 0); + assert.strictEqual(eventCounter, 0); participant.dispose(); model.dispose(); @@ -645,7 +645,7 @@ suite('Files - TextFileEditorModel', () => { const now = Date.now(); await model.save(); - assert.equal(eventCounter, 2); + assert.strictEqual(eventCounter, 2); assert.ok(Date.now() - now >= 10); model.dispose(); @@ -700,7 +700,7 @@ suite('Files - TextFileEditorModel', () => { const p4 = model.save(); await Promise.all([p1, p2, p3, p4]); - assert.equal(participations.length, 1); + assert.strictEqual(participations.length, 1); model.dispose(); participant.dispose(); @@ -740,7 +740,7 @@ suite('Files - TextFileEditorModel', () => { const newSavePromise = model.save(); // assert that this is the same promise as the outer one - assert.equal(savePromise, newSavePromise); + assert.strictEqual(savePromise, newSavePromise); } }); diff --git a/src/vs/workbench/services/textfile/test/browser/textFileEditorModelManager.test.ts b/src/vs/workbench/services/textfile/test/browser/textFileEditorModelManager.test.ts index 57e8eff87d0583964ddb852fd30af32dc1d94930..396928a87e64f820698e43734bd76e1fa3d72cef 100644 --- a/src/vs/workbench/services/textfile/test/browser/textFileEditorModelManager.test.ts +++ b/src/vs/workbench/services/textfile/test/browser/textFileEditorModelManager.test.ts @@ -98,21 +98,21 @@ suite('Files - TextFileEditorModelManager', () => { const model1 = await modelPromise; assert.ok(model1); - assert.equal(model1.getEncoding(), encoding); - assert.equal(manager.get(resource), model1); + assert.strictEqual(model1.getEncoding(), encoding); + assert.strictEqual(manager.get(resource), model1); const model2 = await manager.resolve(resource, { encoding }); - assert.equal(model2, model1); + assert.strictEqual(model2, model1); model1.dispose(); const model3 = await manager.resolve(resource, { encoding }); assert.notEqual(model3, model2); - assert.equal(manager.get(resource), model3); + assert.strictEqual(manager.get(resource), model3); model3.dispose(); - assert.equal(events.length, 2); - assert.equal(events[0].resource.toString(), model1.resource.toString()); - assert.equal(events[1].resource.toString(), model2.resource.toString()); + assert.strictEqual(events.length, 2); + assert.strictEqual(events[0].resource.toString(), model1.resource.toString()); + assert.strictEqual(events[1].resource.toString(), model2.resource.toString()); listener.dispose(); @@ -128,12 +128,12 @@ suite('Files - TextFileEditorModelManager', () => { const resource = URI.file('/test.html'); const model = await manager.resolve(resource, { contents: createTextBufferFactory('Hello World') }); - assert.equal(model.textEditorModel?.getValue(), 'Hello World'); - assert.equal(model.isDirty(), true); + assert.strictEqual(model.textEditorModel?.getValue(), 'Hello World'); + assert.strictEqual(model.isDirty(), true); await manager.resolve(resource, { contents: createTextBufferFactory('More Changes') }); - assert.equal(model.textEditorModel?.getValue(), 'More Changes'); - assert.equal(model.isDirty(), true); + assert.strictEqual(model.textEditorModel?.getValue(), 'More Changes'); + assert.strictEqual(model.isDirty(), true); model.dispose(); manager.dispose(); @@ -151,8 +151,8 @@ suite('Files - TextFileEditorModelManager', () => { await secondModelPromise; const model = await thirdModelPromise; - assert.equal(model.textEditorModel?.getValue(), 'More Changes'); - assert.equal(model.isDirty(), true); + assert.strictEqual(model.textEditorModel?.getValue(), 'More Changes'); + assert.strictEqual(model.isDirty(), true); model.dispose(); manager.dispose(); @@ -228,13 +228,13 @@ suite('Files - TextFileEditorModelManager', () => { }); const model1 = await manager.resolve(resource1, { encoding: 'utf8' }); - assert.equal(loadedCounter, 1); + assert.strictEqual(loadedCounter, 1); accessor.fileService.fireFileChanges(new FileChangesEvent([{ resource: resource1, type: FileChangeType.DELETED }], false)); accessor.fileService.fireFileChanges(new FileChangesEvent([{ resource: resource1, type: FileChangeType.ADDED }], false)); const model2 = await manager.resolve(resource2, { encoding: 'utf8' }); - assert.equal(loadedCounter, 2); + assert.strictEqual(loadedCounter, 2); model1.updateTextEditorModel(createTextBufferFactory('changed')); model1.updatePreferredEncoding('utf16'); @@ -247,11 +247,11 @@ suite('Files - TextFileEditorModelManager', () => { model2.dispose(); await model1.revert(); - assert.equal(gotDirtyCounter, 2); - assert.equal(gotNonDirtyCounter, 2); - assert.equal(revertedCounter, 1); - assert.equal(savedCounter, 1); - assert.equal(encodingCounter, 2); + assert.strictEqual(gotDirtyCounter, 2); + assert.strictEqual(gotNonDirtyCounter, 2); + assert.strictEqual(revertedCounter, 1); + assert.strictEqual(savedCounter, 1); + assert.strictEqual(encodingCounter, 2); model1.dispose(); model2.dispose(); @@ -289,15 +289,15 @@ suite('Files - TextFileEditorModelManager', () => { canDispose = await canDisposePromise; })(); - assert.equal(canDispose, false); + assert.strictEqual(canDispose, false); model.revert({ soft: true }); await timeout(0); - assert.equal(canDispose, true); + assert.strictEqual(canDispose, true); let canDispose2 = manager.canDispose(model as TextFileEditorModel); - assert.equal(canDispose2, true); + assert.strictEqual(canDispose2, true); manager.dispose(); }); @@ -313,10 +313,10 @@ suite('Files - TextFileEditorModelManager', () => { const resource = toResource.call(this, '/path/index_something.txt'); let model = await manager.resolve(resource, { mode }); - assert.equal(model.textEditorModel!.getModeId(), mode); + assert.strictEqual(model.textEditorModel!.getModeId(), mode); model = await manager.resolve(resource, { mode: 'text' }); - assert.equal(model.textEditorModel!.getModeId(), PLAINTEXT_MODE_ID); + assert.strictEqual(model.textEditorModel!.getModeId(), PLAINTEXT_MODE_ID); model.dispose(); manager.dispose(); diff --git a/src/vs/workbench/services/textfile/test/browser/textFileService.test.ts b/src/vs/workbench/services/textfile/test/browser/textFileService.test.ts index 9bac6b5cf60088d495b9a6402724c455d32d37fa..19a8a497cf6805b86e464fb3bba381fda021dc76 100644 --- a/src/vs/workbench/services/textfile/test/browser/textFileService.test.ts +++ b/src/vs/workbench/services/textfile/test/browser/textFileService.test.ts @@ -58,7 +58,7 @@ suite('Files - TextFileService', () => { assert.ok(accessor.textFileService.isDirty(model.resource)); const res = await accessor.textFileService.save(model.resource); - assert.equal(res?.toString(), model.resource.toString()); + assert.strictEqual(res?.toString(), model.resource.toString()); assert.ok(!accessor.textFileService.isDirty(model.resource)); }); @@ -71,7 +71,7 @@ suite('Files - TextFileService', () => { assert.ok(accessor.textFileService.isDirty(model.resource)); const res = await accessor.textFileService.save(model.resource); - assert.equal(res?.toString(), model.resource.toString()); + assert.strictEqual(res?.toString(), model.resource.toString()); assert.ok(!accessor.textFileService.isDirty(model.resource)); }); @@ -85,7 +85,7 @@ suite('Files - TextFileService', () => { assert.ok(accessor.textFileService.isDirty(model.resource)); const res = await accessor.textFileService.saveAs(model.resource); - assert.equal(res!.toString(), model.resource.toString()); + assert.strictEqual(res!.toString(), model.resource.toString()); assert.ok(!accessor.textFileService.isDirty(model.resource)); }); @@ -114,21 +114,21 @@ suite('Files - TextFileService', () => { const disposable1 = accessor.workingCopyFileService.addFileOperationParticipant({ participate: async files => { - assert.equal(files[0].target, model.resource.toString()); + assert.strictEqual(files[0].target.toString(), model.resource.toString()); eventCounter++; } }); const disposable2 = accessor.workingCopyFileService.onDidRunWorkingCopyFileOperation(e => { - assert.equal(e.operation, FileOperation.CREATE); - assert.equal(e.files[0].target.toString(), model.resource.toString()); + assert.strictEqual(e.operation, FileOperation.CREATE); + assert.strictEqual(e.files[0].target.toString(), model.resource.toString()); eventCounter++; }); await accessor.textFileService.create([{ resource: model.resource, value: 'Foo' }]); assert.ok(!accessor.textFileService.isDirty(model.resource)); - assert.equal(eventCounter, 2); + assert.strictEqual(eventCounter, 2); disposable1.dispose(); disposable2.dispose(); @@ -141,7 +141,7 @@ suite('Files - TextFileService', () => { }); let suggested = accessor.textFileService.suggestFilename('shleem', 'Untitled-1'); - assert.equal(suggested, 'Untitled-1'); + assert.strictEqual(suggested, 'Untitled-1'); }); test('Filename Suggestion - Suggest prefix with first extension', () => { @@ -152,7 +152,7 @@ suite('Files - TextFileService', () => { }); let suggested = accessor.textFileService.suggestFilename('plumbus1', 'Untitled-1'); - assert.equal(suggested, 'Untitled-1.shleem'); + assert.strictEqual(suggested, 'Untitled-1.shleem'); }); test('Filename Suggestion - Suggest filename if there are no extensions', () => { @@ -162,7 +162,7 @@ suite('Files - TextFileService', () => { }); let suggested = accessor.textFileService.suggestFilename('plumbus2', 'Untitled-1'); - assert.equal(suggested, 'plumbus'); + assert.strictEqual(suggested, 'plumbus'); }); }); diff --git a/src/vs/workbench/services/textfile/test/common/textFileService.io.test.ts b/src/vs/workbench/services/textfile/test/common/textFileService.io.test.ts index 1a83652a2d4484cd293057cc30987dc8c33ac3bf..dab4b4e6225fb8b1474b2b023ea34f86dba56e83 100644 --- a/src/vs/workbench/services/textfile/test/common/textFileService.io.test.ts +++ b/src/vs/workbench/services/textfile/test/common/textFileService.io.test.ts @@ -56,7 +56,7 @@ export default function createSuite(params: Params) { await service.create([{ resource }]); const res = await readFile(resource.fsPath); - assert.equal(res.byteLength, 0 /* no BOM */); + assert.strictEqual(res.byteLength, 0 /* no BOM */); }); test('create - no encoding - content provided (string)', async () => { @@ -65,8 +65,8 @@ export default function createSuite(params: Params) { await service.create([{ resource, value: 'Hello World' }]); const res = await readFile(resource.fsPath); - assert.equal(res.toString(), 'Hello World'); - assert.equal(res.byteLength, 'Hello World'.length); + assert.strictEqual(res.toString(), 'Hello World'); + assert.strictEqual(res.byteLength, 'Hello World'.length); }); test('create - no encoding - content provided (snapshot)', async () => { @@ -75,8 +75,8 @@ export default function createSuite(params: Params) { await service.create([{ resource, value: stringToSnapshot('Hello World') }]); const res = await readFile(resource.fsPath); - assert.equal(res.toString(), 'Hello World'); - assert.equal(res.byteLength, 'Hello World'.length); + assert.strictEqual(res.toString(), 'Hello World'); + assert.strictEqual(res.byteLength, 'Hello World'.length); }); test('create - UTF 16 LE - no content', async () => { @@ -84,13 +84,13 @@ export default function createSuite(params: Params) { await service.create([{ resource }]); - assert.equal(await exists(resource.fsPath), true); + assert.strictEqual(await exists(resource.fsPath), true); const detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, UTF16le); + assert.strictEqual(detectedEncoding, UTF16le); const res = await readFile(resource.fsPath); - assert.equal(res.byteLength, UTF16le_BOM.length); + assert.strictEqual(res.byteLength, UTF16le_BOM.length); }); test('create - UTF 16 LE - content provided', async () => { @@ -98,13 +98,13 @@ export default function createSuite(params: Params) { await service.create([{ resource, value: 'Hello World' }]); - assert.equal(await exists(resource.fsPath), true); + assert.strictEqual(await exists(resource.fsPath), true); const detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, UTF16le); + assert.strictEqual(detectedEncoding, UTF16le); const res = await readFile(resource.fsPath); - assert.equal(res.byteLength, 'Hello World'.length * 2 /* UTF16 2bytes per char */ + UTF16le_BOM.length); + assert.strictEqual(res.byteLength, 'Hello World'.length * 2 /* UTF16 2bytes per char */ + UTF16le_BOM.length); }); test('create - UTF 16 BE - no content', async () => { @@ -112,13 +112,13 @@ export default function createSuite(params: Params) { await service.create([{ resource }]); - assert.equal(await exists(resource.fsPath), true); + assert.strictEqual(await exists(resource.fsPath), true); const detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, UTF16be); + assert.strictEqual(detectedEncoding, UTF16be); const res = await readFile(resource.fsPath); - assert.equal(res.byteLength, UTF16le_BOM.length); + assert.strictEqual(res.byteLength, UTF16le_BOM.length); }); test('create - UTF 16 BE - content provided', async () => { @@ -126,13 +126,13 @@ export default function createSuite(params: Params) { await service.create([{ resource, value: 'Hello World' }]); - assert.equal(await exists(resource.fsPath), true); + assert.strictEqual(await exists(resource.fsPath), true); const detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, UTF16be); + assert.strictEqual(detectedEncoding, UTF16be); const res = await readFile(resource.fsPath); - assert.equal(res.byteLength, 'Hello World'.length * 2 /* UTF16 2bytes per char */ + UTF16be_BOM.length); + assert.strictEqual(res.byteLength, 'Hello World'.length * 2 /* UTF16 2bytes per char */ + UTF16be_BOM.length); }); test('create - UTF 8 BOM - no content', async () => { @@ -140,13 +140,13 @@ export default function createSuite(params: Params) { await service.create([{ resource }]); - assert.equal(await exists(resource.fsPath), true); + assert.strictEqual(await exists(resource.fsPath), true); const detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, UTF8_with_bom); + assert.strictEqual(detectedEncoding, UTF8_with_bom); const res = await readFile(resource.fsPath); - assert.equal(res.byteLength, UTF8_BOM.length); + assert.strictEqual(res.byteLength, UTF8_BOM.length); }); test('create - UTF 8 BOM - content provided', async () => { @@ -154,13 +154,13 @@ export default function createSuite(params: Params) { await service.create([{ resource, value: 'Hello World' }]); - assert.equal(await exists(resource.fsPath), true); + assert.strictEqual(await exists(resource.fsPath), true); const detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, UTF8_with_bom); + assert.strictEqual(detectedEncoding, UTF8_with_bom); const res = await readFile(resource.fsPath); - assert.equal(res.byteLength, 'Hello World'.length + UTF8_BOM.length); + assert.strictEqual(res.byteLength, 'Hello World'.length + UTF8_BOM.length); }); test('create - UTF 8 BOM - empty content - snapshot', async () => { @@ -168,13 +168,13 @@ export default function createSuite(params: Params) { await service.create([{ resource, value: createTextModel('').createSnapshot() }]); - assert.equal(await exists(resource.fsPath), true); + assert.strictEqual(await exists(resource.fsPath), true); const detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, UTF8_with_bom); + assert.strictEqual(detectedEncoding, UTF8_with_bom); const res = await readFile(resource.fsPath); - assert.equal(res.byteLength, UTF8_BOM.length); + assert.strictEqual(res.byteLength, UTF8_BOM.length); }); test('create - UTF 8 BOM - content provided - snapshot', async () => { @@ -182,13 +182,13 @@ export default function createSuite(params: Params) { await service.create([{ resource, value: createTextModel('Hello World').createSnapshot() }]); - assert.equal(await exists(resource.fsPath), true); + assert.strictEqual(await exists(resource.fsPath), true); const detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, UTF8_with_bom); + assert.strictEqual(detectedEncoding, UTF8_with_bom); const res = await readFile(resource.fsPath); - assert.equal(res.byteLength, 'Hello World'.length + UTF8_BOM.length); + assert.strictEqual(res.byteLength, 'Hello World'.length + UTF8_BOM.length); }); test('write - use encoding (UTF 16 BE) - small content as string', async () => { @@ -211,12 +211,12 @@ export default function createSuite(params: Params) { await service.write(resource, content, { encoding }); const detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, encoding); + assert.strictEqual(detectedEncoding, encoding); const resolved = await service.readStream(resource); - assert.equal(resolved.encoding, encoding); + assert.strictEqual(resolved.encoding, encoding); - assert.equal(snapshotToString(resolved.value.create(isWindows ? DefaultEndOfLine.CRLF : DefaultEndOfLine.LF).textBuffer.createSnapshot(false)), expectedContent); + assert.strictEqual(snapshotToString(resolved.value.create(isWindows ? DefaultEndOfLine.CRLF : DefaultEndOfLine.LF).textBuffer.createSnapshot(false)), expectedContent); } test('write - use encoding (cp1252)', async () => { @@ -245,17 +245,17 @@ export default function createSuite(params: Params) { async function testEncodingKeepsData(resource: URI, encoding: string, expected: string) { let resolved = await service.readStream(resource, { encoding }); const content = snapshotToString(resolved.value.create(isWindows ? DefaultEndOfLine.CRLF : DefaultEndOfLine.LF).textBuffer.createSnapshot(false)); - assert.equal(content, expected); + assert.strictEqual(content, expected); await service.write(resource, content, { encoding }); resolved = await service.readStream(resource, { encoding }); - assert.equal(snapshotToString(resolved.value.create(DefaultEndOfLine.CRLF).textBuffer.createSnapshot(false)), content); + assert.strictEqual(snapshotToString(resolved.value.create(DefaultEndOfLine.CRLF).textBuffer.createSnapshot(false)), content); await service.write(resource, createTextModel(content).createSnapshot(), { encoding }); resolved = await service.readStream(resource, { encoding }); - assert.equal(snapshotToString(resolved.value.create(DefaultEndOfLine.CRLF).textBuffer.createSnapshot(false)), content); + assert.strictEqual(snapshotToString(resolved.value.create(DefaultEndOfLine.CRLF).textBuffer.createSnapshot(false)), content); } test('write - no encoding - content as string', async () => { @@ -266,7 +266,7 @@ export default function createSuite(params: Params) { await service.write(resource, content); const resolved = await service.readStream(resource); - assert.equal(resolved.value.getFirstLineText(999999), content); + assert.strictEqual(resolved.value.getFirstLineText(999999), content); }); test('write - no encoding - content as snapshot', async () => { @@ -277,14 +277,14 @@ export default function createSuite(params: Params) { await service.write(resource, createTextModel(content).createSnapshot()); const resolved = await service.readStream(resource); - assert.equal(resolved.value.getFirstLineText(999999), content); + assert.strictEqual(resolved.value.getFirstLineText(999999), content); }); test('write - encoding preserved (UTF 16 LE) - content as string', async () => { const resource = URI.file(join(testDir, 'some_utf16le.css')); const resolved = await service.readStream(resource); - assert.equal(resolved.encoding, UTF16le); + assert.strictEqual(resolved.encoding, UTF16le); await testEncoding(URI.file(join(testDir, 'some_utf16le.css')), UTF16le, 'Hello\nWorld', 'Hello\nWorld'); }); @@ -293,7 +293,7 @@ export default function createSuite(params: Params) { const resource = URI.file(join(testDir, 'some_utf16le.css')); const resolved = await service.readStream(resource); - assert.equal(resolved.encoding, UTF16le); + assert.strictEqual(resolved.encoding, UTF16le); await testEncoding(URI.file(join(testDir, 'some_utf16le.css')), UTF16le, createTextModel('Hello\nWorld').createSnapshot(), 'Hello\nWorld'); }); @@ -302,67 +302,67 @@ export default function createSuite(params: Params) { const resource = URI.file(join(testDir, 'index.html')); let detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, null); + assert.strictEqual(detectedEncoding, null); const content = (await readFile(resource.fsPath)).toString() + 'updates'; await service.write(resource, content, { encoding: UTF8_with_bom }); detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, UTF8_with_bom); + assert.strictEqual(detectedEncoding, UTF8_with_bom); // ensure BOM preserved if enforced await service.write(resource, content, { encoding: UTF8_with_bom }); detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, UTF8_with_bom); + assert.strictEqual(detectedEncoding, UTF8_with_bom); // allow to remove BOM await service.write(resource, content, { encoding: UTF8 }); detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, null); + assert.strictEqual(detectedEncoding, null); // BOM does not come back await service.write(resource, content, { encoding: UTF8 }); detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, null); + assert.strictEqual(detectedEncoding, null); }); test('write - UTF8 variations - content as snapshot', async () => { const resource = URI.file(join(testDir, 'index.html')); let detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, null); + assert.strictEqual(detectedEncoding, null); const model = createTextModel((await readFile(resource.fsPath)).toString() + 'updates'); await service.write(resource, model.createSnapshot(), { encoding: UTF8_with_bom }); detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, UTF8_with_bom); + assert.strictEqual(detectedEncoding, UTF8_with_bom); // ensure BOM preserved if enforced await service.write(resource, model.createSnapshot(), { encoding: UTF8_with_bom }); detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, UTF8_with_bom); + assert.strictEqual(detectedEncoding, UTF8_with_bom); // allow to remove BOM await service.write(resource, model.createSnapshot(), { encoding: UTF8 }); detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, null); + assert.strictEqual(detectedEncoding, null); // BOM does not come back await service.write(resource, model.createSnapshot(), { encoding: UTF8 }); detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, null); + assert.strictEqual(detectedEncoding, null); }); test('write - preserve UTF8 BOM - content as string', async () => { const resource = URI.file(join(testDir, 'some_utf8_bom.txt')); let detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, UTF8_with_bom); + assert.strictEqual(detectedEncoding, UTF8_with_bom); await service.write(resource, 'Hello World', { encoding: detectedEncoding! }); detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, UTF8_with_bom); + assert.strictEqual(detectedEncoding, UTF8_with_bom); }); test('write - ensure BOM in empty file - content as string', async () => { @@ -371,7 +371,7 @@ export default function createSuite(params: Params) { await service.write(resource, '', { encoding: UTF8_with_bom }); let detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, UTF8_with_bom); + assert.strictEqual(detectedEncoding, UTF8_with_bom); }); test('write - ensure BOM in empty file - content as snapshot', async () => { @@ -380,7 +380,7 @@ export default function createSuite(params: Params) { await service.write(resource, createTextModel('').createSnapshot(), { encoding: UTF8_with_bom }); let detectedEncoding = await detectEncodingByBOM(resource.fsPath); - assert.equal(detectedEncoding, UTF8_with_bom); + assert.strictEqual(detectedEncoding, UTF8_with_bom); }); test('readStream - small text', async () => { @@ -398,11 +398,11 @@ export default function createSuite(params: Params) { async function testReadStream(resource: URI): Promise { const result = await service.readStream(resource); - assert.equal(result.name, basename(resource.fsPath)); - assert.equal(result.size, (await stat(resource.fsPath)).size); + assert.strictEqual(result.name, basename(resource.fsPath)); + assert.strictEqual(result.size, (await stat(resource.fsPath)).size); const content = (await readFile(resource.fsPath)).toString(); - assert.equal( + assert.strictEqual( snapshotToString(result.value.create(DefaultEndOfLine.LF).textBuffer.createSnapshot(false)), snapshotToString(createTextModel(content).createSnapshot(false))); } @@ -422,9 +422,9 @@ export default function createSuite(params: Params) { async function testRead(resource: URI): Promise { const result = await service.read(resource); - assert.equal(result.name, basename(resource.fsPath)); - assert.equal(result.size, (await stat(resource.fsPath)).size); - assert.equal(result.value, (await readFile(resource.fsPath)).toString()); + assert.strictEqual(result.name, basename(resource.fsPath)); + assert.strictEqual(result.size, (await stat(resource.fsPath)).size); + assert.strictEqual(result.value, (await readFile(resource.fsPath)).toString()); } test('readStream - encoding picked up (CP1252)', async () => { @@ -432,8 +432,8 @@ export default function createSuite(params: Params) { const encoding = 'windows1252'; const result = await service.readStream(resource, { encoding }); - assert.equal(result.encoding, encoding); - assert.equal(result.value.getFirstLineText(999999), 'Private = "Persönlicheß Information"'); + assert.strictEqual(result.encoding, encoding); + assert.strictEqual(result.value.getFirstLineText(999999), 'Private = "Persönlicheß Information"'); }); test('read - encoding picked up (CP1252)', async () => { @@ -441,8 +441,8 @@ export default function createSuite(params: Params) { const encoding = 'windows1252'; const result = await service.read(resource, { encoding }); - assert.equal(result.encoding, encoding); - assert.equal(result.value, 'Private = "Persönlicheß Information"'); + assert.strictEqual(result.encoding, encoding); + assert.strictEqual(result.value, 'Private = "Persönlicheß Information"'); }); test('read - encoding picked up (binary)', async () => { @@ -450,8 +450,8 @@ export default function createSuite(params: Params) { const encoding = 'binary'; const result = await service.read(resource, { encoding }); - assert.equal(result.encoding, encoding); - assert.equal(result.value, 'Private = "Persönlicheß Information"'); + assert.strictEqual(result.encoding, encoding); + assert.strictEqual(result.value, 'Private = "Persönlicheß Information"'); }); test('read - encoding picked up (base64)', async () => { @@ -459,37 +459,37 @@ export default function createSuite(params: Params) { const encoding = 'base64'; const result = await service.read(resource, { encoding }); - assert.equal(result.encoding, encoding); - assert.equal(result.value, btoa('Private = "Persönlicheß Information"')); + assert.strictEqual(result.encoding, encoding); + assert.strictEqual(result.value, btoa('Private = "Persönlicheß Information"')); }); test('readStream - user overrides BOM', async () => { const resource = URI.file(join(testDir, 'some_utf16le.css')); const result = await service.readStream(resource, { encoding: 'windows1252' }); - assert.equal(result.encoding, 'windows1252'); + assert.strictEqual(result.encoding, 'windows1252'); }); test('readStream - BOM removed', async () => { const resource = URI.file(join(testDir, 'some_utf8_bom.txt')); const result = await service.readStream(resource); - assert.equal(result.value.getFirstLineText(999999), 'This is some UTF 8 with BOM file.'); + assert.strictEqual(result.value.getFirstLineText(999999), 'This is some UTF 8 with BOM file.'); }); test('readStream - invalid encoding', async () => { const resource = URI.file(join(testDir, 'index.html')); const result = await service.readStream(resource, { encoding: 'superduper' }); - assert.equal(result.encoding, 'utf8'); + assert.strictEqual(result.encoding, 'utf8'); }); test('readStream - encoding override', async () => { const resource = URI.file(join(testDir, 'some.utf16le')); const result = await service.readStream(resource, { encoding: 'windows1252' }); - assert.equal(result.encoding, 'utf16le'); - assert.equal(result.value.getFirstLineText(999999), 'This is some UTF 16 with BOM file.'); + assert.strictEqual(result.encoding, 'utf16le'); + assert.strictEqual(result.value.getFirstLineText(999999), 'This is some UTF 16 with BOM file.'); }); test('readStream - large Big5', async () => { @@ -528,11 +528,11 @@ export default function createSuite(params: Params) { const resource = URI.file(join(testDir, `lorem_${encoding}.txt`)); const result = await service.readStream(resource, { encoding }); - assert.equal(result.encoding, encoding); + assert.strictEqual(result.encoding, encoding); const contents = snapshotToString(result.value.create(DefaultEndOfLine.LF).textBuffer.createSnapshot(false)); - assert.equal(contents.indexOf(needle), 0); + assert.strictEqual(contents.indexOf(needle), 0); assert.ok(contents.indexOf(needle, 10) > 0); } @@ -540,21 +540,21 @@ export default function createSuite(params: Params) { const resource = URI.file(join(testDir, 'utf16_le_nobom.txt')); const result = await service.readStream(resource); - assert.equal(result.encoding, 'utf16le'); + assert.strictEqual(result.encoding, 'utf16le'); }); test('readStream - UTF16 BE (no BOM)', async () => { const resource = URI.file(join(testDir, 'utf16_be_nobom.txt')); const result = await service.readStream(resource); - assert.equal(result.encoding, 'utf16be'); + assert.strictEqual(result.encoding, 'utf16be'); }); test('readStream - autoguessEncoding', async () => { const resource = URI.file(join(testDir, 'some_cp1252.txt')); const result = await service.readStream(resource, { autoGuessEncoding: true }); - assert.equal(result.encoding, 'windows1252'); + assert.strictEqual(result.encoding, 'windows1252'); }); test('readStream - FILE_IS_BINARY', async () => { @@ -568,10 +568,10 @@ export default function createSuite(params: Params) { } assert.ok(error); - assert.equal(error!.textFileOperationResult, TextFileOperationResult.FILE_IS_BINARY); + assert.strictEqual(error!.textFileOperationResult, TextFileOperationResult.FILE_IS_BINARY); const result = await service.readStream(URI.file(join(testDir, 'small.txt')), { acceptTextOnly: true }); - assert.equal(result.name, 'small.txt'); + assert.strictEqual(result.name, 'small.txt'); }); test('read - FILE_IS_BINARY', async () => { @@ -585,9 +585,9 @@ export default function createSuite(params: Params) { } assert.ok(error); - assert.equal(error!.textFileOperationResult, TextFileOperationResult.FILE_IS_BINARY); + assert.strictEqual(error!.textFileOperationResult, TextFileOperationResult.FILE_IS_BINARY); const result = await service.read(URI.file(join(testDir, 'small.txt')), { acceptTextOnly: true }); - assert.equal(result.name, 'small.txt'); + assert.strictEqual(result.name, 'small.txt'); }); } diff --git a/src/vs/workbench/services/textfile/test/node/encoding/encoding.test.ts b/src/vs/workbench/services/textfile/test/node/encoding/encoding.test.ts index f8cc4ac8dbfd21983722a409bc6df0db26dfb977..5f22081ec93afd8d18698d805d607f1f2e1e8c2d 100644 --- a/src/vs/workbench/services/textfile/test/node/encoding/encoding.test.ts +++ b/src/vs/workbench/services/textfile/test/node/encoding/encoding.test.ts @@ -83,42 +83,42 @@ suite('Encoding', () => { const file = getPathFromAmdModule(require, './fixtures/not-exist.css'); const detectedEncoding = await detectEncodingByBOM(file); - assert.equal(detectedEncoding, null); + assert.strictEqual(detectedEncoding, null); }); test('detectBOM UTF-8', async () => { const file = getPathFromAmdModule(require, './fixtures/some_utf8.css'); const detectedEncoding = await detectEncodingByBOM(file); - assert.equal(detectedEncoding, 'utf8bom'); + assert.strictEqual(detectedEncoding, 'utf8bom'); }); test('detectBOM UTF-16 LE', async () => { const file = getPathFromAmdModule(require, './fixtures/some_utf16le.css'); const detectedEncoding = await detectEncodingByBOM(file); - assert.equal(detectedEncoding, 'utf16le'); + assert.strictEqual(detectedEncoding, 'utf16le'); }); test('detectBOM UTF-16 BE', async () => { const file = getPathFromAmdModule(require, './fixtures/some_utf16be.css'); const detectedEncoding = await detectEncodingByBOM(file); - assert.equal(detectedEncoding, 'utf16be'); + assert.strictEqual(detectedEncoding, 'utf16be'); }); test('detectBOM ANSI', async function () { const file = getPathFromAmdModule(require, './fixtures/some_ansi.css'); const detectedEncoding = await detectEncodingByBOM(file); - assert.equal(detectedEncoding, null); + assert.strictEqual(detectedEncoding, null); }); test('detectBOM ANSI', async function () { const file = getPathFromAmdModule(require, './fixtures/empty.txt'); const detectedEncoding = await detectEncodingByBOM(file); - assert.equal(detectedEncoding, null); + assert.strictEqual(detectedEncoding, null); }); test('resolve terminal encoding (detect)', async function () { @@ -131,7 +131,7 @@ suite('Encoding', () => { const enc = await terminalEncoding.resolveTerminalEncoding(); assert.ok(await encoding.encodingExists(enc)); - assert.equal(enc, 'utf16le'); + assert.strictEqual(enc, 'utf16le'); }); test('detectEncodingFromBuffer (JSON saved as PNG)', async function () { @@ -139,86 +139,86 @@ suite('Encoding', () => { const buffer = await readExactlyByFile(file, 512); const mimes = encoding.detectEncodingFromBuffer(buffer); - assert.equal(mimes.seemsBinary, false); + assert.strictEqual(mimes.seemsBinary, false); }); test('detectEncodingFromBuffer (PNG saved as TXT)', async function () { const file = getPathFromAmdModule(require, './fixtures/some.png.txt'); const buffer = await readExactlyByFile(file, 512); const mimes = encoding.detectEncodingFromBuffer(buffer); - assert.equal(mimes.seemsBinary, true); + assert.strictEqual(mimes.seemsBinary, true); }); test('detectEncodingFromBuffer (XML saved as PNG)', async function () { const file = getPathFromAmdModule(require, './fixtures/some.xml.png'); const buffer = await readExactlyByFile(file, 512); const mimes = encoding.detectEncodingFromBuffer(buffer); - assert.equal(mimes.seemsBinary, false); + assert.strictEqual(mimes.seemsBinary, false); }); test('detectEncodingFromBuffer (QWOFF saved as TXT)', async function () { const file = getPathFromAmdModule(require, './fixtures/some.qwoff.txt'); const buffer = await readExactlyByFile(file, 512); const mimes = encoding.detectEncodingFromBuffer(buffer); - assert.equal(mimes.seemsBinary, true); + assert.strictEqual(mimes.seemsBinary, true); }); test('detectEncodingFromBuffer (CSS saved as QWOFF)', async function () { const file = getPathFromAmdModule(require, './fixtures/some.css.qwoff'); const buffer = await readExactlyByFile(file, 512); const mimes = encoding.detectEncodingFromBuffer(buffer); - assert.equal(mimes.seemsBinary, false); + assert.strictEqual(mimes.seemsBinary, false); }); test('detectEncodingFromBuffer (PDF)', async function () { const file = getPathFromAmdModule(require, './fixtures/some.pdf'); const buffer = await readExactlyByFile(file, 512); const mimes = encoding.detectEncodingFromBuffer(buffer); - assert.equal(mimes.seemsBinary, true); + assert.strictEqual(mimes.seemsBinary, true); }); test('detectEncodingFromBuffer (guess UTF-16 LE from content without BOM)', async function () { const file = getPathFromAmdModule(require, './fixtures/utf16_le_nobom.txt'); const buffer = await readExactlyByFile(file, 512); const mimes = encoding.detectEncodingFromBuffer(buffer); - assert.equal(mimes.encoding, encoding.UTF16le); - assert.equal(mimes.seemsBinary, false); + assert.strictEqual(mimes.encoding, encoding.UTF16le); + assert.strictEqual(mimes.seemsBinary, false); }); test('detectEncodingFromBuffer (guess UTF-16 BE from content without BOM)', async function () { const file = getPathFromAmdModule(require, './fixtures/utf16_be_nobom.txt'); const buffer = await readExactlyByFile(file, 512); const mimes = encoding.detectEncodingFromBuffer(buffer); - assert.equal(mimes.encoding, encoding.UTF16be); - assert.equal(mimes.seemsBinary, false); + assert.strictEqual(mimes.encoding, encoding.UTF16be); + assert.strictEqual(mimes.seemsBinary, false); }); test('autoGuessEncoding (UTF8)', async function () { const file = getPathFromAmdModule(require, './fixtures/some_file.css'); const buffer = await readExactlyByFile(file, 512 * 8); const mimes = await encoding.detectEncodingFromBuffer(buffer, true); - assert.equal(mimes.encoding, 'utf8'); + assert.strictEqual(mimes.encoding, 'utf8'); }); test('autoGuessEncoding (ASCII)', async function () { const file = getPathFromAmdModule(require, './fixtures/some_ansi.css'); const buffer = await readExactlyByFile(file, 512 * 8); const mimes = await encoding.detectEncodingFromBuffer(buffer, true); - assert.equal(mimes.encoding, null); + assert.strictEqual(mimes.encoding, null); }); test('autoGuessEncoding (ShiftJIS)', async function () { const file = getPathFromAmdModule(require, './fixtures/some.shiftjis.txt'); const buffer = await readExactlyByFile(file, 512 * 8); const mimes = await encoding.detectEncodingFromBuffer(buffer, true); - assert.equal(mimes.encoding, 'shiftjis'); + assert.strictEqual(mimes.encoding, 'shiftjis'); }); test('autoGuessEncoding (CP1252)', async function () { const file = getPathFromAmdModule(require, './fixtures/some.cp1252.txt'); const buffer = await readExactlyByFile(file, 512 * 8); const mimes = await encoding.detectEncodingFromBuffer(buffer, true); - assert.equal(mimes.encoding, 'windows1252'); + assert.strictEqual(mimes.encoding, 'windows1252'); }); async function readAndDecodeFromDisk(path: string, fileEncoding: string | null) { @@ -265,7 +265,7 @@ suite('Encoding', () => { assert.ok(stream); const content = await readAllAsString(stream); - assert.equal(content, 'ABCABCABC'); + assert.strictEqual(content, 'ABCABCABC'); }); test('toDecodeStream - some stream, expect too much data', async function () { @@ -281,7 +281,7 @@ suite('Encoding', () => { assert.ok(stream); const content = await readAllAsString(stream); - assert.equal(content, 'ABCABCABC'); + assert.strictEqual(content, 'ABCABCABC'); }); test('toDecodeStream - some stream, no data', async function () { @@ -294,7 +294,7 @@ suite('Encoding', () => { assert.ok(stream); const content = await readAllAsString(stream); - assert.equal(content, ''); + assert.strictEqual(content, ''); }); test('toDecodeStream - encoding, utf16be', async function () { @@ -303,12 +303,12 @@ suite('Encoding', () => { const { detected, stream } = await encoding.toDecodeStream(source, { minBytesRequiredForDetection: 64, guessEncoding: false, overwriteEncoding: async detected => detected || encoding.UTF8 }); - assert.equal(detected.encoding, 'utf16be'); - assert.equal(detected.seemsBinary, false); + assert.strictEqual(detected.encoding, 'utf16be'); + assert.strictEqual(detected.seemsBinary, false); const expected = await readAndDecodeFromDisk(path, detected.encoding); const actual = await readAllAsString(stream); - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); test('toDecodeStream - empty file', async function () { @@ -318,7 +318,7 @@ suite('Encoding', () => { const expected = await readAndDecodeFromDisk(path, detected.encoding); const actual = await readAllAsString(stream); - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); test('toDecodeStream - decodes buffer entirely', async function () { @@ -336,7 +336,7 @@ suite('Encoding', () => { const expected = new TextDecoder().decode(incompleteEmojis); const actual = await readAllAsString(stream); - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); test('toDecodeStream - some stream (GBK issue #101856)', async function () { @@ -348,7 +348,7 @@ suite('Encoding', () => { assert.ok(stream); const content = await readAllAsString(stream); - assert.equal(content.length, 65537); + assert.strictEqual(content.length, 65537); }); (isWindows /* TODO@bpasero why does this fail on windows */ ? test.skip : test)('toDecodeStream - some stream (UTF-8 issue #102202)', async function () { @@ -362,7 +362,7 @@ suite('Encoding', () => { const content = await readAllAsString(stream); const lines = content.split('\n'); - assert.equal(lines[981].toString(), '啊啊啊啊啊啊aaa啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊，啊啊啊啊啊啊啊啊啊啊啊。'); + assert.strictEqual(lines[981].toString(), '啊啊啊啊啊啊aaa啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊，啊啊啊啊啊啊啊啊啊啊啊。'); }); test('toEncodeReadable - encoding, utf16be', async function () { @@ -378,7 +378,7 @@ suite('Encoding', () => { VSBuffer.concat ).toString(); - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); test('toEncodeReadable - empty readable to utf8', async function () { @@ -393,7 +393,7 @@ suite('Encoding', () => { VSBuffer.concat ).toString(); - assert.equal(actual, ''); + assert.strictEqual(actual, ''); }); [{ @@ -421,7 +421,7 @@ suite('Encoding', () => { const expected = VSBuffer.wrap(Buffer.from(relatedBom)).toString(); const actual = streams.consumeReadable(await encodedReadable, VSBuffer.concat).toString(); - assert.equal(actual, expected); + assert.strictEqual(actual, expected); }); }); @@ -431,7 +431,7 @@ suite('Encoding', () => { continue; // skip over encodings from us } - assert.equal(iconv.encodingExists(enc), true, enc); + assert.strictEqual(iconv.encodingExists(enc), true, enc); } }); }); diff --git a/src/vs/workbench/services/textmodelResolver/test/browser/textModelResolverService.test.ts b/src/vs/workbench/services/textmodelResolver/test/browser/textModelResolverService.test.ts index ac6d0787a2f4bf58603773cf5983c37107a1ad11..fb0e1386d213fe37a4ff846ca7b790018358c316 100644 --- a/src/vs/workbench/services/textmodelResolver/test/browser/textModelResolverService.test.ts +++ b/src/vs/workbench/services/textmodelResolver/test/browser/textModelResolverService.test.ts @@ -56,7 +56,7 @@ suite('Workbench - TextModelResolverService', () => { const model = await input.resolve(); assert.ok(model); - assert.equal(snapshotToString(((model as ResourceEditorModel).createSnapshot()!)), 'Hello Test'); + assert.strictEqual(snapshotToString(((model as ResourceEditorModel).createSnapshot()!)), 'Hello Test'); let disposed = false; let disposedPromise = new Promise(resolve => { Event.once(model.onDispose)(() => { @@ -67,7 +67,7 @@ suite('Workbench - TextModelResolverService', () => { input.dispose(); await disposedPromise; - assert.equal(disposed, true); + assert.strictEqual(disposed, true); dispose.dispose(); }); @@ -83,7 +83,7 @@ suite('Workbench - TextModelResolverService', () => { const editorModel = model.textEditorModel; assert.ok(editorModel); - assert.equal(editorModel.getValue(), 'Hello Html'); + assert.strictEqual(editorModel.getValue(), 'Hello Html'); let disposed = false; Event.once(model.onDispose)(() => { @@ -92,7 +92,7 @@ suite('Workbench - TextModelResolverService', () => { ref.dispose(); await timeout(0); // due to the reference resolving the model first which is async - assert.equal(disposed, true); + assert.strictEqual(disposed, true); }); test('resolved dirty file eventually disposes', async function () { @@ -112,12 +112,12 @@ suite('Workbench - TextModelResolverService', () => { ref.dispose(); await timeout(0); - assert.equal(disposed, false); // not disposed because model still dirty + assert.strictEqual(disposed, false); // not disposed because model still dirty loadedModel.revert(); await timeout(0); - assert.equal(disposed, true); // now disposed because model got reverted + assert.strictEqual(disposed, true); // now disposed because model got reverted }); test('resolved dirty file does not dispose when new reference created', async function () { @@ -137,19 +137,19 @@ suite('Workbench - TextModelResolverService', () => { ref1.dispose(); await timeout(0); - assert.equal(disposed, false); // not disposed because model still dirty + assert.strictEqual(disposed, false); // not disposed because model still dirty const ref2 = await accessor.textModelResolverService.createModelReference(textModel.resource); loadedModel.revert(); await timeout(0); - assert.equal(disposed, false); // not disposed because we got another ref meanwhile + assert.strictEqual(disposed, false); // not disposed because we got another ref meanwhile ref2.dispose(); await timeout(0); - assert.equal(disposed, true); // now disposed because last ref got disposed + assert.strictEqual(disposed, true); // now disposed because last ref got disposed }); test('resolve untitled', async () => { @@ -160,7 +160,7 @@ suite('Workbench - TextModelResolverService', () => { await input.resolve(); const ref = await accessor.textModelResolverService.createModelReference(input.resource); const model = ref.object; - assert.equal(untitledModel, model); + assert.strictEqual(untitledModel, model); const editorModel = model.textEditorModel; assert.ok(editorModel); ref.dispose(); @@ -195,7 +195,7 @@ suite('Workbench - TextModelResolverService', () => { const model2 = modelRef2.object; const textModel = model1.textEditorModel; - assert.equal(model1, model2, 'they are the same model'); + assert.strictEqual(model1, model2, 'they are the same model'); assert(!textModel.isDisposed(), 'the text model should not be disposed'); modelRef1.dispose(); diff --git a/src/vs/workbench/services/untitled/test/browser/untitledTextEditor.test.ts b/src/vs/workbench/services/untitled/test/browser/untitledTextEditor.test.ts index 2048b160bf7a7a94d4270baba922fd41b098c6b2..1bfd85b2c25eab89218bb3191aa1631c9d706ec0 100644 --- a/src/vs/workbench/services/untitled/test/browser/untitledTextEditor.test.ts +++ b/src/vs/workbench/services/untitled/test/browser/untitledTextEditor.test.ts @@ -36,17 +36,17 @@ suite('Untitled text editors', () => { const input1 = instantiationService.createInstance(UntitledTextEditorInput, service.create()); await input1.resolve(); - assert.equal(service.get(input1.resource), input1.model); + assert.strictEqual(service.get(input1.resource), input1.model); assert.ok(service.get(input1.resource)); assert.ok(!service.get(URI.file('testing'))); const input2 = instantiationService.createInstance(UntitledTextEditorInput, service.create()); - assert.equal(service.get(input2.resource), input2.model); + assert.strictEqual(service.get(input2.resource), input2.model); // get() - assert.equal(service.get(input1.resource), input1.model); - assert.equal(service.get(input2.resource), input2.model); + assert.strictEqual(service.get(input1.resource), input1.model); + assert.strictEqual(service.get(input2.resource), input2.model); // revert() await input1.revert(0); @@ -55,7 +55,7 @@ suite('Untitled text editors', () => { // dirty const model = await input2.resolve(); - assert.equal(await service.resolve({ untitledResource: input2.resource }), model); + assert.strictEqual(await service.resolve({ untitledResource: input2.resource }), model); assert.ok(service.get(model.resource)); assert.ok(!input2.isDirty()); @@ -66,12 +66,12 @@ suite('Untitled text editors', () => { const resource = await resourcePromise; - assert.equal(resource.toString(), input2.resource.toString()); + assert.strictEqual(resource.toString(), input2.resource.toString()); assert.ok(input2.isDirty()); assert.ok(workingCopyService.isDirty(input2.resource)); - assert.equal(workingCopyService.dirtyCount, 1); + assert.strictEqual(workingCopyService.dirtyCount, 1); await input1.revert(0); await input2.revert(0); @@ -81,7 +81,7 @@ suite('Untitled text editors', () => { assert.ok(!model.isDirty()); assert.ok(!workingCopyService.isDirty(input2.resource)); - assert.equal(workingCopyService.dirtyCount, 0); + assert.strictEqual(workingCopyService.dirtyCount, 0); await input1.revert(0); assert.ok(input1.isDisposed()); @@ -129,12 +129,12 @@ suite('Untitled text editors', () => { const model = service.create({ associatedResource: file }); const untitled = instantiationService.createInstance(UntitledTextEditorInput, model); assert.ok(untitled.isDirty()); - assert.equal(model, onDidChangeDirtyModel); + assert.strictEqual(model, onDidChangeDirtyModel); const resolvedModel = await untitled.resolve(); assert.ok(resolvedModel.hasAssociatedFilePath); - assert.equal(untitled.isDirty(), true); + assert.strictEqual(untitled.isDirty(), true); untitled.dispose(); listener.dispose(); @@ -169,13 +169,13 @@ suite('Untitled text editors', () => { assert.ok(!model1.isDirty()); const model2 = await instantiationService.createInstance(UntitledTextEditorInput, service.create({ initialValue: 'Hello World' })).resolve(); - assert.equal(snapshotToString(model2.createSnapshot()!), 'Hello World'); + assert.strictEqual(snapshotToString(model2.createSnapshot()!), 'Hello World'); const input = instantiationService.createInstance(UntitledTextEditorInput, service.create()); const model3 = await instantiationService.createInstance(UntitledTextEditorInput, service.create({ untitledResource: input.resource })).resolve(); - assert.equal(model3.resource.toString(), input.resource.toString()); + assert.strictEqual(model3.resource.toString(), input.resource.toString()); const file = URI.file(join('C:\\', '/foo/file44.txt')); const model4 = await instantiationService.createInstance(UntitledTextEditorInput, service.create({ associatedResource: file })).resolve(); @@ -214,7 +214,7 @@ suite('Untitled text editors', () => { // dirty const model = await untitled.resolve(); assert.ok(model.isDirty()); - assert.equal(workingCopyService.dirtyCount, 1); + assert.strictEqual(workingCopyService.dirtyCount, 1); untitled.dispose(); model.dispose(); @@ -228,7 +228,7 @@ suite('Untitled text editors', () => { const service = accessor.untitledTextEditorService; const input = service.create(); - assert.equal(input.getMode(), defaultLanguage); + assert.strictEqual(input.getMode(), defaultLanguage); config.setUserConfiguration('files', { 'defaultLanguage': undefined }); @@ -244,7 +244,7 @@ suite('Untitled text editors', () => { const service = accessor.untitledTextEditorService; const model = service.create(); - assert.equal(model.getMode(), 'typescript'); + assert.strictEqual(model.getMode(), 'typescript'); config.setUserConfiguration('files', { 'defaultLanguage': undefined }); accessor.editorService.activeTextEditorMode = undefined; @@ -261,7 +261,7 @@ suite('Untitled text editors', () => { const service = accessor.untitledTextEditorService; const input = service.create({ mode }); - assert.equal(input.getMode(), mode); + assert.strictEqual(input.getMode(), mode); config.setUserConfiguration('files', { 'defaultLanguage': undefined }); @@ -279,14 +279,14 @@ suite('Untitled text editors', () => { const input = instantiationService.createInstance(UntitledTextEditorInput, service.create({ mode })); assert.ok(input.model.hasModeSetExplicitly); - assert.equal(input.getMode(), mode); + assert.strictEqual(input.getMode(), mode); const model = await input.resolve(); - assert.equal(model.getMode(), mode); + assert.strictEqual(model.getMode(), mode); input.setMode('plaintext'); - assert.equal(input.getMode(), PLAINTEXT_MODE_ID); + assert.strictEqual(input.getMode(), PLAINTEXT_MODE_ID); input.dispose(); model.dispose(); @@ -307,7 +307,7 @@ suite('Untitled text editors', () => { input.setMode('plaintext'); assert.ok(input.model.hasModeSetExplicitly); - assert.equal(input.getMode(), PLAINTEXT_MODE_ID); + assert.strictEqual(input.getMode(), PLAINTEXT_MODE_ID); input.dispose(); model.dispose(); @@ -321,13 +321,13 @@ suite('Untitled text editors', () => { service.onDidChangeEncoding(model => { counter++; - assert.equal(model.resource.toString(), input.resource.toString()); + assert.strictEqual(model.resource.toString(), input.resource.toString()); }); // encoding const model = await input.resolve(); model.setEncoding('utf16'); - assert.equal(counter, 1); + assert.strictEqual(counter, 1); input.dispose(); model.dispose(); }); @@ -340,13 +340,13 @@ suite('Untitled text editors', () => { service.onDidChangeLabel(model => { counter++; - assert.equal(model.resource.toString(), input.resource.toString()); + assert.strictEqual(model.resource.toString(), input.resource.toString()); }); // label const model = await input.resolve(); model.textEditorModel.setValue('Foo Bar'); - assert.equal(counter, 1); + assert.strictEqual(counter, 1); input.dispose(); model.dispose(); }); @@ -359,13 +359,13 @@ suite('Untitled text editors', () => { service.onDidDispose(model => { counter++; - assert.equal(model.resource.toString(), input.resource.toString()); + assert.strictEqual(model.resource.toString(), input.resource.toString()); }); const model = await input.resolve(); - assert.equal(counter, 0); + assert.strictEqual(counter, 0); model.dispose(); - assert.equal(counter, 1); + assert.strictEqual(counter, 1); }); test('model#onDidChangeContent', async function () { @@ -379,16 +379,16 @@ suite('Untitled text editors', () => { model.textEditorModel.setValue('foo'); - assert.equal(counter, 1, 'Dirty model should trigger event'); + assert.strictEqual(counter, 1, 'Dirty model should trigger event'); model.textEditorModel.setValue('bar'); - assert.equal(counter, 2, 'Content change when dirty should trigger event'); + assert.strictEqual(counter, 2, 'Content change when dirty should trigger event'); model.textEditorModel.setValue(''); - assert.equal(counter, 3, 'Manual revert should trigger event'); + assert.strictEqual(counter, 3, 'Manual revert should trigger event'); model.textEditorModel.setValue('foo'); - assert.equal(counter, 4, 'Dirty model should trigger event'); + assert.strictEqual(counter, 4, 'Dirty model should trigger event'); input.dispose(); model.dispose(); @@ -421,43 +421,43 @@ suite('Untitled text editors', () => { model.onDidChangeName(() => counter++); model.textEditorModel.setValue('foo'); - assert.equal(input.getName(), 'foo'); - assert.equal(model.name, 'foo'); + assert.strictEqual(input.getName(), 'foo'); + assert.strictEqual(model.name, 'foo'); - assert.equal(counter, 1); + assert.strictEqual(counter, 1); model.textEditorModel.setValue('bar'); - assert.equal(input.getName(), 'bar'); - assert.equal(model.name, 'bar'); + assert.strictEqual(input.getName(), 'bar'); + assert.strictEqual(model.name, 'bar'); - assert.equal(counter, 2); + assert.strictEqual(counter, 2); model.textEditorModel.setValue(''); - assert.equal(input.getName(), 'Untitled-1'); - assert.equal(model.name, 'Untitled-1'); + assert.strictEqual(input.getName(), 'Untitled-1'); + assert.strictEqual(model.name, 'Untitled-1'); model.textEditorModel.setValue(' '); - assert.equal(input.getName(), 'Untitled-1'); - assert.equal(model.name, 'Untitled-1'); + assert.strictEqual(input.getName(), 'Untitled-1'); + assert.strictEqual(model.name, 'Untitled-1'); model.textEditorModel.setValue('([]}'); // require actual words - assert.equal(input.getName(), 'Untitled-1'); - assert.equal(model.name, 'Untitled-1'); + assert.strictEqual(input.getName(), 'Untitled-1'); + assert.strictEqual(model.name, 'Untitled-1'); model.textEditorModel.setValue('([]}hello '); // require actual words - assert.equal(input.getName(), '([]}hello'); - assert.equal(model.name, '([]}hello'); + assert.strictEqual(input.getName(), '([]}hello'); + assert.strictEqual(model.name, '([]}hello'); model.textEditorModel.setValue('12345678901234567890123456789012345678901234567890'); // trimmed at 40chars max - assert.equal(input.getName(), '1234567890123456789012345678901234567890'); - assert.equal(model.name, '1234567890123456789012345678901234567890'); + assert.strictEqual(input.getName(), '1234567890123456789012345678901234567890'); + assert.strictEqual(model.name, '1234567890123456789012345678901234567890'); model.textEditorModel.setValue('123456789012345678901234567890123456789🌞'); // do not break grapehems (#111235) - assert.equal(input.getName(), '123456789012345678901234567890123456789'); - assert.equal(model.name, '123456789012345678901234567890123456789'); + assert.strictEqual(input.getName(), '123456789012345678901234567890123456789'); + assert.strictEqual(model.name, '123456789012345678901234567890123456789'); - assert.equal(counter, 6); + assert.strictEqual(counter, 6); model.textEditorModel.setValue('Hello\nWorld'); - assert.equal(counter, 7); + assert.strictEqual(counter, 7); function createSingleEditOp(text: string, positionLineNumber: number, positionColumn: number, selectionLineNumber: number = positionLineNumber, selectionColumn: number = positionColumn): IIdentifiedSingleEditOperation { let range = new Range( @@ -476,7 +476,7 @@ suite('Untitled text editors', () => { } model.textEditorModel.applyEdits([createSingleEditOp('hello', 2, 2)]); - assert.equal(counter, 7); // change was not on first line + assert.strictEqual(counter, 7); // change was not on first line input.dispose(); model.dispose(); @@ -484,7 +484,7 @@ suite('Untitled text editors', () => { const inputWithContents = instantiationService.createInstance(UntitledTextEditorInput, service.create({ initialValue: 'Foo' })); model = await inputWithContents.resolve(); - assert.equal(inputWithContents.getName(), 'Foo'); + assert.strictEqual(inputWithContents.getName(), 'Foo'); inputWithContents.dispose(); model.dispose(); @@ -501,10 +501,10 @@ suite('Untitled text editors', () => { model.textEditorModel.setValue('foo'); - assert.equal(counter, 1, 'Dirty model should trigger event'); + assert.strictEqual(counter, 1, 'Dirty model should trigger event'); model.textEditorModel.setValue('bar'); - assert.equal(counter, 1, 'Another change does not fire event'); + assert.strictEqual(counter, 1, 'Another change does not fire event'); input.dispose(); model.dispose(); @@ -521,10 +521,10 @@ suite('Untitled text editors', () => { model.setEncoding('utf16'); - assert.equal(counter, 1, 'Dirty model should trigger event'); + assert.strictEqual(counter, 1, 'Dirty model should trigger event'); model.setEncoding('utf16'); - assert.equal(counter, 1, 'Another change to same encoding does not fire event'); + assert.strictEqual(counter, 1, 'Another change to same encoding does not fire event'); input.dispose(); model.dispose(); diff --git a/src/vs/workbench/services/workingCopy/test/browser/workingCopyFileService.test.ts b/src/vs/workbench/services/workingCopy/test/browser/workingCopyFileService.test.ts index 3ea04364e329f5e2c063468a4961a67ae79a2c99..09fe8d064e202ce99065d373e3e96d09fe376fd3 100644 --- a/src/vs/workbench/services/workingCopy/test/browser/workingCopyFileService.test.ts +++ b/src/vs/workbench/services/workingCopy/test/browser/workingCopyFileService.test.ts @@ -56,7 +56,7 @@ suite('WorkingCopyFileService', () => { const eventCounter = await testEventsMoveOrCopy([{ file: { source: sourceModel.resource, target: sourceModel.resource }, overwrite: true }], true); sourceModel.dispose(); - assert.equal(eventCounter, 3); + assert.strictEqual(eventCounter, 3); }); test('move - one source == target and another source != target', async function () { @@ -75,7 +75,7 @@ suite('WorkingCopyFileService', () => { sourceModel1.dispose(); sourceModel2.dispose(); targetModel2.dispose(); - assert.equal(eventCounter, 3); + assert.strictEqual(eventCounter, 3); }); test('move multiple - dirty file', async function () { @@ -100,7 +100,7 @@ suite('WorkingCopyFileService', () => { const eventCounter = await testEventsMoveOrCopy([{ file: { source: sourceModel.resource, target: sourceModel.resource }, overwrite: true }]); sourceModel.dispose(); - assert.equal(eventCounter, 3); + assert.strictEqual(eventCounter, 3); }); test('copy - one source == target and another source != target', async function () { @@ -119,7 +119,7 @@ suite('WorkingCopyFileService', () => { sourceModel1.dispose(); sourceModel2.dispose(); targetModel2.dispose(); - assert.equal(eventCounter, 3); + assert.strictEqual(eventCounter, 3); }); test('copy multiple - dirty file', async function () { @@ -142,24 +142,24 @@ suite('WorkingCopyFileService', () => { (accessor.textFileService.files).add(model2.resource, model2); let dirty = accessor.workingCopyFileService.getDirty(model1.resource); - assert.equal(dirty.length, 0); + assert.strictEqual(dirty.length, 0); await model1.load(); model1.textEditorModel!.setValue('foo'); dirty = accessor.workingCopyFileService.getDirty(model1.resource); - assert.equal(dirty.length, 1); - assert.equal(dirty[0], model1); + assert.strictEqual(dirty.length, 1); + assert.strictEqual(dirty[0], model1); dirty = accessor.workingCopyFileService.getDirty(toResource.call(this, '/path')); - assert.equal(dirty.length, 1); - assert.equal(dirty[0], model1); + assert.strictEqual(dirty.length, 1); + assert.strictEqual(dirty[0], model1); await model2.load(); model2.textEditorModel!.setValue('bar'); dirty = accessor.workingCopyFileService.getDirty(toResource.call(this, '/path')); - assert.equal(dirty.length, 2); + assert.strictEqual(dirty.length, 2); model1.dispose(); model2.dispose(); @@ -198,35 +198,35 @@ suite('WorkingCopyFileService', () => { const participant = accessor.workingCopyFileService.addFileOperationParticipant({ participate: async (files, operation) => { - assert.equal(files.length, 1); + assert.strictEqual(files.length, 1); const file = files[0]; - assert.equal(file.target.toString(), resource.toString()); - assert.equal(operation, FileOperation.CREATE); + assert.strictEqual(file.target.toString(), resource.toString()); + assert.strictEqual(operation, FileOperation.CREATE); eventCounter++; } }); const listener1 = accessor.workingCopyFileService.onWillRunWorkingCopyFileOperation(e => { - assert.equal(e.files.length, 1); + assert.strictEqual(e.files.length, 1); const file = e.files[0]; - assert.equal(file.target.toString(), resource.toString()); - assert.equal(e.operation, FileOperation.CREATE); + assert.strictEqual(file.target.toString(), resource.toString()); + assert.strictEqual(e.operation, FileOperation.CREATE); correlationId = e.correlationId; eventCounter++; }); const listener2 = accessor.workingCopyFileService.onDidRunWorkingCopyFileOperation(e => { - assert.equal(e.files.length, 1); + assert.strictEqual(e.files.length, 1); const file = e.files[0]; - assert.equal(file.target.toString(), resource.toString()); - assert.equal(e.operation, FileOperation.CREATE); - assert.equal(e.correlationId, correlationId); + assert.strictEqual(file.target.toString(), resource.toString()); + assert.strictEqual(e.operation, FileOperation.CREATE); + assert.strictEqual(e.correlationId, correlationId); eventCounter++; }); await accessor.workingCopyFileService.createFolder([{ resource }]); - assert.equal(eventCounter, 3); + assert.strictEqual(eventCounter, 3); participant.dispose(); listener1.dispose(); @@ -289,13 +289,13 @@ suite('WorkingCopyFileService', () => { const { target, source } = files[i]; const { targetModel, sourceModel } = models[i]; - assert.equal(target.toString(), targetModel.resource.toString()); - assert.equal(source?.toString(), sourceModel.resource.toString()); + assert.strictEqual(target.toString(), targetModel.resource.toString()); + assert.strictEqual(source?.toString(), sourceModel.resource.toString()); } eventCounter++; - assert.equal(operation, move ? FileOperation.MOVE : FileOperation.COPY); + assert.strictEqual(operation, move ? FileOperation.MOVE : FileOperation.COPY); } }); @@ -306,28 +306,28 @@ suite('WorkingCopyFileService', () => { const { target, source } = files[i]; const { targetModel, sourceModel } = models[i]; - assert.equal(target.toString(), targetModel.resource.toString()); - assert.equal(source?.toString(), sourceModel.resource.toString()); + assert.strictEqual(target.toString(), targetModel.resource.toString()); + assert.strictEqual(source?.toString(), sourceModel.resource.toString()); } eventCounter++; correlationId = e.correlationId; - assert.equal(e.operation, move ? FileOperation.MOVE : FileOperation.COPY); + assert.strictEqual(e.operation, move ? FileOperation.MOVE : FileOperation.COPY); }); const listener2 = accessor.workingCopyFileService.onDidRunWorkingCopyFileOperation(e => { for (let i = 0; i < e.files.length; i++) { const { target, source } = files[i]; const { targetModel, sourceModel } = models[i]; - assert.equal(target.toString(), targetModel.resource.toString()); - assert.equal(source?.toString(), sourceModel.resource.toString()); + assert.strictEqual(target.toString(), targetModel.resource.toString()); + assert.strictEqual(source?.toString(), sourceModel.resource.toString()); } eventCounter++; - assert.equal(e.operation, move ? FileOperation.MOVE : FileOperation.COPY); - assert.equal(e.correlationId, correlationId); + assert.strictEqual(e.operation, move ? FileOperation.MOVE : FileOperation.COPY); + assert.strictEqual(e.correlationId, correlationId); }); if (move) { @@ -339,7 +339,7 @@ suite('WorkingCopyFileService', () => { for (let i = 0; i < models.length; i++) { const { sourceModel, targetModel } = models[i]; - assert.equal(targetModel.textEditorModel!.getValue(), 'foo' + i); + assert.strictEqual(targetModel.textEditorModel!.getValue(), 'foo' + i); if (move) { assert.ok(!accessor.textFileService.isDirty(sourceModel.resource)); @@ -351,7 +351,7 @@ suite('WorkingCopyFileService', () => { sourceModel.dispose(); targetModel.dispose(); } - assert.equal(eventCounter, 3); + assert.strictEqual(eventCounter, 3); participant.dispose(); listener1.dispose(); @@ -378,9 +378,9 @@ suite('WorkingCopyFileService', () => { for (let i = 0; i < models.length; i++) { const model = models[i]; const file = files[i]; - assert.equal(file.target.toString(), model.resource.toString()); + assert.strictEqual(file.target.toString(), model.resource.toString()); } - assert.equal(operation, FileOperation.DELETE); + assert.strictEqual(operation, FileOperation.DELETE); eventCounter++; } }); @@ -389,9 +389,9 @@ suite('WorkingCopyFileService', () => { for (let i = 0; i < models.length; i++) { const model = models[i]; const file = e.files[i]; - assert.equal(file.target.toString(), model.resource.toString()); + assert.strictEqual(file.target.toString(), model.resource.toString()); } - assert.equal(e.operation, FileOperation.DELETE); + assert.strictEqual(e.operation, FileOperation.DELETE); correlationId = e.correlationId; eventCounter++; }); @@ -400,10 +400,10 @@ suite('WorkingCopyFileService', () => { for (let i = 0; i < models.length; i++) { const model = models[i]; const file = e.files[i]; - assert.equal(file.target.toString(), model.resource.toString()); + assert.strictEqual(file.target.toString(), model.resource.toString()); } - assert.equal(e.operation, FileOperation.DELETE); - assert.equal(e.correlationId, correlationId); + assert.strictEqual(e.operation, FileOperation.DELETE); + assert.strictEqual(e.correlationId, correlationId); eventCounter++; }); @@ -413,7 +413,7 @@ suite('WorkingCopyFileService', () => { model.dispose(); } - assert.equal(eventCounter, 3); + assert.strictEqual(eventCounter, 3); participant.dispose(); listener1.dispose(); @@ -433,29 +433,29 @@ suite('WorkingCopyFileService', () => { const participant = accessor.workingCopyFileService.addFileOperationParticipant({ participate: async (files, operation) => { - assert.equal(files.length, 1); + assert.strictEqual(files.length, 1); const file = files[0]; - assert.equal(file.target.toString(), model.resource.toString()); - assert.equal(operation, FileOperation.CREATE); + assert.strictEqual(file.target.toString(), model.resource.toString()); + assert.strictEqual(operation, FileOperation.CREATE); eventCounter++; } }); const listener1 = accessor.workingCopyFileService.onWillRunWorkingCopyFileOperation(e => { - assert.equal(e.files.length, 1); + assert.strictEqual(e.files.length, 1); const file = e.files[0]; - assert.equal(file.target.toString(), model.resource.toString()); - assert.equal(e.operation, FileOperation.CREATE); + assert.strictEqual(file.target.toString(), model.resource.toString()); + assert.strictEqual(e.operation, FileOperation.CREATE); correlationId = e.correlationId; eventCounter++; }); const listener2 = accessor.workingCopyFileService.onDidRunWorkingCopyFileOperation(e => { - assert.equal(e.files.length, 1); + assert.strictEqual(e.files.length, 1); const file = e.files[0]; - assert.equal(file.target.toString(), model.resource.toString()); - assert.equal(e.operation, FileOperation.CREATE); - assert.equal(e.correlationId, correlationId); + assert.strictEqual(file.target.toString(), model.resource.toString()); + assert.strictEqual(e.operation, FileOperation.CREATE); + assert.strictEqual(e.correlationId, correlationId); eventCounter++; }); @@ -463,7 +463,7 @@ suite('WorkingCopyFileService', () => { assert.ok(!accessor.workingCopyService.isDirty(model.resource)); model.dispose(); - assert.equal(eventCounter, 3); + assert.strictEqual(eventCounter, 3); participant.dispose(); listener1.dispose(); diff --git a/src/vs/workbench/services/workingCopy/test/common/workingCopyService.test.ts b/src/vs/workbench/services/workingCopy/test/common/workingCopyService.test.ts index df5f7b2e048ff95f374d268c3e1e45c80dd043ce..314cd18f96657ac9e6328c16871487c4d903a282 100644 --- a/src/vs/workbench/services/workingCopy/test/common/workingCopyService.test.ts +++ b/src/vs/workbench/services/workingCopy/test/common/workingCopyService.test.ts @@ -25,83 +25,83 @@ suite('WorkingCopyService', () => { const onDidUnregister: IWorkingCopy[] = []; service.onDidUnregister(copy => onDidUnregister.push(copy)); - assert.equal(service.hasDirty, false); - assert.equal(service.dirtyCount, 0); - assert.equal(service.workingCopies.length, 0); - assert.equal(service.isDirty(URI.file('/')), false); + assert.strictEqual(service.hasDirty, false); + assert.strictEqual(service.dirtyCount, 0); + assert.strictEqual(service.workingCopies.length, 0); + assert.strictEqual(service.isDirty(URI.file('/')), false); // resource 1 const resource1 = URI.file('/some/folder/file.txt'); const copy1 = new TestWorkingCopy(resource1); const unregister1 = service.registerWorkingCopy(copy1); - assert.equal(service.workingCopies.length, 1); - assert.equal(service.workingCopies[0], copy1); - assert.equal(onDidRegister.length, 1); - assert.equal(onDidRegister[0], copy1); - assert.equal(service.dirtyCount, 0); - assert.equal(service.isDirty(resource1), false); - assert.equal(service.hasDirty, false); + assert.strictEqual(service.workingCopies.length, 1); + assert.strictEqual(service.workingCopies[0], copy1); + assert.strictEqual(onDidRegister.length, 1); + assert.strictEqual(onDidRegister[0], copy1); + assert.strictEqual(service.dirtyCount, 0); + assert.strictEqual(service.isDirty(resource1), false); + assert.strictEqual(service.hasDirty, false); copy1.setDirty(true); - assert.equal(copy1.isDirty(), true); - assert.equal(service.dirtyCount, 1); - assert.equal(service.dirtyWorkingCopies.length, 1); - assert.equal(service.dirtyWorkingCopies[0], copy1); - assert.equal(service.workingCopies.length, 1); - assert.equal(service.workingCopies[0], copy1); - assert.equal(service.isDirty(resource1), true); - assert.equal(service.hasDirty, true); - assert.equal(onDidChangeDirty.length, 1); - assert.equal(onDidChangeDirty[0], copy1); + assert.strictEqual(copy1.isDirty(), true); + assert.strictEqual(service.dirtyCount, 1); + assert.strictEqual(service.dirtyWorkingCopies.length, 1); + assert.strictEqual(service.dirtyWorkingCopies[0], copy1); + assert.strictEqual(service.workingCopies.length, 1); + assert.strictEqual(service.workingCopies[0], copy1); + assert.strictEqual(service.isDirty(resource1), true); + assert.strictEqual(service.hasDirty, true); + assert.strictEqual(onDidChangeDirty.length, 1); + assert.strictEqual(onDidChangeDirty[0], copy1); copy1.setContent('foo'); - assert.equal(onDidChangeContent.length, 1); - assert.equal(onDidChangeContent[0], copy1); + assert.strictEqual(onDidChangeContent.length, 1); + assert.strictEqual(onDidChangeContent[0], copy1); copy1.setDirty(false); - assert.equal(service.dirtyCount, 0); - assert.equal(service.isDirty(resource1), false); - assert.equal(service.hasDirty, false); - assert.equal(onDidChangeDirty.length, 2); - assert.equal(onDidChangeDirty[1], copy1); + assert.strictEqual(service.dirtyCount, 0); + assert.strictEqual(service.isDirty(resource1), false); + assert.strictEqual(service.hasDirty, false); + assert.strictEqual(onDidChangeDirty.length, 2); + assert.strictEqual(onDidChangeDirty[1], copy1); unregister1.dispose(); - assert.equal(onDidUnregister.length, 1); - assert.equal(onDidUnregister[0], copy1); - assert.equal(service.workingCopies.length, 0); + assert.strictEqual(onDidUnregister.length, 1); + assert.strictEqual(onDidUnregister[0], copy1); + assert.strictEqual(service.workingCopies.length, 0); // resource 2 const resource2 = URI.file('/some/folder/file-dirty.txt'); const copy2 = new TestWorkingCopy(resource2, true); const unregister2 = service.registerWorkingCopy(copy2); - assert.equal(onDidRegister.length, 2); - assert.equal(onDidRegister[1], copy2); - assert.equal(service.dirtyCount, 1); - assert.equal(service.isDirty(resource2), true); - assert.equal(service.hasDirty, true); + assert.strictEqual(onDidRegister.length, 2); + assert.strictEqual(onDidRegister[1], copy2); + assert.strictEqual(service.dirtyCount, 1); + assert.strictEqual(service.isDirty(resource2), true); + assert.strictEqual(service.hasDirty, true); - assert.equal(onDidChangeDirty.length, 3); - assert.equal(onDidChangeDirty[2], copy2); + assert.strictEqual(onDidChangeDirty.length, 3); + assert.strictEqual(onDidChangeDirty[2], copy2); copy2.setContent('foo'); - assert.equal(onDidChangeContent.length, 2); - assert.equal(onDidChangeContent[1], copy2); + assert.strictEqual(onDidChangeContent.length, 2); + assert.strictEqual(onDidChangeContent[1], copy2); unregister2.dispose(); - assert.equal(onDidUnregister.length, 2); - assert.equal(onDidUnregister[1], copy2); - assert.equal(service.dirtyCount, 0); - assert.equal(service.hasDirty, false); - assert.equal(onDidChangeDirty.length, 4); - assert.equal(onDidChangeDirty[3], copy2); + assert.strictEqual(onDidUnregister.length, 2); + assert.strictEqual(onDidUnregister[1], copy2); + assert.strictEqual(service.dirtyCount, 0); + assert.strictEqual(service.hasDirty, false); + assert.strictEqual(onDidChangeDirty.length, 4); + assert.strictEqual(onDidChangeDirty[3], copy2); }); test('registry - multiple copies on same resource throws', () => { diff --git a/src/vs/workbench/test/browser/parts/editor/editor.test.ts b/src/vs/workbench/test/browser/parts/editor/editor.test.ts index 8ff03965ebdf92082a5de5102bdbba34ffa6c2dd..f968682156bfd398a9cdaac375b6da8f56ee0cf4 100644 --- a/src/vs/workbench/test/browser/parts/editor/editor.test.ts +++ b/src/vs/workbench/test/browser/parts/editor/editor.test.ts @@ -41,38 +41,38 @@ suite('Workbench editor', () => { const untitled = instantiationService.createInstance(UntitledTextEditorInput, service.create()); - assert.equal(EditorResourceAccessor.getCanonicalUri(untitled)!.toString(), untitled.resource.toString()); - assert.equal(EditorResourceAccessor.getCanonicalUri(untitled, { supportSideBySide: SideBySideEditor.PRIMARY })!.toString(), untitled.resource.toString()); - assert.equal(EditorResourceAccessor.getCanonicalUri(untitled, { supportSideBySide: SideBySideEditor.SECONDARY })!.toString(), untitled.resource.toString()); - assert.equal(EditorResourceAccessor.getCanonicalUri(untitled, { supportSideBySide: SideBySideEditor.BOTH })!.toString(), untitled.resource.toString()); - assert.equal(EditorResourceAccessor.getCanonicalUri(untitled, { filterByScheme: Schemas.untitled })!.toString(), untitled.resource.toString()); - assert.equal(EditorResourceAccessor.getCanonicalUri(untitled, { filterByScheme: [Schemas.file, Schemas.untitled] })!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(untitled)!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(untitled, { supportSideBySide: SideBySideEditor.PRIMARY })!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(untitled, { supportSideBySide: SideBySideEditor.SECONDARY })!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(untitled, { supportSideBySide: SideBySideEditor.BOTH })!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(untitled, { filterByScheme: Schemas.untitled })!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(untitled, { filterByScheme: [Schemas.file, Schemas.untitled] })!.toString(), untitled.resource.toString()); assert.ok(!EditorResourceAccessor.getCanonicalUri(untitled, { filterByScheme: Schemas.file })); - assert.equal(EditorResourceAccessor.getOriginalUri(untitled)!.toString(), untitled.resource.toString()); - assert.equal(EditorResourceAccessor.getOriginalUri(untitled, { supportSideBySide: SideBySideEditor.PRIMARY })!.toString(), untitled.resource.toString()); - assert.equal(EditorResourceAccessor.getOriginalUri(untitled, { supportSideBySide: SideBySideEditor.SECONDARY })!.toString(), untitled.resource.toString()); - assert.equal(EditorResourceAccessor.getOriginalUri(untitled, { supportSideBySide: SideBySideEditor.BOTH })!.toString(), untitled.resource.toString()); - assert.equal(EditorResourceAccessor.getOriginalUri(untitled, { filterByScheme: Schemas.untitled })!.toString(), untitled.resource.toString()); - assert.equal(EditorResourceAccessor.getOriginalUri(untitled, { filterByScheme: [Schemas.file, Schemas.untitled] })!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(untitled)!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(untitled, { supportSideBySide: SideBySideEditor.PRIMARY })!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(untitled, { supportSideBySide: SideBySideEditor.SECONDARY })!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(untitled, { supportSideBySide: SideBySideEditor.BOTH })!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(untitled, { filterByScheme: Schemas.untitled })!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(untitled, { filterByScheme: [Schemas.file, Schemas.untitled] })!.toString(), untitled.resource.toString()); assert.ok(!EditorResourceAccessor.getOriginalUri(untitled, { filterByScheme: Schemas.file })); const file = new TestEditorInput(URI.file('/some/path.txt'), 'editorResourceFileTest'); - assert.equal(EditorResourceAccessor.getCanonicalUri(file)!.toString(), file.resource.toString()); - assert.equal(EditorResourceAccessor.getCanonicalUri(file, { supportSideBySide: SideBySideEditor.PRIMARY })!.toString(), file.resource.toString()); - assert.equal(EditorResourceAccessor.getCanonicalUri(file, { supportSideBySide: SideBySideEditor.SECONDARY })!.toString(), file.resource.toString()); - assert.equal(EditorResourceAccessor.getCanonicalUri(file, { supportSideBySide: SideBySideEditor.BOTH })!.toString(), file.resource.toString()); - assert.equal(EditorResourceAccessor.getCanonicalUri(file, { filterByScheme: Schemas.file })!.toString(), file.resource.toString()); - assert.equal(EditorResourceAccessor.getCanonicalUri(file, { filterByScheme: [Schemas.file, Schemas.untitled] })!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(file)!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(file, { supportSideBySide: SideBySideEditor.PRIMARY })!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(file, { supportSideBySide: SideBySideEditor.SECONDARY })!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(file, { supportSideBySide: SideBySideEditor.BOTH })!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(file, { filterByScheme: Schemas.file })!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(file, { filterByScheme: [Schemas.file, Schemas.untitled] })!.toString(), file.resource.toString()); assert.ok(!EditorResourceAccessor.getCanonicalUri(file, { filterByScheme: Schemas.untitled })); - assert.equal(EditorResourceAccessor.getOriginalUri(file)!.toString(), file.resource.toString()); - assert.equal(EditorResourceAccessor.getOriginalUri(file, { supportSideBySide: SideBySideEditor.PRIMARY })!.toString(), file.resource.toString()); - assert.equal(EditorResourceAccessor.getOriginalUri(file, { supportSideBySide: SideBySideEditor.SECONDARY })!.toString(), file.resource.toString()); - assert.equal(EditorResourceAccessor.getOriginalUri(file, { supportSideBySide: SideBySideEditor.BOTH })!.toString(), file.resource.toString()); - assert.equal(EditorResourceAccessor.getOriginalUri(file, { filterByScheme: Schemas.file })!.toString(), file.resource.toString()); - assert.equal(EditorResourceAccessor.getOriginalUri(file, { filterByScheme: [Schemas.file, Schemas.untitled] })!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(file)!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(file, { supportSideBySide: SideBySideEditor.PRIMARY })!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(file, { supportSideBySide: SideBySideEditor.SECONDARY })!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(file, { supportSideBySide: SideBySideEditor.BOTH })!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(file, { filterByScheme: Schemas.file })!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(file, { filterByScheme: [Schemas.file, Schemas.untitled] })!.toString(), file.resource.toString()); assert.ok(!EditorResourceAccessor.getOriginalUri(file, { filterByScheme: Schemas.untitled })); const diffEditorInput = instantiationService.createInstance(DiffEditorInput, 'name', 'description', untitled, file, undefined); @@ -80,47 +80,47 @@ suite('Workbench editor', () => { assert.ok(!EditorResourceAccessor.getCanonicalUri(diffEditorInput)); assert.ok(!EditorResourceAccessor.getCanonicalUri(diffEditorInput, { filterByScheme: Schemas.file })); - assert.equal(EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.PRIMARY })!.toString(), file.resource.toString()); - assert.equal(EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.PRIMARY, filterByScheme: Schemas.file })!.toString(), file.resource.toString()); - assert.equal(EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.PRIMARY, filterByScheme: [Schemas.file, Schemas.untitled] })!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.PRIMARY })!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.PRIMARY, filterByScheme: Schemas.file })!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.PRIMARY, filterByScheme: [Schemas.file, Schemas.untitled] })!.toString(), file.resource.toString()); - assert.equal(EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.SECONDARY })!.toString(), untitled.resource.toString()); - assert.equal(EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.SECONDARY, filterByScheme: Schemas.untitled })!.toString(), untitled.resource.toString()); - assert.equal(EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.SECONDARY, filterByScheme: [Schemas.file, Schemas.untitled] })!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.SECONDARY })!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.SECONDARY, filterByScheme: Schemas.untitled })!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.SECONDARY, filterByScheme: [Schemas.file, Schemas.untitled] })!.toString(), untitled.resource.toString()); - assert.equal((EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH }) as { primary: URI, secondary: URI }).primary.toString(), file.resource.toString()); - assert.equal((EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH, filterByScheme: Schemas.file }) as { primary: URI, secondary: URI }).primary.toString(), file.resource.toString()); - assert.equal((EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH, filterByScheme: [Schemas.file, Schemas.untitled] }) as { primary: URI, secondary: URI }).primary.toString(), file.resource.toString()); + assert.strictEqual((EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH }) as { primary: URI, secondary: URI }).primary.toString(), file.resource.toString()); + assert.strictEqual((EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH, filterByScheme: Schemas.file }) as { primary: URI, secondary: URI }).primary.toString(), file.resource.toString()); + assert.strictEqual((EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH, filterByScheme: [Schemas.file, Schemas.untitled] }) as { primary: URI, secondary: URI }).primary.toString(), file.resource.toString()); - assert.equal((EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH }) as { primary: URI, secondary: URI }).secondary.toString(), untitled.resource.toString()); - assert.equal((EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH, filterByScheme: Schemas.untitled }) as { primary: URI, secondary: URI }).secondary.toString(), untitled.resource.toString()); - assert.equal((EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH, filterByScheme: [Schemas.file, Schemas.untitled] }) as { primary: URI, secondary: URI }).secondary.toString(), untitled.resource.toString()); + assert.strictEqual((EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH }) as { primary: URI, secondary: URI }).secondary.toString(), untitled.resource.toString()); + assert.strictEqual((EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH, filterByScheme: Schemas.untitled }) as { primary: URI, secondary: URI }).secondary.toString(), untitled.resource.toString()); + assert.strictEqual((EditorResourceAccessor.getCanonicalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH, filterByScheme: [Schemas.file, Schemas.untitled] }) as { primary: URI, secondary: URI }).secondary.toString(), untitled.resource.toString()); assert.ok(!EditorResourceAccessor.getOriginalUri(diffEditorInput)); assert.ok(!EditorResourceAccessor.getOriginalUri(diffEditorInput, { filterByScheme: Schemas.file })); - assert.equal(EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.PRIMARY })!.toString(), file.resource.toString()); - assert.equal(EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.PRIMARY, filterByScheme: Schemas.file })!.toString(), file.resource.toString()); - assert.equal(EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.PRIMARY, filterByScheme: [Schemas.file, Schemas.untitled] })!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.PRIMARY })!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.PRIMARY, filterByScheme: Schemas.file })!.toString(), file.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.PRIMARY, filterByScheme: [Schemas.file, Schemas.untitled] })!.toString(), file.resource.toString()); - assert.equal(EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.SECONDARY })!.toString(), untitled.resource.toString()); - assert.equal(EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.SECONDARY, filterByScheme: Schemas.untitled })!.toString(), untitled.resource.toString()); - assert.equal(EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.SECONDARY, filterByScheme: [Schemas.file, Schemas.untitled] })!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.SECONDARY })!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.SECONDARY, filterByScheme: Schemas.untitled })!.toString(), untitled.resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.SECONDARY, filterByScheme: [Schemas.file, Schemas.untitled] })!.toString(), untitled.resource.toString()); - assert.equal((EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH }) as { primary: URI, secondary: URI }).primary.toString(), file.resource.toString()); - assert.equal((EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH, filterByScheme: Schemas.file }) as { primary: URI, secondary: URI }).primary.toString(), file.resource.toString()); - assert.equal((EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH, filterByScheme: [Schemas.file, Schemas.untitled] }) as { primary: URI, secondary: URI }).primary.toString(), file.resource.toString()); + assert.strictEqual((EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH }) as { primary: URI, secondary: URI }).primary.toString(), file.resource.toString()); + assert.strictEqual((EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH, filterByScheme: Schemas.file }) as { primary: URI, secondary: URI }).primary.toString(), file.resource.toString()); + assert.strictEqual((EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH, filterByScheme: [Schemas.file, Schemas.untitled] }) as { primary: URI, secondary: URI }).primary.toString(), file.resource.toString()); - assert.equal((EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH }) as { primary: URI, secondary: URI }).secondary.toString(), untitled.resource.toString()); - assert.equal((EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH, filterByScheme: Schemas.untitled }) as { primary: URI, secondary: URI }).secondary.toString(), untitled.resource.toString()); - assert.equal((EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH, filterByScheme: [Schemas.file, Schemas.untitled] }) as { primary: URI, secondary: URI }).secondary.toString(), untitled.resource.toString()); + assert.strictEqual((EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH }) as { primary: URI, secondary: URI }).secondary.toString(), untitled.resource.toString()); + assert.strictEqual((EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH, filterByScheme: Schemas.untitled }) as { primary: URI, secondary: URI }).secondary.toString(), untitled.resource.toString()); + assert.strictEqual((EditorResourceAccessor.getOriginalUri(diffEditorInput, { supportSideBySide: SideBySideEditor.BOTH, filterByScheme: [Schemas.file, Schemas.untitled] }) as { primary: URI, secondary: URI }).secondary.toString(), untitled.resource.toString()); const resource = URI.file('/some/path.txt'); const preferredResource = URI.file('/some/PATH.txt'); const fileWithPreferredResource = new TestEditorInputWithPreferredResource(URI.file('/some/path.txt'), URI.file('/some/PATH.txt'), 'editorResourceFileTest'); - assert.equal(EditorResourceAccessor.getCanonicalUri(fileWithPreferredResource)?.toString(), resource.toString()); - assert.equal(EditorResourceAccessor.getOriginalUri(fileWithPreferredResource)?.toString(), preferredResource.toString()); + assert.strictEqual(EditorResourceAccessor.getCanonicalUri(fileWithPreferredResource)?.toString(), resource.toString()); + assert.strictEqual(EditorResourceAccessor.getOriginalUri(fileWithPreferredResource)?.toString(), preferredResource.toString()); }); }); diff --git a/src/vs/workbench/test/browser/parts/editor/editorGroups.test.ts b/src/vs/workbench/test/browser/parts/editor/editorGroups.test.ts index a75df3f3f87e931c4ccc7babc0f3bab9746a8f94..0eae911639d6b5267d1d8b88e0e814e3048c9944 100644 --- a/src/vs/workbench/test/browser/parts/editor/editorGroups.test.ts +++ b/src/vs/workbench/test/browser/parts/editor/editorGroups.test.ts @@ -253,25 +253,25 @@ suite('Workbench editor groups', () => { assert.ok(group.isSticky(input2)); const clone = group.clone(); - assert.notEqual(group.id, clone.id); - assert.equal(clone.count, 3); + assert.notStrictEqual(group.id, clone.id); + assert.strictEqual(clone.count, 3); let didEditorLabelChange = false; const toDispose = clone.onDidEditorLabelChange(() => didEditorLabelChange = true); input1.setLabel(); assert.ok(didEditorLabelChange); - assert.equal(clone.isPinned(input1), true); - assert.equal(clone.isActive(input1), false); - assert.equal(clone.isSticky(input1), false); + assert.strictEqual(clone.isPinned(input1), true); + assert.strictEqual(clone.isActive(input1), false); + assert.strictEqual(clone.isSticky(input1), false); - assert.equal(clone.isPinned(input2), true); - assert.equal(clone.isActive(input2), false); - assert.equal(clone.isSticky(input2), true); + assert.strictEqual(clone.isPinned(input2), true); + assert.strictEqual(clone.isActive(input2), false); + assert.strictEqual(clone.isSticky(input2), true); - assert.equal(clone.isPinned(input3), false); - assert.equal(clone.isActive(input3), true); - assert.equal(clone.isSticky(input3), false); + assert.strictEqual(clone.isPinned(input3), false); + assert.strictEqual(clone.isActive(input3), true); + assert.strictEqual(clone.isSticky(input3), false); toDispose.dispose(); }); @@ -288,82 +288,82 @@ suite('Workbench editor groups', () => { group.openEditor(input1, { pinned: true, active: true }); - assert.equal(group.contains(input1), true); - assert.equal(group.contains(input1, { strictEquals: true }), true); - assert.equal(group.contains(input1, { supportSideBySide: true }), true); - assert.equal(group.contains(input2), false); - assert.equal(group.contains(input2, { strictEquals: true }), false); - assert.equal(group.contains(input2, { supportSideBySide: true }), false); - assert.equal(group.contains(diffInput1), false); - assert.equal(group.contains(diffInput2), false); + assert.strictEqual(group.contains(input1), true); + assert.strictEqual(group.contains(input1, { strictEquals: true }), true); + assert.strictEqual(group.contains(input1, { supportSideBySide: true }), true); + assert.strictEqual(group.contains(input2), false); + assert.strictEqual(group.contains(input2, { strictEquals: true }), false); + assert.strictEqual(group.contains(input2, { supportSideBySide: true }), false); + assert.strictEqual(group.contains(diffInput1), false); + assert.strictEqual(group.contains(diffInput2), false); group.openEditor(input2, { pinned: true, active: true }); - assert.equal(group.contains(input1), true); - assert.equal(group.contains(input2), true); - assert.equal(group.contains(diffInput1), false); - assert.equal(group.contains(diffInput2), false); + assert.strictEqual(group.contains(input1), true); + assert.strictEqual(group.contains(input2), true); + assert.strictEqual(group.contains(diffInput1), false); + assert.strictEqual(group.contains(diffInput2), false); group.openEditor(diffInput1, { pinned: true, active: true }); - assert.equal(group.contains(input1), true); - assert.equal(group.contains(input2), true); - assert.equal(group.contains(diffInput1), true); - assert.equal(group.contains(diffInput2), false); + assert.strictEqual(group.contains(input1), true); + assert.strictEqual(group.contains(input2), true); + assert.strictEqual(group.contains(diffInput1), true); + assert.strictEqual(group.contains(diffInput2), false); group.openEditor(diffInput2, { pinned: true, active: true }); - assert.equal(group.contains(input1), true); - assert.equal(group.contains(input2), true); - assert.equal(group.contains(diffInput1), true); - assert.equal(group.contains(diffInput2), true); + assert.strictEqual(group.contains(input1), true); + assert.strictEqual(group.contains(input2), true); + assert.strictEqual(group.contains(diffInput1), true); + assert.strictEqual(group.contains(diffInput2), true); group.closeEditor(input1); - assert.equal(group.contains(input1), false); - assert.equal(group.contains(input1, { supportSideBySide: true }), true); - assert.equal(group.contains(input2), true); - assert.equal(group.contains(diffInput1), true); - assert.equal(group.contains(diffInput2), true); + assert.strictEqual(group.contains(input1), false); + assert.strictEqual(group.contains(input1, { supportSideBySide: true }), true); + assert.strictEqual(group.contains(input2), true); + assert.strictEqual(group.contains(diffInput1), true); + assert.strictEqual(group.contains(diffInput2), true); group.closeEditor(input2); - assert.equal(group.contains(input1), false); - assert.equal(group.contains(input1, { supportSideBySide: true }), true); - assert.equal(group.contains(input2), false); - assert.equal(group.contains(input2, { supportSideBySide: true }), true); - assert.equal(group.contains(diffInput1), true); - assert.equal(group.contains(diffInput2), true); + assert.strictEqual(group.contains(input1), false); + assert.strictEqual(group.contains(input1, { supportSideBySide: true }), true); + assert.strictEqual(group.contains(input2), false); + assert.strictEqual(group.contains(input2, { supportSideBySide: true }), true); + assert.strictEqual(group.contains(diffInput1), true); + assert.strictEqual(group.contains(diffInput2), true); group.closeEditor(diffInput1); - assert.equal(group.contains(input1), false); - assert.equal(group.contains(input1, { supportSideBySide: true }), true); - assert.equal(group.contains(input2), false); - assert.equal(group.contains(input2, { supportSideBySide: true }), true); - assert.equal(group.contains(diffInput1), false); - assert.equal(group.contains(diffInput2), true); + assert.strictEqual(group.contains(input1), false); + assert.strictEqual(group.contains(input1, { supportSideBySide: true }), true); + assert.strictEqual(group.contains(input2), false); + assert.strictEqual(group.contains(input2, { supportSideBySide: true }), true); + assert.strictEqual(group.contains(diffInput1), false); + assert.strictEqual(group.contains(diffInput2), true); group.closeEditor(diffInput2); - assert.equal(group.contains(input1), false); - assert.equal(group.contains(input1, { supportSideBySide: true }), false); - assert.equal(group.contains(input2), false); - assert.equal(group.contains(input2, { supportSideBySide: true }), false); - assert.equal(group.contains(diffInput1), false); - assert.equal(group.contains(diffInput2), false); + assert.strictEqual(group.contains(input1), false); + assert.strictEqual(group.contains(input1, { supportSideBySide: true }), false); + assert.strictEqual(group.contains(input2), false); + assert.strictEqual(group.contains(input2, { supportSideBySide: true }), false); + assert.strictEqual(group.contains(diffInput1), false); + assert.strictEqual(group.contains(diffInput2), false); const input3 = input(undefined, true, URI.parse('foo://bar')); const input4 = input(undefined, true, URI.parse('foo://barsomething')); group.openEditor(input3, { pinned: true, active: true }); - assert.equal(group.contains(input4), false); - assert.equal(group.contains(input3), true); + assert.strictEqual(group.contains(input4), false); + assert.strictEqual(group.contains(input3), true); group.closeEditor(input3); - assert.equal(group.contains(input3), false); + assert.strictEqual(group.contains(input3), false); }); test('group serialization', function () { @@ -381,33 +381,33 @@ suite('Workbench editor groups', () => { group.openEditor(input3, { pinned: false, active: true }); let deserialized = createGroup(group.serialize()); - assert.equal(group.id, deserialized.id); - assert.equal(deserialized.count, 3); - assert.equal(deserialized.getEditors(EditorsOrder.SEQUENTIAL).length, 3); - assert.equal(deserialized.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 3); - assert.equal(deserialized.isPinned(input1), true); - assert.equal(deserialized.isPinned(input2), true); - assert.equal(deserialized.isPinned(input3), false); - assert.equal(deserialized.isActive(input3), true); + assert.strictEqual(group.id, deserialized.id); + assert.strictEqual(deserialized.count, 3); + assert.strictEqual(deserialized.getEditors(EditorsOrder.SEQUENTIAL).length, 3); + assert.strictEqual(deserialized.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 3); + assert.strictEqual(deserialized.isPinned(input1), true); + assert.strictEqual(deserialized.isPinned(input2), true); + assert.strictEqual(deserialized.isPinned(input3), false); + assert.strictEqual(deserialized.isActive(input3), true); // Case 2: inputs cannot be serialized TestEditorInputFactory.disableSerialize = true; deserialized = createGroup(group.serialize()); - assert.equal(group.id, deserialized.id); - assert.equal(deserialized.count, 0); - assert.equal(deserialized.getEditors(EditorsOrder.SEQUENTIAL).length, 0); - assert.equal(deserialized.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); + assert.strictEqual(group.id, deserialized.id); + assert.strictEqual(deserialized.count, 0); + assert.strictEqual(deserialized.getEditors(EditorsOrder.SEQUENTIAL).length, 0); + assert.strictEqual(deserialized.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); // Case 3: inputs cannot be deserialized TestEditorInputFactory.disableSerialize = false; TestEditorInputFactory.disableDeserialize = true; deserialized = createGroup(group.serialize()); - assert.equal(group.id, deserialized.id); - assert.equal(deserialized.count, 0); - assert.equal(deserialized.getEditors(EditorsOrder.SEQUENTIAL).length, 0); - assert.equal(deserialized.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); + assert.strictEqual(group.id, deserialized.id); + assert.strictEqual(deserialized.count, 0); + assert.strictEqual(deserialized.getEditors(EditorsOrder.SEQUENTIAL).length, 0); + assert.strictEqual(deserialized.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); }); test('group serialization (sticky editor)', function () { @@ -428,152 +428,152 @@ suite('Workbench editor groups', () => { assert.ok(group.isSticky(input2)); let deserialized = createGroup(group.serialize()); - assert.equal(group.id, deserialized.id); - assert.equal(deserialized.count, 3); + assert.strictEqual(group.id, deserialized.id); + assert.strictEqual(deserialized.count, 3); - assert.equal(deserialized.isPinned(input1), true); - assert.equal(deserialized.isActive(input1), false); - assert.equal(deserialized.isSticky(input1), false); + assert.strictEqual(deserialized.isPinned(input1), true); + assert.strictEqual(deserialized.isActive(input1), false); + assert.strictEqual(deserialized.isSticky(input1), false); - assert.equal(deserialized.isPinned(input2), true); - assert.equal(deserialized.isActive(input2), false); - assert.equal(deserialized.isSticky(input2), true); + assert.strictEqual(deserialized.isPinned(input2), true); + assert.strictEqual(deserialized.isActive(input2), false); + assert.strictEqual(deserialized.isSticky(input2), true); - assert.equal(deserialized.isPinned(input3), false); - assert.equal(deserialized.isActive(input3), true); - assert.equal(deserialized.isSticky(input3), false); + assert.strictEqual(deserialized.isPinned(input3), false); + assert.strictEqual(deserialized.isActive(input3), true); + assert.strictEqual(deserialized.isSticky(input3), false); // Case 2: inputs cannot be serialized TestEditorInputFactory.disableSerialize = true; deserialized = createGroup(group.serialize()); - assert.equal(group.id, deserialized.id); - assert.equal(deserialized.count, 0); - assert.equal(deserialized.stickyCount, 0); - assert.equal(deserialized.getEditors(EditorsOrder.SEQUENTIAL).length, 0); - assert.equal(deserialized.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); + assert.strictEqual(group.id, deserialized.id); + assert.strictEqual(deserialized.count, 0); + assert.strictEqual(deserialized.stickyCount, 0); + assert.strictEqual(deserialized.getEditors(EditorsOrder.SEQUENTIAL).length, 0); + assert.strictEqual(deserialized.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); // Case 3: inputs cannot be deserialized TestEditorInputFactory.disableSerialize = false; TestEditorInputFactory.disableDeserialize = true; deserialized = createGroup(group.serialize()); - assert.equal(group.id, deserialized.id); - assert.equal(deserialized.count, 0); - assert.equal(deserialized.stickyCount, 0); - assert.equal(deserialized.getEditors(EditorsOrder.SEQUENTIAL).length, 0); - assert.equal(deserialized.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); + assert.strictEqual(group.id, deserialized.id); + assert.strictEqual(deserialized.count, 0); + assert.strictEqual(deserialized.stickyCount, 0); + assert.strictEqual(deserialized.getEditors(EditorsOrder.SEQUENTIAL).length, 0); + assert.strictEqual(deserialized.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); }); test('One Editor', function () { const group = createGroup(); const events = groupListener(group); - assert.equal(group.count, 0); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); + assert.strictEqual(group.count, 0); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); // Active && Pinned const input1 = input(); const { editor: openedEditor, isNew } = group.openEditor(input1, { active: true, pinned: true }); - assert.equal(openedEditor, input1); - assert.equal(isNew, true); + assert.strictEqual(openedEditor, input1); + assert.strictEqual(isNew, true); - assert.equal(group.count, 1); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 1); - assert.equal(group.activeEditor, input1); - assert.equal(group.isActive(input1), true); - assert.equal(group.isPinned(input1), true); - assert.equal(group.isPinned(0), true); + assert.strictEqual(group.count, 1); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 1); + assert.strictEqual(group.activeEditor, input1); + assert.strictEqual(group.isActive(input1), true); + assert.strictEqual(group.isPinned(input1), true); + assert.strictEqual(group.isPinned(0), true); - assert.equal(events.opened[0], input1); - assert.equal(events.activated[0], input1); + assert.strictEqual(events.opened[0], input1); + assert.strictEqual(events.activated[0], input1); let editor = group.closeEditor(input1); - assert.equal(editor, input1); - assert.equal(group.count, 0); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); - assert.equal(group.activeEditor, undefined); - assert.equal(events.closed[0].editor, input1); - assert.equal(events.closed[0].index, 0); - assert.equal(events.closed[0].replaced, false); + assert.strictEqual(editor, input1); + assert.strictEqual(group.count, 0); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); + assert.strictEqual(group.activeEditor, null); + assert.strictEqual(events.closed[0].editor, input1); + assert.strictEqual(events.closed[0].index, 0); + assert.strictEqual(events.closed[0].replaced, false); // Active && Preview const input2 = input(); group.openEditor(input2, { active: true, pinned: false }); - assert.equal(group.count, 1); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 1); - assert.equal(group.activeEditor, input2); - assert.equal(group.isActive(input2), true); - assert.equal(group.isPinned(input2), false); - assert.equal(group.isPinned(0), false); + assert.strictEqual(group.count, 1); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 1); + assert.strictEqual(group.activeEditor, input2); + assert.strictEqual(group.isActive(input2), true); + assert.strictEqual(group.isPinned(input2), false); + assert.strictEqual(group.isPinned(0), false); - assert.equal(events.opened[1], input2); - assert.equal(events.activated[1], input2); + assert.strictEqual(events.opened[1], input2); + assert.strictEqual(events.activated[1], input2); group.closeEditor(input2); - assert.equal(group.count, 0); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); - assert.equal(group.activeEditor, undefined); - assert.equal(events.closed[1].editor, input2); - assert.equal(events.closed[1].index, 0); - assert.equal(events.closed[1].replaced, false); + assert.strictEqual(group.count, 0); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); + assert.strictEqual(group.activeEditor, null); + assert.strictEqual(events.closed[1].editor, input2); + assert.strictEqual(events.closed[1].index, 0); + assert.strictEqual(events.closed[1].replaced, false); editor = group.closeEditor(input2); assert.ok(!editor); - assert.equal(group.count, 0); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); - assert.equal(group.activeEditor, undefined); - assert.equal(events.closed[1].editor, input2); + assert.strictEqual(group.count, 0); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); + assert.strictEqual(group.activeEditor, null); + assert.strictEqual(events.closed[1].editor, input2); // Nonactive && Pinned => gets active because its first editor const input3 = input(); group.openEditor(input3, { active: false, pinned: true }); - assert.equal(group.count, 1); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 1); - assert.equal(group.activeEditor, input3); - assert.equal(group.isActive(input3), true); - assert.equal(group.isPinned(input3), true); - assert.equal(group.isPinned(0), true); + assert.strictEqual(group.count, 1); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 1); + assert.strictEqual(group.activeEditor, input3); + assert.strictEqual(group.isActive(input3), true); + assert.strictEqual(group.isPinned(input3), true); + assert.strictEqual(group.isPinned(0), true); - assert.equal(events.opened[2], input3); - assert.equal(events.activated[2], input3); + assert.strictEqual(events.opened[2], input3); + assert.strictEqual(events.activated[2], input3); group.closeEditor(input3); - assert.equal(group.count, 0); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); - assert.equal(group.activeEditor, undefined); - assert.equal(events.closed[2].editor, input3); + assert.strictEqual(group.count, 0); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); + assert.strictEqual(group.activeEditor, null); + assert.strictEqual(events.closed[2].editor, input3); - assert.equal(events.opened[2], input3); - assert.equal(events.activated[2], input3); + assert.strictEqual(events.opened[2], input3); + assert.strictEqual(events.activated[2], input3); group.closeEditor(input3); - assert.equal(group.count, 0); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); - assert.equal(group.activeEditor, undefined); - assert.equal(events.closed[2].editor, input3); + assert.strictEqual(group.count, 0); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); + assert.strictEqual(group.activeEditor, null); + assert.strictEqual(events.closed[2].editor, input3); // Nonactive && Preview => gets active because its first editor const input4 = input(); group.openEditor(input4); - assert.equal(group.count, 1); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 1); - assert.equal(group.activeEditor, input4); - assert.equal(group.isActive(input4), true); - assert.equal(group.isPinned(input4), false); - assert.equal(group.isPinned(0), false); + assert.strictEqual(group.count, 1); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 1); + assert.strictEqual(group.activeEditor, input4); + assert.strictEqual(group.isActive(input4), true); + assert.strictEqual(group.isPinned(input4), false); + assert.strictEqual(group.isPinned(0), false); - assert.equal(events.opened[3], input4); - assert.equal(events.activated[3], input4); + assert.strictEqual(events.opened[3], input4); + assert.strictEqual(events.activated[3], input4); group.closeEditor(input4); - assert.equal(group.count, 0); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); - assert.equal(group.activeEditor, undefined); - assert.equal(events.closed[3].editor, input4); + assert.strictEqual(group.count, 0); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 0); + assert.strictEqual(group.activeEditor, null); + assert.strictEqual(events.closed[3].editor, input4); }); test('Multiple Editors - Pinned and Active', function () { @@ -587,67 +587,67 @@ suite('Workbench editor groups', () => { // Pinned and Active let openedEditorResult = group.openEditor(input1, { pinned: true, active: true }); - assert.equal(openedEditorResult.editor, input1); - assert.equal(openedEditorResult.isNew, true); + assert.strictEqual(openedEditorResult.editor, input1); + assert.strictEqual(openedEditorResult.isNew, true); openedEditorResult = group.openEditor(input1Copy, { pinned: true, active: true }); // opening copy of editor should still return existing one - assert.equal(openedEditorResult.editor, input1); - assert.equal(openedEditorResult.isNew, false); + assert.strictEqual(openedEditorResult.editor, input1); + assert.strictEqual(openedEditorResult.isNew, false); group.openEditor(input2, { pinned: true, active: true }); group.openEditor(input3, { pinned: true, active: true }); - assert.equal(group.count, 3); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 3); - assert.equal(group.activeEditor, input3); - assert.equal(group.isActive(input1), false); - assert.equal(group.isPinned(input1), true); - assert.equal(group.isActive(input2), false); - assert.equal(group.isPinned(input2), true); - assert.equal(group.isActive(input3), true); - assert.equal(group.isPinned(input3), true); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 3); + assert.strictEqual(group.activeEditor, input3); + assert.strictEqual(group.isActive(input1), false); + assert.strictEqual(group.isPinned(input1), true); + assert.strictEqual(group.isActive(input2), false); + assert.strictEqual(group.isPinned(input2), true); + assert.strictEqual(group.isActive(input3), true); + assert.strictEqual(group.isPinned(input3), true); - assert.equal(events.opened[0], input1); - assert.equal(events.opened[1], input2); - assert.equal(events.opened[2], input3); + assert.strictEqual(events.opened[0], input1); + assert.strictEqual(events.opened[1], input2); + assert.strictEqual(events.opened[2], input3); - assert.equal(events.activated[0], input1); - assert.equal(events.activated[1], input2); - assert.equal(events.activated[2], input3); + assert.strictEqual(events.activated[0], input1); + assert.strictEqual(events.activated[1], input2); + assert.strictEqual(events.activated[2], input3); const mru = group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE); - assert.equal(mru[0], input3); - assert.equal(mru[1], input2); - assert.equal(mru[2], input1); + assert.strictEqual(mru[0], input3); + assert.strictEqual(mru[1], input2); + assert.strictEqual(mru[2], input1); // Add some tests where a matching input is used // and verify that events carry the original input const sameInput1 = input('1'); group.openEditor(sameInput1, { pinned: true, active: true }); - assert.equal(events.activated[3], input1); + assert.strictEqual(events.activated[3], input1); group.unpin(sameInput1); - assert.equal(events.unpinned[0], input1); + assert.strictEqual(events.unpinned[0], input1); group.pin(sameInput1); - assert.equal(events.pinned[0], input1); + assert.strictEqual(events.pinned[0], input1); group.stick(sameInput1); - assert.equal(events.sticky[0], input1); + assert.strictEqual(events.sticky[0], input1); group.unstick(sameInput1); - assert.equal(events.unsticky[0], input1); + assert.strictEqual(events.unsticky[0], input1); group.moveEditor(sameInput1, 1); - assert.equal(events.moved[0], input1); + assert.strictEqual(events.moved[0], input1); group.closeEditor(sameInput1); - assert.equal(events.closed[0].editor, input1); + assert.strictEqual(events.closed[0].editor, input1); closeAllEditors(group); - assert.equal(events.closed.length, 3); - assert.equal(group.count, 0); + assert.strictEqual(events.closed.length, 3); + assert.strictEqual(group.count, 0); }); test('Multiple Editors - Preview editor moves to the side of the active one', function () { @@ -661,12 +661,12 @@ suite('Workbench editor groups', () => { group.openEditor(input2, { pinned: true, active: true }); group.openEditor(input3, { pinned: true, active: true }); - assert.equal(input3, group.getEditors(EditorsOrder.SEQUENTIAL)[2]); + assert.strictEqual(input3, group.getEditors(EditorsOrder.SEQUENTIAL)[2]); const input4 = input(); group.openEditor(input4, { pinned: false, active: true }); // this should cause the preview editor to move after input3 - assert.equal(input4, group.getEditors(EditorsOrder.SEQUENTIAL)[2]); + assert.strictEqual(input4, group.getEditors(EditorsOrder.SEQUENTIAL)[2]); }); test('Multiple Editors - Pinned and Active (DEFAULT_OPEN_EDITOR_DIRECTION = Direction.LEFT)', function () { @@ -693,14 +693,14 @@ suite('Workbench editor groups', () => { group.openEditor(input2, { pinned: true, active: true }); group.openEditor(input3, { pinned: true, active: true }); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input3); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input2); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[2], input1); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input3); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input2); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[2], input1); closeAllEditors(group); - assert.equal(events.closed.length, 3); - assert.equal(group.count, 0); + assert.strictEqual(events.closed.length, 3); + assert.strictEqual(group.count, 0); }); test('Multiple Editors - Pinned and Not Active', function () { @@ -715,24 +715,24 @@ suite('Workbench editor groups', () => { group.openEditor(input2, { pinned: true }); group.openEditor(input3, { pinned: true }); - assert.equal(group.count, 3); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 3); - assert.equal(group.activeEditor, input1); - assert.equal(group.isActive(input1), true); - assert.equal(group.isPinned(input1), true); - assert.equal(group.isPinned(0), true); - assert.equal(group.isActive(input2), false); - assert.equal(group.isPinned(input2), true); - assert.equal(group.isPinned(1), true); - assert.equal(group.isActive(input3), false); - assert.equal(group.isPinned(input3), true); - assert.equal(group.isPinned(2), true); - assert.equal(group.isPinned(input3), true); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 3); + assert.strictEqual(group.activeEditor, input1); + assert.strictEqual(group.isActive(input1), true); + assert.strictEqual(group.isPinned(input1), true); + assert.strictEqual(group.isPinned(0), true); + assert.strictEqual(group.isActive(input2), false); + assert.strictEqual(group.isPinned(input2), true); + assert.strictEqual(group.isPinned(1), true); + assert.strictEqual(group.isActive(input3), false); + assert.strictEqual(group.isPinned(input3), true); + assert.strictEqual(group.isPinned(2), true); + assert.strictEqual(group.isPinned(input3), true); const mru = group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE); - assert.equal(mru[0], input1); - assert.equal(mru[1], input3); - assert.equal(mru[2], input2); + assert.strictEqual(mru[0], input1); + assert.strictEqual(mru[1], input3); + assert.strictEqual(mru[2], input2); }); test('Multiple Editors - Preview gets overwritten', function () { @@ -748,24 +748,24 @@ suite('Workbench editor groups', () => { group.openEditor(input2); // overwrites preview group.openEditor(input3); // overwrites preview - assert.equal(group.count, 1); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 1); - assert.equal(group.activeEditor, input3); - assert.equal(group.isActive(input3), true); - assert.equal(group.isPinned(input3), false); - assert.equal(!group.isPinned(input3), true); - - assert.equal(events.opened[0], input1); - assert.equal(events.opened[1], input2); - assert.equal(events.opened[2], input3); - assert.equal(events.closed[0].editor, input1); - assert.equal(events.closed[1].editor, input2); - assert.equal(events.closed[0].replaced, true); - assert.equal(events.closed[1].replaced, true); + assert.strictEqual(group.count, 1); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 1); + assert.strictEqual(group.activeEditor, input3); + assert.strictEqual(group.isActive(input3), true); + assert.strictEqual(group.isPinned(input3), false); + assert.strictEqual(!group.isPinned(input3), true); + + assert.strictEqual(events.opened[0], input1); + assert.strictEqual(events.opened[1], input2); + assert.strictEqual(events.opened[2], input3); + assert.strictEqual(events.closed[0].editor, input1); + assert.strictEqual(events.closed[1].editor, input2); + assert.strictEqual(events.closed[0].replaced, true); + assert.strictEqual(events.closed[1].replaced, true); const mru = group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE); - assert.equal(mru[0], input3); - assert.equal(mru.length, 1); + assert.strictEqual(mru[0], input3); + assert.strictEqual(mru.length, 1); }); test('Multiple Editors - set active', function () { @@ -780,27 +780,27 @@ suite('Workbench editor groups', () => { group.openEditor(input2, { pinned: true, active: true }); group.openEditor(input3, { pinned: false, active: true }); - assert.equal(group.activeEditor, input3); + assert.strictEqual(group.activeEditor, input3); let mru = group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE); - assert.equal(mru[0], input3); - assert.equal(mru[1], input2); - assert.equal(mru[2], input1); + assert.strictEqual(mru[0], input3); + assert.strictEqual(mru[1], input2); + assert.strictEqual(mru[2], input1); group.setActive(input3); - assert.equal(events.activated.length, 3); + assert.strictEqual(events.activated.length, 3); group.setActive(input1); - assert.equal(events.activated[3], input1); - assert.equal(group.activeEditor, input1); - assert.equal(group.isActive(input1), true); - assert.equal(group.isActive(input2), false); - assert.equal(group.isActive(input3), false); + assert.strictEqual(events.activated[3], input1); + assert.strictEqual(group.activeEditor, input1); + assert.strictEqual(group.isActive(input1), true); + assert.strictEqual(group.isActive(input2), false); + assert.strictEqual(group.isActive(input3), false); mru = group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE); - assert.equal(mru[0], input1); - assert.equal(mru[1], input3); - assert.equal(mru[2], input2); + assert.strictEqual(mru[0], input1); + assert.strictEqual(mru[1], input3); + assert.strictEqual(mru[2], input2); }); test('Multiple Editors - pin and unpin', function () { @@ -815,41 +815,41 @@ suite('Workbench editor groups', () => { group.openEditor(input2, { pinned: true, active: true }); group.openEditor(input3, { pinned: false, active: true }); - assert.equal(group.activeEditor, input3); - assert.equal(group.count, 3); + assert.strictEqual(group.activeEditor, input3); + assert.strictEqual(group.count, 3); group.pin(input3); - assert.equal(group.activeEditor, input3); - assert.equal(group.isPinned(input3), true); - assert.equal(group.isActive(input3), true); - assert.equal(events.pinned[0], input3); - assert.equal(group.count, 3); + assert.strictEqual(group.activeEditor, input3); + assert.strictEqual(group.isPinned(input3), true); + assert.strictEqual(group.isActive(input3), true); + assert.strictEqual(events.pinned[0], input3); + assert.strictEqual(group.count, 3); group.unpin(input1); - assert.equal(group.activeEditor, input3); - assert.equal(group.isPinned(input1), false); - assert.equal(group.isActive(input1), false); - assert.equal(events.unpinned[0], input1); - assert.equal(group.count, 3); + assert.strictEqual(group.activeEditor, input3); + assert.strictEqual(group.isPinned(input1), false); + assert.strictEqual(group.isActive(input1), false); + assert.strictEqual(events.unpinned[0], input1); + assert.strictEqual(group.count, 3); group.unpin(input2); - assert.equal(group.activeEditor, input3); - assert.equal(group.count, 2); // 2 previews got merged into one - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input2); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input3); - assert.equal(events.closed[0].editor, input1); - assert.equal(group.count, 2); + assert.strictEqual(group.activeEditor, input3); + assert.strictEqual(group.count, 2); // 2 previews got merged into one + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input2); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input3); + assert.strictEqual(events.closed[0].editor, input1); + assert.strictEqual(group.count, 2); group.unpin(input3); - assert.equal(group.activeEditor, input3); - assert.equal(group.count, 1); // pinning replaced the preview - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input3); - assert.equal(events.closed[1].editor, input2); - assert.equal(group.count, 1); + assert.strictEqual(group.activeEditor, input3); + assert.strictEqual(group.count, 1); // pinning replaced the preview + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input3); + assert.strictEqual(events.closed[1].editor, input2); + assert.strictEqual(group.count, 1); }); test('Multiple Editors - closing picks next from MRU list', function () { @@ -868,37 +868,37 @@ suite('Workbench editor groups', () => { group.openEditor(input4, { pinned: true, active: true }); group.openEditor(input5, { pinned: true, active: true }); - assert.equal(group.activeEditor, input5); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0], input5); - assert.equal(group.count, 5); + assert.strictEqual(group.activeEditor, input5); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0], input5); + assert.strictEqual(group.count, 5); group.closeEditor(input5); - assert.equal(group.activeEditor, input4); - assert.equal(events.activated[5], input4); - assert.equal(group.count, 4); + assert.strictEqual(group.activeEditor, input4); + assert.strictEqual(events.activated[5], input4); + assert.strictEqual(group.count, 4); group.setActive(input1); group.setActive(input4); group.closeEditor(input4); - assert.equal(group.activeEditor, input1); - assert.equal(group.count, 3); + assert.strictEqual(group.activeEditor, input1); + assert.strictEqual(group.count, 3); group.closeEditor(input1); - assert.equal(group.activeEditor, input3); - assert.equal(group.count, 2); + assert.strictEqual(group.activeEditor, input3); + assert.strictEqual(group.count, 2); group.setActive(input2); group.closeEditor(input2); - assert.equal(group.activeEditor, input3); - assert.equal(group.count, 1); + assert.strictEqual(group.activeEditor, input3); + assert.strictEqual(group.count, 1); group.closeEditor(input3); assert.ok(!group.activeEditor); - assert.equal(group.count, 0); + assert.strictEqual(group.count, 0); }); test('Multiple Editors - closing picks next to the right', function () { @@ -927,36 +927,36 @@ suite('Workbench editor groups', () => { group.openEditor(input4, { pinned: true, active: true }); group.openEditor(input5, { pinned: true, active: true }); - assert.equal(group.activeEditor, input5); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0], input5); - assert.equal(group.count, 5); + assert.strictEqual(group.activeEditor, input5); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0], input5); + assert.strictEqual(group.count, 5); group.closeEditor(input5); - assert.equal(group.activeEditor, input4); - assert.equal(events.activated[5], input4); - assert.equal(group.count, 4); + assert.strictEqual(group.activeEditor, input4); + assert.strictEqual(events.activated[5], input4); + assert.strictEqual(group.count, 4); group.setActive(input1); group.closeEditor(input1); - assert.equal(group.activeEditor, input2); - assert.equal(group.count, 3); + assert.strictEqual(group.activeEditor, input2); + assert.strictEqual(group.count, 3); group.setActive(input3); group.closeEditor(input3); - assert.equal(group.activeEditor, input4); - assert.equal(group.count, 2); + assert.strictEqual(group.activeEditor, input4); + assert.strictEqual(group.count, 2); group.closeEditor(input4); - assert.equal(group.activeEditor, input2); - assert.equal(group.count, 1); + assert.strictEqual(group.activeEditor, input2); + assert.strictEqual(group.count, 1); group.closeEditor(input2); assert.ok(!group.activeEditor); - assert.equal(group.count, 0); + assert.strictEqual(group.count, 0); }); test('Multiple Editors - move editor', function () { @@ -974,9 +974,9 @@ suite('Workbench editor groups', () => { group.moveEditor(input1, 1); - assert.equal(events.moved[0], input1); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input2); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input1); + assert.strictEqual(events.moved[0], input1); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input2); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input1); group.setActive(input1); group.openEditor(input3, { pinned: true, active: true }); @@ -985,40 +985,40 @@ suite('Workbench editor groups', () => { group.moveEditor(input4, 0); - assert.equal(events.moved[1], input4); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input4); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input2); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[2], input1); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[3], input3); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[4], input5); + assert.strictEqual(events.moved[1], input4); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input4); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input2); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[2], input1); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[3], input3); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[4], input5); group.moveEditor(input4, 3); group.moveEditor(input2, 1); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input1); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input2); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[2], input3); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[3], input4); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[4], input5); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input1); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input2); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[2], input3); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[3], input4); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[4], input5); - assert.equal(events.moved.length, 4); + assert.strictEqual(events.moved.length, 4); group.moveEditor(input1, 0); - assert.equal(events.moved.length, 4); + assert.strictEqual(events.moved.length, 4); group.moveEditor(input1, -1); - assert.equal(events.moved.length, 4); + assert.strictEqual(events.moved.length, 4); group.moveEditor(input5, 4); - assert.equal(events.moved.length, 4); + assert.strictEqual(events.moved.length, 4); group.moveEditor(input5, 100); - assert.equal(events.moved.length, 4); + assert.strictEqual(events.moved.length, 4); group.moveEditor(input5, -1); - assert.equal(events.moved.length, 5); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input5); + assert.strictEqual(events.moved.length, 5); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input5); group.moveEditor(input1, 100); - assert.equal(events.moved.length, 6); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[4], input1); + assert.strictEqual(events.moved.length, 6); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[4], input1); }); test('Multiple Editors - move editor across groups', function () { @@ -1037,10 +1037,10 @@ suite('Workbench editor groups', () => { group2.closeEditor(g2_input1); group1.openEditor(g2_input1, { active: true, pinned: true, index: 1 }); - assert.equal(group1.count, 3); - assert.equal(group1.getEditors(EditorsOrder.SEQUENTIAL)[0], g1_input1); - assert.equal(group1.getEditors(EditorsOrder.SEQUENTIAL)[1], g2_input1); - assert.equal(group1.getEditors(EditorsOrder.SEQUENTIAL)[2], g1_input2); + assert.strictEqual(group1.count, 3); + assert.strictEqual(group1.getEditors(EditorsOrder.SEQUENTIAL)[0], g1_input1); + assert.strictEqual(group1.getEditors(EditorsOrder.SEQUENTIAL)[1], g2_input1); + assert.strictEqual(group1.getEditors(EditorsOrder.SEQUENTIAL)[2], g1_input2); }); test('Multiple Editors - move editor across groups (input already exists in group 1)', function () { @@ -1061,10 +1061,10 @@ suite('Workbench editor groups', () => { group2.closeEditor(g2_input1); group1.openEditor(g2_input1, { active: true, pinned: true, index: 0 }); - assert.equal(group1.count, 3); - assert.equal(group1.getEditors(EditorsOrder.SEQUENTIAL)[0], g1_input2); - assert.equal(group1.getEditors(EditorsOrder.SEQUENTIAL)[1], g1_input1); - assert.equal(group1.getEditors(EditorsOrder.SEQUENTIAL)[2], g1_input3); + assert.strictEqual(group1.count, 3); + assert.strictEqual(group1.getEditors(EditorsOrder.SEQUENTIAL)[0], g1_input2); + assert.strictEqual(group1.getEditors(EditorsOrder.SEQUENTIAL)[1], g1_input1); + assert.strictEqual(group1.getEditors(EditorsOrder.SEQUENTIAL)[2], g1_input3); }); test('Multiple Editors - Pinned & Non Active', function () { @@ -1072,30 +1072,30 @@ suite('Workbench editor groups', () => { const input1 = input(); group.openEditor(input1); - assert.equal(group.activeEditor, input1); - assert.equal(group.previewEditor, input1); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input1); - assert.equal(group.count, 1); + assert.strictEqual(group.activeEditor, input1); + assert.strictEqual(group.previewEditor, input1); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input1); + assert.strictEqual(group.count, 1); const input2 = input(); group.openEditor(input2, { pinned: true, active: false }); - assert.equal(group.activeEditor, input1); - assert.equal(group.previewEditor, input1); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input1); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input2); - assert.equal(group.count, 2); + assert.strictEqual(group.activeEditor, input1); + assert.strictEqual(group.previewEditor, input1); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input1); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input2); + assert.strictEqual(group.count, 2); const input3 = input(); group.openEditor(input3, { pinned: true, active: false }); - assert.equal(group.activeEditor, input1); - assert.equal(group.previewEditor, input1); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input1); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input3); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[2], input2); - assert.equal(group.isPinned(input1), false); - assert.equal(group.isPinned(input2), true); - assert.equal(group.isPinned(input3), true); - assert.equal(group.count, 3); + assert.strictEqual(group.activeEditor, input1); + assert.strictEqual(group.previewEditor, input1); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input1); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input3); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[2], input2); + assert.strictEqual(group.isPinned(input1), false); + assert.strictEqual(group.isPinned(input2), true); + assert.strictEqual(group.isPinned(input3), true); + assert.strictEqual(group.count, 3); }); test('Multiple Editors - Close Others, Close Left, Close Right', function () { @@ -1115,8 +1115,8 @@ suite('Workbench editor groups', () => { // Close Others closeEditors(group, group.activeEditor!); - assert.equal(group.activeEditor, input5); - assert.equal(group.count, 1); + assert.strictEqual(group.activeEditor, input5); + assert.strictEqual(group.count, 1); closeAllEditors(group); group.openEditor(input1, { active: true, pinned: true }); @@ -1127,13 +1127,13 @@ suite('Workbench editor groups', () => { group.setActive(input3); // Close Left - assert.equal(group.activeEditor, input3); + assert.strictEqual(group.activeEditor, input3); closeEditors(group, group.activeEditor!, CloseDirection.LEFT); - assert.equal(group.activeEditor, input3); - assert.equal(group.count, 3); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input3); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input4); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[2], input5); + assert.strictEqual(group.activeEditor, input3); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input3); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input4); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[2], input5); closeAllEditors(group); group.openEditor(input1, { active: true, pinned: true }); @@ -1144,13 +1144,13 @@ suite('Workbench editor groups', () => { group.setActive(input3); // Close Right - assert.equal(group.activeEditor, input3); + assert.strictEqual(group.activeEditor, input3); closeEditors(group, group.activeEditor!, CloseDirection.RIGHT); - assert.equal(group.activeEditor, input3); - assert.equal(group.count, 3); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input1); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input2); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[2], input3); + assert.strictEqual(group.activeEditor, input3); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[0], input1); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[1], input2); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[2], input3); }); test('Multiple Editors - real user example', function () { @@ -1159,118 +1159,118 @@ suite('Workbench editor groups', () => { // [] -> /index.html/ const indexHtml = input('index.html'); let openedEditor = group.openEditor(indexHtml).editor; - assert.equal(openedEditor, indexHtml); - assert.equal(group.activeEditor, indexHtml); - assert.equal(group.previewEditor, indexHtml); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[0], indexHtml); - assert.equal(group.count, 1); + assert.strictEqual(openedEditor, indexHtml); + assert.strictEqual(group.activeEditor, indexHtml); + assert.strictEqual(group.previewEditor, indexHtml); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[0], indexHtml); + assert.strictEqual(group.count, 1); // /index.html/ -> /index.html/ const sameIndexHtml = input('index.html'); openedEditor = group.openEditor(sameIndexHtml).editor; - assert.equal(openedEditor, indexHtml); - assert.equal(group.activeEditor, indexHtml); - assert.equal(group.previewEditor, indexHtml); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[0], indexHtml); - assert.equal(group.count, 1); + assert.strictEqual(openedEditor, indexHtml); + assert.strictEqual(group.activeEditor, indexHtml); + assert.strictEqual(group.previewEditor, indexHtml); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[0], indexHtml); + assert.strictEqual(group.count, 1); // /index.html/ -> /style.css/ const styleCss = input('style.css'); openedEditor = group.openEditor(styleCss).editor; - assert.equal(openedEditor, styleCss); - assert.equal(group.activeEditor, styleCss); - assert.equal(group.previewEditor, styleCss); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[0], styleCss); - assert.equal(group.count, 1); + assert.strictEqual(openedEditor, styleCss); + assert.strictEqual(group.activeEditor, styleCss); + assert.strictEqual(group.previewEditor, styleCss); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[0], styleCss); + assert.strictEqual(group.count, 1); // /style.css/ -> [/style.css/, test.js] const testJs = input('test.js'); openedEditor = group.openEditor(testJs, { active: true, pinned: true }).editor; - assert.equal(openedEditor, testJs); - assert.equal(group.previewEditor, styleCss); - assert.equal(group.activeEditor, testJs); - assert.equal(group.isPinned(styleCss), false); - assert.equal(group.isPinned(testJs), true); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[0], styleCss); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[1], testJs); - assert.equal(group.count, 2); + assert.strictEqual(openedEditor, testJs); + assert.strictEqual(group.previewEditor, styleCss); + assert.strictEqual(group.activeEditor, testJs); + assert.strictEqual(group.isPinned(styleCss), false); + assert.strictEqual(group.isPinned(testJs), true); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[0], styleCss); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[1], testJs); + assert.strictEqual(group.count, 2); // [/style.css/, test.js] -> [test.js, /index.html/] const indexHtml2 = input('index.html'); group.openEditor(indexHtml2, { active: true }); - assert.equal(group.activeEditor, indexHtml2); - assert.equal(group.previewEditor, indexHtml2); - assert.equal(group.isPinned(indexHtml2), false); - assert.equal(group.isPinned(testJs), true); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[0], testJs); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[1], indexHtml2); - assert.equal(group.count, 2); + assert.strictEqual(group.activeEditor, indexHtml2); + assert.strictEqual(group.previewEditor, indexHtml2); + assert.strictEqual(group.isPinned(indexHtml2), false); + assert.strictEqual(group.isPinned(testJs), true); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[0], testJs); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[1], indexHtml2); + assert.strictEqual(group.count, 2); // make test.js active const testJs2 = input('test.js'); group.setActive(testJs2); - assert.equal(group.activeEditor, testJs); - assert.equal(group.isActive(testJs2), true); - assert.equal(group.count, 2); + assert.strictEqual(group.activeEditor, testJs); + assert.strictEqual(group.isActive(testJs2), true); + assert.strictEqual(group.count, 2); // [test.js, /indexHtml/] -> [test.js, index.html] const indexHtml3 = input('index.html'); group.pin(indexHtml3); - assert.equal(group.isPinned(indexHtml3), true); - assert.equal(group.activeEditor, testJs); + assert.strictEqual(group.isPinned(indexHtml3), true); + assert.strictEqual(group.activeEditor, testJs); // [test.js, index.html] -> [test.js, file.ts, index.html] const fileTs = input('file.ts'); group.openEditor(fileTs, { active: true, pinned: true }); - assert.equal(group.isPinned(fileTs), true); - assert.equal(group.count, 3); - assert.equal(group.activeEditor, fileTs); + assert.strictEqual(group.isPinned(fileTs), true); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.activeEditor, fileTs); // [test.js, index.html, file.ts] -> [test.js, /file.ts/, index.html] group.unpin(fileTs); - assert.equal(group.count, 3); - assert.equal(group.isPinned(fileTs), false); - assert.equal(group.activeEditor, fileTs); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.isPinned(fileTs), false); + assert.strictEqual(group.activeEditor, fileTs); // [test.js, /file.ts/, index.html] -> [test.js, /other.ts/, index.html] const otherTs = input('other.ts'); group.openEditor(otherTs, { active: true }); - assert.equal(group.count, 3); - assert.equal(group.activeEditor, otherTs); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.activeEditor, otherTs); assert.ok(group.getEditors(EditorsOrder.SEQUENTIAL)[0].matches(testJs)); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[1], otherTs); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[1], otherTs); assert.ok(group.getEditors(EditorsOrder.SEQUENTIAL)[2].matches(indexHtml)); // make index.html active const indexHtml4 = input('index.html'); group.setActive(indexHtml4); - assert.equal(group.activeEditor, indexHtml2); + assert.strictEqual(group.activeEditor, indexHtml2); // [test.js, /other.ts/, index.html] -> [test.js, /other.ts/] group.closeEditor(indexHtml); - assert.equal(group.count, 2); - assert.equal(group.activeEditor, otherTs); + assert.strictEqual(group.count, 2); + assert.strictEqual(group.activeEditor, otherTs); assert.ok(group.getEditors(EditorsOrder.SEQUENTIAL)[0].matches(testJs)); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL)[1], otherTs); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL)[1], otherTs); // [test.js, /other.ts/] -> [test.js] group.closeEditor(otherTs); - assert.equal(group.count, 1); - assert.equal(group.activeEditor, testJs); + assert.strictEqual(group.count, 1); + assert.strictEqual(group.activeEditor, testJs); assert.ok(group.getEditors(EditorsOrder.SEQUENTIAL)[0].matches(testJs)); // [test.js] -> /test.js/ group.unpin(testJs); - assert.equal(group.count, 1); - assert.equal(group.activeEditor, testJs); + assert.strictEqual(group.count, 1); + assert.strictEqual(group.activeEditor, testJs); assert.ok(group.getEditors(EditorsOrder.SEQUENTIAL)[0].matches(testJs)); - assert.equal(group.isPinned(testJs), false); + assert.strictEqual(group.isPinned(testJs), false); // /test.js/ -> [] group.closeEditor(testJs); - assert.equal(group.count, 0); - assert.equal(group.activeEditor, null); - assert.equal(group.previewEditor, null); + assert.strictEqual(group.count, 0); + assert.strictEqual(group.activeEditor, null); + assert.strictEqual(group.previewEditor, null); }); test('Single Group, Single Editor - persist', function () { @@ -1293,18 +1293,18 @@ suite('Workbench editor groups', () => { const input1 = input(); group.openEditor(input1); - assert.equal(group.count, 1); - assert.equal(group.activeEditor!.matches(input1), true); - assert.equal(group.previewEditor!.matches(input1), true); - assert.equal(group.isActive(input1), true); + assert.strictEqual(group.count, 1); + assert.strictEqual(group.activeEditor!.matches(input1), true); + assert.strictEqual(group.previewEditor!.matches(input1), true); + assert.strictEqual(group.isActive(input1), true); // Create model again - should load from storage group = inst.createInstance(EditorGroup, group.serialize()); - assert.equal(group.count, 1); - assert.equal(group.activeEditor!.matches(input1), true); - assert.equal(group.previewEditor!.matches(input1), true); - assert.equal(group.isActive(input1), true); + assert.strictEqual(group.count, 1); + assert.strictEqual(group.activeEditor!.matches(input1), true); + assert.strictEqual(group.previewEditor!.matches(input1), true); + assert.strictEqual(group.isActive(input1), true); }); test('Multiple Groups, Multiple editors - persist', function () { @@ -1342,39 +1342,39 @@ suite('Workbench editor groups', () => { group2.openEditor(g2_input2, { active: false, pinned: false }); group2.openEditor(g2_input3, { active: false, pinned: true }); - assert.equal(group1.count, 3); - assert.equal(group2.count, 3); - assert.equal(group1.activeEditor!.matches(g1_input2), true); - assert.equal(group2.activeEditor!.matches(g2_input1), true); - assert.equal(group1.previewEditor!.matches(g1_input2), true); - assert.equal(group2.previewEditor!.matches(g2_input2), true); + assert.strictEqual(group1.count, 3); + assert.strictEqual(group2.count, 3); + assert.strictEqual(group1.activeEditor!.matches(g1_input2), true); + assert.strictEqual(group2.activeEditor!.matches(g2_input1), true); + assert.strictEqual(group1.previewEditor!.matches(g1_input2), true); + assert.strictEqual(group2.previewEditor!.matches(g2_input2), true); - assert.equal(group1.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0].matches(g1_input2), true); - assert.equal(group1.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[1].matches(g1_input3), true); - assert.equal(group1.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[2].matches(g1_input1), true); + assert.strictEqual(group1.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0].matches(g1_input2), true); + assert.strictEqual(group1.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[1].matches(g1_input3), true); + assert.strictEqual(group1.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[2].matches(g1_input1), true); - assert.equal(group2.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0].matches(g2_input1), true); - assert.equal(group2.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[1].matches(g2_input3), true); - assert.equal(group2.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[2].matches(g2_input2), true); + assert.strictEqual(group2.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0].matches(g2_input1), true); + assert.strictEqual(group2.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[1].matches(g2_input3), true); + assert.strictEqual(group2.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[2].matches(g2_input2), true); // Create model again - should load from storage group1 = inst.createInstance(EditorGroup, group1.serialize()); group2 = inst.createInstance(EditorGroup, group2.serialize()); - assert.equal(group1.count, 3); - assert.equal(group2.count, 3); - assert.equal(group1.activeEditor!.matches(g1_input2), true); - assert.equal(group2.activeEditor!.matches(g2_input1), true); - assert.equal(group1.previewEditor!.matches(g1_input2), true); - assert.equal(group2.previewEditor!.matches(g2_input2), true); + assert.strictEqual(group1.count, 3); + assert.strictEqual(group2.count, 3); + assert.strictEqual(group1.activeEditor!.matches(g1_input2), true); + assert.strictEqual(group2.activeEditor!.matches(g2_input1), true); + assert.strictEqual(group1.previewEditor!.matches(g1_input2), true); + assert.strictEqual(group2.previewEditor!.matches(g2_input2), true); - assert.equal(group1.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0].matches(g1_input2), true); - assert.equal(group1.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[1].matches(g1_input3), true); - assert.equal(group1.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[2].matches(g1_input1), true); + assert.strictEqual(group1.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0].matches(g1_input2), true); + assert.strictEqual(group1.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[1].matches(g1_input3), true); + assert.strictEqual(group1.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[2].matches(g1_input1), true); - assert.equal(group2.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0].matches(g2_input1), true); - assert.equal(group2.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[1].matches(g2_input3), true); - assert.equal(group2.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[2].matches(g2_input2), true); + assert.strictEqual(group2.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0].matches(g2_input1), true); + assert.strictEqual(group2.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[1].matches(g2_input3), true); + assert.strictEqual(group2.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[2].matches(g2_input2), true); }); test('Single group, multiple editors - persist (some not persistable)', function () { @@ -1402,23 +1402,23 @@ suite('Workbench editor groups', () => { group.openEditor(nonSerializableInput2, { active: true, pinned: false }); group.openEditor(serializableInput2, { active: false, pinned: true }); - assert.equal(group.count, 3); - assert.equal(group.activeEditor!.matches(nonSerializableInput2), true); - assert.equal(group.previewEditor!.matches(nonSerializableInput2), true); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.activeEditor!.matches(nonSerializableInput2), true); + assert.strictEqual(group.previewEditor!.matches(nonSerializableInput2), true); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0].matches(nonSerializableInput2), true); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[1].matches(serializableInput2), true); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[2].matches(serializableInput1), true); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0].matches(nonSerializableInput2), true); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[1].matches(serializableInput2), true); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[2].matches(serializableInput1), true); // Create model again - should load from storage group = inst.createInstance(EditorGroup, group.serialize()); - assert.equal(group.count, 2); - assert.equal(group.activeEditor!.matches(serializableInput2), true); - assert.equal(group.previewEditor, null); + assert.strictEqual(group.count, 2); + assert.strictEqual(group.activeEditor!.matches(serializableInput2), true); + assert.strictEqual(group.previewEditor, null); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0].matches(serializableInput2), true); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[1].matches(serializableInput1), true); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[0].matches(serializableInput2), true); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)[1].matches(serializableInput1), true); }); test('Single group, multiple editors - persist (some not persistable, sticky editors)', function () { @@ -1446,14 +1446,14 @@ suite('Workbench editor groups', () => { group.openEditor(nonSerializableInput2, { active: true, pinned: true, sticky: true }); group.openEditor(serializableInput2, { active: false, pinned: true }); - assert.equal(group.count, 3); - assert.equal(group.stickyCount, 1); + assert.strictEqual(group.count, 3); + assert.strictEqual(group.stickyCount, 1); // Create model again - should load from storage group = inst.createInstance(EditorGroup, group.serialize()); - assert.equal(group.count, 2); - assert.equal(group.stickyCount, 0); + assert.strictEqual(group.count, 2); + assert.strictEqual(group.stickyCount, 0); }); test('Multiple groups, multiple editors - persist (some not persistable, causes empty group)', function () { @@ -1487,9 +1487,9 @@ suite('Workbench editor groups', () => { group1 = inst.createInstance(EditorGroup, group1.serialize()); group2 = inst.createInstance(EditorGroup, group2.serialize()); - assert.equal(group1.count, 2); - assert.equal(group1.getEditors(EditorsOrder.SEQUENTIAL)[0].matches(serializableInput1), true); - assert.equal(group1.getEditors(EditorsOrder.SEQUENTIAL)[1].matches(serializableInput2), true); + assert.strictEqual(group1.count, 2); + assert.strictEqual(group1.getEditors(EditorsOrder.SEQUENTIAL)[0].matches(serializableInput1), true); + assert.strictEqual(group1.getEditors(EditorsOrder.SEQUENTIAL)[1].matches(serializableInput2), true); }); test('Multiple Editors - Editor Dispose', function () { @@ -1512,14 +1512,14 @@ suite('Workbench editor groups', () => { input1.dispose(); - assert.equal(group1Listener.disposed.length, 1); - assert.equal(group2Listener.disposed.length, 1); + assert.strictEqual(group1Listener.disposed.length, 1); + assert.strictEqual(group2Listener.disposed.length, 1); assert.ok(group1Listener.disposed[0].matches(input1)); assert.ok(group2Listener.disposed[0].matches(input1)); input3.dispose(); - assert.equal(group1Listener.disposed.length, 2); - assert.equal(group2Listener.disposed.length, 1); + assert.strictEqual(group1Listener.disposed.length, 2); + assert.strictEqual(group2Listener.disposed.length, 1); assert.ok(group1Listener.disposed[1].matches(input3)); }); @@ -1535,7 +1535,7 @@ suite('Workbench editor groups', () => { group1.setActive(input1); group1.openEditor(input3, { active: true }); - assert.equal(group1.indexOf(input3), 1); + assert.strictEqual(group1.indexOf(input3), 1); }); test('Multiple Editors - Editor Emits Dirty and Label Changed', function () { @@ -1571,24 +1571,24 @@ suite('Workbench editor groups', () => { (input1).setDirty(); (input1).setLabel(); - assert.equal(dirty1Counter, 1); - assert.equal(label1ChangeCounter, 1); + assert.strictEqual(dirty1Counter, 1); + assert.strictEqual(label1ChangeCounter, 1); (input2).setDirty(); (input2).setLabel(); - assert.equal(dirty2Counter, 1); - assert.equal(label2ChangeCounter, 1); + assert.strictEqual(dirty2Counter, 1); + assert.strictEqual(label2ChangeCounter, 1); closeAllEditors(group2); (input2).setDirty(); (input2).setLabel(); - assert.equal(dirty2Counter, 1); - assert.equal(label2ChangeCounter, 1); - assert.equal(dirty1Counter, 1); - assert.equal(label1ChangeCounter, 1); + assert.strictEqual(dirty2Counter, 1); + assert.strictEqual(label2ChangeCounter, 1); + assert.strictEqual(dirty1Counter, 1); + assert.strictEqual(label1ChangeCounter, 1); }); test('Sticky Editors', function () { @@ -1603,98 +1603,98 @@ suite('Workbench editor groups', () => { group.openEditor(input2, { pinned: true, active: true }); group.openEditor(input3, { pinned: false, active: true }); - assert.equal(group.stickyCount, 0); + assert.strictEqual(group.stickyCount, 0); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL).length, 3); - assert.equal(group.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }).length, 3); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 3); - assert.equal(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true }).length, 3); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL).length, 3); + assert.strictEqual(group.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }).length, 3); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE).length, 3); + assert.strictEqual(group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true }).length, 3); // Stick last editor should move it first and pin group.stick(input3); - assert.equal(group.stickyCount, 1); - assert.equal(group.isSticky(input1), false); - assert.equal(group.isSticky(input2), false); - assert.equal(group.isSticky(input3), true); - assert.equal(group.isPinned(input3), true); - assert.equal(group.indexOf(input1), 1); - assert.equal(group.indexOf(input2), 2); - assert.equal(group.indexOf(input3), 0); + assert.strictEqual(group.stickyCount, 1); + assert.strictEqual(group.isSticky(input1), false); + assert.strictEqual(group.isSticky(input2), false); + assert.strictEqual(group.isSticky(input3), true); + assert.strictEqual(group.isPinned(input3), true); + assert.strictEqual(group.indexOf(input1), 1); + assert.strictEqual(group.indexOf(input2), 2); + assert.strictEqual(group.indexOf(input3), 0); let sequentialAllEditors = group.getEditors(EditorsOrder.SEQUENTIAL); - assert.equal(sequentialAllEditors.length, 3); + assert.strictEqual(sequentialAllEditors.length, 3); let sequentialEditorsExcludingSticky = group.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }); - assert.equal(sequentialEditorsExcludingSticky.length, 2); + assert.strictEqual(sequentialEditorsExcludingSticky.length, 2); assert.ok(sequentialEditorsExcludingSticky.indexOf(input1) >= 0); assert.ok(sequentialEditorsExcludingSticky.indexOf(input2) >= 0); let mruAllEditors = group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE); - assert.equal(mruAllEditors.length, 3); + assert.strictEqual(mruAllEditors.length, 3); let mruEditorsExcludingSticky = group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true }); - assert.equal(mruEditorsExcludingSticky.length, 2); + assert.strictEqual(mruEditorsExcludingSticky.length, 2); assert.ok(mruEditorsExcludingSticky.indexOf(input1) >= 0); assert.ok(mruEditorsExcludingSticky.indexOf(input2) >= 0); // Sticking same editor again is a no-op group.stick(input3); - assert.equal(group.isSticky(input3), true); + assert.strictEqual(group.isSticky(input3), true); // Sticking last editor now should move it after sticky one group.stick(input2); - assert.equal(group.stickyCount, 2); - assert.equal(group.isSticky(input1), false); - assert.equal(group.isSticky(input2), true); - assert.equal(group.isSticky(input3), true); - assert.equal(group.indexOf(input1), 2); - assert.equal(group.indexOf(input2), 1); - assert.equal(group.indexOf(input3), 0); + assert.strictEqual(group.stickyCount, 2); + assert.strictEqual(group.isSticky(input1), false); + assert.strictEqual(group.isSticky(input2), true); + assert.strictEqual(group.isSticky(input3), true); + assert.strictEqual(group.indexOf(input1), 2); + assert.strictEqual(group.indexOf(input2), 1); + assert.strictEqual(group.indexOf(input3), 0); sequentialAllEditors = group.getEditors(EditorsOrder.SEQUENTIAL); - assert.equal(sequentialAllEditors.length, 3); + assert.strictEqual(sequentialAllEditors.length, 3); sequentialEditorsExcludingSticky = group.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }); - assert.equal(sequentialEditorsExcludingSticky.length, 1); + assert.strictEqual(sequentialEditorsExcludingSticky.length, 1); assert.ok(sequentialEditorsExcludingSticky.indexOf(input1) >= 0); mruAllEditors = group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE); - assert.equal(mruAllEditors.length, 3); + assert.strictEqual(mruAllEditors.length, 3); mruEditorsExcludingSticky = group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true }); - assert.equal(mruEditorsExcludingSticky.length, 1); + assert.strictEqual(mruEditorsExcludingSticky.length, 1); assert.ok(mruEditorsExcludingSticky.indexOf(input1) >= 0); // Sticking remaining editor also works group.stick(input1); - assert.equal(group.stickyCount, 3); - assert.equal(group.isSticky(input1), true); - assert.equal(group.isSticky(input2), true); - assert.equal(group.isSticky(input3), true); - assert.equal(group.indexOf(input1), 2); - assert.equal(group.indexOf(input2), 1); - assert.equal(group.indexOf(input3), 0); + assert.strictEqual(group.stickyCount, 3); + assert.strictEqual(group.isSticky(input1), true); + assert.strictEqual(group.isSticky(input2), true); + assert.strictEqual(group.isSticky(input3), true); + assert.strictEqual(group.indexOf(input1), 2); + assert.strictEqual(group.indexOf(input2), 1); + assert.strictEqual(group.indexOf(input3), 0); sequentialAllEditors = group.getEditors(EditorsOrder.SEQUENTIAL); - assert.equal(sequentialAllEditors.length, 3); + assert.strictEqual(sequentialAllEditors.length, 3); sequentialEditorsExcludingSticky = group.getEditors(EditorsOrder.SEQUENTIAL, { excludeSticky: true }); - assert.equal(sequentialEditorsExcludingSticky.length, 0); + assert.strictEqual(sequentialEditorsExcludingSticky.length, 0); mruAllEditors = group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE); - assert.equal(mruAllEditors.length, 3); + assert.strictEqual(mruAllEditors.length, 3); mruEditorsExcludingSticky = group.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE, { excludeSticky: true }); - assert.equal(mruEditorsExcludingSticky.length, 0); + assert.strictEqual(mruEditorsExcludingSticky.length, 0); // Unsticking moves editor after sticky ones group.unstick(input3); - assert.equal(group.stickyCount, 2); - assert.equal(group.isSticky(input1), true); - assert.equal(group.isSticky(input2), true); - assert.equal(group.isSticky(input3), false); - assert.equal(group.indexOf(input1), 1); - assert.equal(group.indexOf(input2), 0); - assert.equal(group.indexOf(input3), 2); + assert.strictEqual(group.stickyCount, 2); + assert.strictEqual(group.isSticky(input1), true); + assert.strictEqual(group.isSticky(input2), true); + assert.strictEqual(group.isSticky(input3), false); + assert.strictEqual(group.indexOf(input1), 1); + assert.strictEqual(group.indexOf(input2), 0); + assert.strictEqual(group.indexOf(input3), 2); // Unsticking all works group.unstick(input1); group.unstick(input2); - assert.equal(group.stickyCount, 0); - assert.equal(group.isSticky(input1), false); - assert.equal(group.isSticky(input2), false); - assert.equal(group.isSticky(input3), false); + assert.strictEqual(group.stickyCount, 0); + assert.strictEqual(group.isSticky(input1), false); + assert.strictEqual(group.isSticky(input2), false); + assert.strictEqual(group.isSticky(input3), false); group.moveEditor(input1, 0); group.moveEditor(input2, 1); @@ -1708,60 +1708,60 @@ suite('Workbench editor groups', () => { const events = groupListener(group); group.openEditor(input4, { pinned: true, active: true }); - assert.equal(group.indexOf(input4), 2); + assert.strictEqual(group.indexOf(input4), 2); group.closeEditor(input4); - assert.equal(events.closed[0].sticky, false); + assert.strictEqual(events.closed[0].sticky, false); group.setActive(input2); group.openEditor(input4, { pinned: true, active: true }); - assert.equal(group.indexOf(input4), 2); + assert.strictEqual(group.indexOf(input4), 2); group.closeEditor(input4); - assert.equal(events.closed[1].sticky, false); + assert.strictEqual(events.closed[1].sticky, false); // Reset - assert.equal(group.stickyCount, 2); - assert.equal(group.isSticky(input1), true); - assert.equal(group.isSticky(input2), true); - assert.equal(group.isSticky(input3), false); - assert.equal(group.indexOf(input1), 0); - assert.equal(group.indexOf(input2), 1); - assert.equal(group.indexOf(input3), 2); + assert.strictEqual(group.stickyCount, 2); + assert.strictEqual(group.isSticky(input1), true); + assert.strictEqual(group.isSticky(input2), true); + assert.strictEqual(group.isSticky(input3), false); + assert.strictEqual(group.indexOf(input1), 0); + assert.strictEqual(group.indexOf(input2), 1); + assert.strictEqual(group.indexOf(input3), 2); // Moving a sticky editor works group.moveEditor(input1, 1); // still moved within sticky range - assert.equal(group.isSticky(input1), true); - assert.equal(group.isSticky(input2), true); - assert.equal(group.isSticky(input3), false); - assert.equal(group.indexOf(input1), 1); - assert.equal(group.indexOf(input2), 0); - assert.equal(group.indexOf(input3), 2); + assert.strictEqual(group.isSticky(input1), true); + assert.strictEqual(group.isSticky(input2), true); + assert.strictEqual(group.isSticky(input3), false); + assert.strictEqual(group.indexOf(input1), 1); + assert.strictEqual(group.indexOf(input2), 0); + assert.strictEqual(group.indexOf(input3), 2); group.moveEditor(input1, 0); // still moved within sticky range - assert.equal(group.isSticky(input1), true); - assert.equal(group.isSticky(input2), true); - assert.equal(group.isSticky(input3), false); - assert.equal(group.indexOf(input1), 0); - assert.equal(group.indexOf(input2), 1); - assert.equal(group.indexOf(input3), 2); + assert.strictEqual(group.isSticky(input1), true); + assert.strictEqual(group.isSticky(input2), true); + assert.strictEqual(group.isSticky(input3), false); + assert.strictEqual(group.indexOf(input1), 0); + assert.strictEqual(group.indexOf(input2), 1); + assert.strictEqual(group.indexOf(input3), 2); group.moveEditor(input1, 2); // moved out of sticky range - assert.equal(group.isSticky(input1), false); - assert.equal(group.isSticky(input2), true); - assert.equal(group.isSticky(input3), false); - assert.equal(group.indexOf(input1), 2); - assert.equal(group.indexOf(input2), 0); - assert.equal(group.indexOf(input3), 1); + assert.strictEqual(group.isSticky(input1), false); + assert.strictEqual(group.isSticky(input2), true); + assert.strictEqual(group.isSticky(input3), false); + assert.strictEqual(group.indexOf(input1), 2); + assert.strictEqual(group.indexOf(input2), 0); + assert.strictEqual(group.indexOf(input3), 1); group.moveEditor(input2, 2); // moved out of sticky range - assert.equal(group.isSticky(input1), false); - assert.equal(group.isSticky(input2), false); - assert.equal(group.isSticky(input3), false); - assert.equal(group.indexOf(input1), 1); - assert.equal(group.indexOf(input2), 2); - assert.equal(group.indexOf(input3), 0); + assert.strictEqual(group.isSticky(input1), false); + assert.strictEqual(group.isSticky(input2), false); + assert.strictEqual(group.isSticky(input3), false); + assert.strictEqual(group.indexOf(input1), 1); + assert.strictEqual(group.indexOf(input2), 2); + assert.strictEqual(group.indexOf(input3), 0); // Reset group.moveEditor(input1, 0); @@ -1769,89 +1769,89 @@ suite('Workbench editor groups', () => { group.moveEditor(input3, 2); group.stick(input1); group.unstick(input2); - assert.equal(group.stickyCount, 1); - assert.equal(group.isSticky(input1), true); - assert.equal(group.isSticky(input2), false); - assert.equal(group.isSticky(input3), false); - assert.equal(group.indexOf(input1), 0); - assert.equal(group.indexOf(input2), 1); - assert.equal(group.indexOf(input3), 2); + assert.strictEqual(group.stickyCount, 1); + assert.strictEqual(group.isSticky(input1), true); + assert.strictEqual(group.isSticky(input2), false); + assert.strictEqual(group.isSticky(input3), false); + assert.strictEqual(group.indexOf(input1), 0); + assert.strictEqual(group.indexOf(input2), 1); + assert.strictEqual(group.indexOf(input3), 2); // Moving a unsticky editor in works group.moveEditor(input3, 1); // still moved within unsticked range - assert.equal(group.isSticky(input1), true); - assert.equal(group.isSticky(input2), false); - assert.equal(group.isSticky(input3), false); - assert.equal(group.indexOf(input1), 0); - assert.equal(group.indexOf(input2), 2); - assert.equal(group.indexOf(input3), 1); + assert.strictEqual(group.isSticky(input1), true); + assert.strictEqual(group.isSticky(input2), false); + assert.strictEqual(group.isSticky(input3), false); + assert.strictEqual(group.indexOf(input1), 0); + assert.strictEqual(group.indexOf(input2), 2); + assert.strictEqual(group.indexOf(input3), 1); group.moveEditor(input3, 2); // still moved within unsticked range - assert.equal(group.isSticky(input1), true); - assert.equal(group.isSticky(input2), false); - assert.equal(group.isSticky(input3), false); - assert.equal(group.indexOf(input1), 0); - assert.equal(group.indexOf(input2), 1); - assert.equal(group.indexOf(input3), 2); + assert.strictEqual(group.isSticky(input1), true); + assert.strictEqual(group.isSticky(input2), false); + assert.strictEqual(group.isSticky(input3), false); + assert.strictEqual(group.indexOf(input1), 0); + assert.strictEqual(group.indexOf(input2), 1); + assert.strictEqual(group.indexOf(input3), 2); group.moveEditor(input3, 0); // moved into sticky range - assert.equal(group.isSticky(input1), true); - assert.equal(group.isSticky(input2), false); - assert.equal(group.isSticky(input3), true); - assert.equal(group.indexOf(input1), 1); - assert.equal(group.indexOf(input2), 2); - assert.equal(group.indexOf(input3), 0); + assert.strictEqual(group.isSticky(input1), true); + assert.strictEqual(group.isSticky(input2), false); + assert.strictEqual(group.isSticky(input3), true); + assert.strictEqual(group.indexOf(input1), 1); + assert.strictEqual(group.indexOf(input2), 2); + assert.strictEqual(group.indexOf(input3), 0); group.moveEditor(input2, 0); // moved into sticky range - assert.equal(group.isSticky(input1), true); - assert.equal(group.isSticky(input2), true); - assert.equal(group.isSticky(input3), true); - assert.equal(group.indexOf(input1), 2); - assert.equal(group.indexOf(input2), 0); - assert.equal(group.indexOf(input3), 1); + assert.strictEqual(group.isSticky(input1), true); + assert.strictEqual(group.isSticky(input2), true); + assert.strictEqual(group.isSticky(input3), true); + assert.strictEqual(group.indexOf(input1), 2); + assert.strictEqual(group.indexOf(input2), 0); + assert.strictEqual(group.indexOf(input3), 1); // Closing a sticky editor updates state properly group.stick(input1); group.stick(input2); group.unstick(input3); - assert.equal(group.stickyCount, 2); + assert.strictEqual(group.stickyCount, 2); group.closeEditor(input1); - assert.equal(events.closed[2].sticky, true); - assert.equal(group.stickyCount, 1); + assert.strictEqual(events.closed[2].sticky, true); + assert.strictEqual(group.stickyCount, 1); group.closeEditor(input2); - assert.equal(events.closed[3].sticky, true); - assert.equal(group.stickyCount, 0); + assert.strictEqual(events.closed[3].sticky, true); + assert.strictEqual(group.stickyCount, 0); closeAllEditors(group); - assert.equal(group.stickyCount, 0); + assert.strictEqual(group.stickyCount, 0); // Open sticky group.openEditor(input1, { sticky: true }); - assert.equal(group.stickyCount, 1); - assert.equal(group.isSticky(input1), true); + assert.strictEqual(group.stickyCount, 1); + assert.strictEqual(group.isSticky(input1), true); group.openEditor(input2, { pinned: true, active: true }); - assert.equal(group.stickyCount, 1); - assert.equal(group.isSticky(input1), true); - assert.equal(group.isSticky(input2), false); + assert.strictEqual(group.stickyCount, 1); + assert.strictEqual(group.isSticky(input1), true); + assert.strictEqual(group.isSticky(input2), false); group.openEditor(input2, { sticky: true }); - assert.equal(group.stickyCount, 2); - assert.equal(group.isSticky(input1), true); - assert.equal(group.isSticky(input2), true); + assert.strictEqual(group.stickyCount, 2); + assert.strictEqual(group.isSticky(input1), true); + assert.strictEqual(group.isSticky(input2), true); group.openEditor(input3, { pinned: true, active: true }); group.openEditor(input4, { pinned: false, active: true, sticky: true }); - assert.equal(group.stickyCount, 3); - assert.equal(group.isSticky(input1), true); - assert.equal(group.isSticky(input2), true); - assert.equal(group.isSticky(input3), false); - assert.equal(group.isSticky(input4), true); - assert.equal(group.isPinned(input4), true); - - assert.equal(group.indexOf(input1), 0); - assert.equal(group.indexOf(input2), 1); - assert.equal(group.indexOf(input3), 3); - assert.equal(group.indexOf(input4), 2); + assert.strictEqual(group.stickyCount, 3); + assert.strictEqual(group.isSticky(input1), true); + assert.strictEqual(group.isSticky(input2), true); + assert.strictEqual(group.isSticky(input3), false); + assert.strictEqual(group.isSticky(input4), true); + assert.strictEqual(group.isPinned(input4), true); + + assert.strictEqual(group.indexOf(input1), 0); + assert.strictEqual(group.indexOf(input2), 1); + assert.strictEqual(group.indexOf(input3), 3); + assert.strictEqual(group.indexOf(input4), 2); }); }); diff --git a/src/vs/workbench/test/browser/parts/editor/editorInput.test.ts b/src/vs/workbench/test/browser/parts/editor/editorInput.test.ts index 21c86ec8fda406cfecef22f29ac7c585f3dfb45e..44824465bd0b9d72f02254073c66a59ed9428407 100644 --- a/src/vs/workbench/test/browser/parts/editor/editorInput.test.ts +++ b/src/vs/workbench/test/browser/parts/editor/editorInput.test.ts @@ -33,7 +33,7 @@ suite('Workbench editor input', () => { }); input.dispose(); - assert.equal(counter, 1); + assert.strictEqual(counter, 1); }); test('DiffEditorInput', () => { @@ -54,14 +54,14 @@ suite('Workbench editor input', () => { let diffInput = instantiationService.createInstance(DiffEditorInput, 'name', 'description', input, otherInput, undefined); - assert.equal(diffInput.originalInput, input); - assert.equal(diffInput.modifiedInput, otherInput); + assert.strictEqual(diffInput.originalInput, input); + assert.strictEqual(diffInput.modifiedInput, otherInput); assert(diffInput.matches(diffInput)); assert(!diffInput.matches(otherInput)); assert(!diffInput.matches(null)); diffInput.dispose(); - assert.equal(counter, 0); + assert.strictEqual(counter, 0); }); test('DiffEditorInput disposes when input inside disposes', function () { @@ -89,6 +89,6 @@ suite('Workbench editor input', () => { }); otherInput.dispose(); - assert.equal(counter, 2); + assert.strictEqual(counter, 2); }); }); diff --git a/src/vs/workbench/test/browser/parts/editor/editorModel.test.ts b/src/vs/workbench/test/browser/parts/editor/editorModel.test.ts index 69a3a66b2efac266f8ee6c4dce839ad4ea77c964..69ef98b646812714a2b745adfd62e1ad90bc20fd 100644 --- a/src/vs/workbench/test/browser/parts/editor/editorModel.test.ts +++ b/src/vs/workbench/test/browser/parts/editor/editorModel.test.ts @@ -60,11 +60,11 @@ suite('Workbench editor model', () => { const model = await m.load(); assert(model === m); - assert.equal(model.isDisposed(), false); + assert.strictEqual(model.isDisposed(), false); assert.strictEqual(m.isResolved(), true); m.dispose(); - assert.equal(counter, 1); - assert.equal(model.isDisposed(), true); + assert.strictEqual(counter, 1); + assert.strictEqual(model.isDisposed(), true); }); test('BaseTextEditorModel', async () => { diff --git a/src/vs/workbench/test/browser/parts/editor/editorPane.test.ts b/src/vs/workbench/test/browser/parts/editor/editorPane.test.ts index b9debd51c920b69fccedf88b13bf60807e6e3cb5..758ade90b1d83bd8a3d19d018c57f23fe994770b 100644 --- a/src/vs/workbench/test/browser/parts/editor/editorPane.test.ts +++ b/src/vs/workbench/test/browser/parts/editor/editorPane.test.ts @@ -111,7 +111,7 @@ suite('Workbench EditorPane', () => { const group = new TestEditorGroupView(1); e.setVisible(true, group); assert(e.isVisible()); - assert.equal(e.group, group); + assert.strictEqual(e.group, group); input.onDispose(() => { assert(false); }); @@ -139,8 +139,8 @@ suite('Workbench EditorPane', () => { const dispose1 = EditorRegistry.registerEditor(d1, [new SyncDescriptor(MyInput)]); const dispose2 = EditorRegistry.registerEditor(d2, [new SyncDescriptor(MyInput), new SyncDescriptor(MyOtherInput)]); - assert.equal(EditorRegistry.getEditors().length, oldEditorsCnt + 2); - assert.equal((EditorRegistry).getEditorInputs().length, oldInputCnt + 3); + assert.strictEqual(EditorRegistry.getEditors().length, oldEditorsCnt + 2); + assert.strictEqual((EditorRegistry).getEditorInputs().length, oldInputCnt + 3); assert.strictEqual(EditorRegistry.getEditor(new MyInput()), d2); assert.strictEqual(EditorRegistry.getEditor(new MyOtherInput()), d2); @@ -209,12 +209,12 @@ suite('Workbench EditorPane', () => { memento.saveEditorState(testGroup0, URI.file('/A'), { line: 3 }); res = memento.loadEditorState(testGroup0, URI.file('/A')); assert.ok(res); - assert.equal(res!.line, 3); + assert.strictEqual(res!.line, 3); memento.saveEditorState(testGroup1, URI.file('/A'), { line: 5 }); res = memento.loadEditorState(testGroup1, URI.file('/A')); assert.ok(res); - assert.equal(res!.line, 5); + assert.strictEqual(res!.line, 5); // Ensure capped at 3 elements memento.saveEditorState(testGroup0, URI.file('/B'), { line: 1 }); @@ -276,15 +276,15 @@ suite('Workbench EditorPane', () => { assert.ok(!res); res = memento.loadEditorState(testGroup0, URI.file('/some/folder/file-moved.txt')); - assert.equal(res?.line, 1); + assert.strictEqual(res?.line, 1); memento.moveEditorState(URI.file('/some/folder'), URI.file('/some/folder-moved'), extUri); res = memento.loadEditorState(testGroup0, URI.file('/some/folder-moved/file-moved.txt')); - assert.equal(res?.line, 1); + assert.strictEqual(res?.line, 1); res = memento.loadEditorState(testGroup0, URI.file('/some/folder-moved/file-2.txt')); - assert.equal(res?.line, 2); + assert.strictEqual(res?.line, 2); }); test('EditoMemento - use with editor input', function () { @@ -317,7 +317,7 @@ suite('Workbench EditorPane', () => { memento.saveEditorState(testGroup0, testInputA, { line: 3 }); res = memento.loadEditorState(testGroup0, testInputA); assert.ok(res); - assert.equal(res!.line, 3); + assert.strictEqual(res!.line, 3); // State removed when input gets disposed testInputA.dispose(); @@ -355,7 +355,7 @@ suite('Workbench EditorPane', () => { memento.saveEditorState(testGroup0, testInputA.resource, { line: 3 }); res = memento.loadEditorState(testGroup0, testInputA); assert.ok(res); - assert.equal(res!.line, 3); + assert.strictEqual(res!.line, 3); // State not yet removed when input gets disposed // because we used resource @@ -371,7 +371,7 @@ suite('Workbench EditorPane', () => { memento.saveEditorState(testGroup0, testInputB.resource, { line: 3 }); res = memento.loadEditorState(testGroup0, testInputB); assert.ok(res); - assert.equal(res!.line, 3); + assert.strictEqual(res!.line, 3); memento.clearEditorStateOnDispose(testInputB.resource, testInputB); diff --git a/src/vs/workbench/test/browser/parts/editor/resourceEditorInput.test.ts b/src/vs/workbench/test/browser/parts/editor/resourceEditorInput.test.ts index a0fa7d56f5d6984d53404f26d4b64d723c915d0a..e8608159c9f2b6f2330f9c003e6e09379a4eaa5c 100644 --- a/src/vs/workbench/test/browser/parts/editor/resourceEditorInput.test.ts +++ b/src/vs/workbench/test/browser/parts/editor/resourceEditorInput.test.ts @@ -31,7 +31,7 @@ suite('Resource text editors', () => { const model = await input.resolve(); assert.ok(model); - assert.equal(snapshotToString(((model as ResourceEditorModel).createSnapshot()!)), 'function test() {}'); + assert.strictEqual(snapshotToString(((model as ResourceEditorModel).createSnapshot()!)), 'function test() {}'); }); test('custom mode', async () => { @@ -46,9 +46,9 @@ suite('Resource text editors', () => { const model = await input.resolve(); assert.ok(model); - assert.equal(model.textEditorModel.getModeId(), 'resource-input-test'); + assert.strictEqual(model.textEditorModel.getModeId(), 'resource-input-test'); input.setMode('text'); - assert.equal(model.textEditorModel.getModeId(), PLAINTEXT_MODE_ID); + assert.strictEqual(model.textEditorModel.getModeId(), PLAINTEXT_MODE_ID); }); }); diff --git a/src/vs/workbench/test/browser/quickAccess.test.ts b/src/vs/workbench/test/browser/quickAccess.test.ts index ccaa36cdf276da1ae177ac57c74e8790f6d5b3ee..669467fa24e43c7a80bbcbb8bb446fca73f265cd 100644 --- a/src/vs/workbench/test/browser/quickAccess.test.ts +++ b/src/vs/workbench/test/browser/quickAccess.test.ts @@ -133,61 +133,61 @@ suite('QuickAccess', () => { disposables.add(registry.registerQuickAccessProvider(providerDescriptor3)); accessor.quickInputService.quickAccess.show('test'); - assert.equal(providerDefaultCalled, false); - assert.equal(provider1Called, true); - assert.equal(provider2Called, false); - assert.equal(provider3Called, false); - assert.equal(providerDefaultCanceled, false); - assert.equal(provider1Canceled, false); - assert.equal(provider2Canceled, false); - assert.equal(provider3Canceled, false); - assert.equal(providerDefaultDisposed, false); - assert.equal(provider1Disposed, false); - assert.equal(provider2Disposed, false); - assert.equal(provider3Disposed, false); + assert.strictEqual(providerDefaultCalled, false); + assert.strictEqual(provider1Called, true); + assert.strictEqual(provider2Called, false); + assert.strictEqual(provider3Called, false); + assert.strictEqual(providerDefaultCanceled, false); + assert.strictEqual(provider1Canceled, false); + assert.strictEqual(provider2Canceled, false); + assert.strictEqual(provider3Canceled, false); + assert.strictEqual(providerDefaultDisposed, false); + assert.strictEqual(provider1Disposed, false); + assert.strictEqual(provider2Disposed, false); + assert.strictEqual(provider3Disposed, false); provider1Called = false; accessor.quickInputService.quickAccess.show('test something'); - assert.equal(providerDefaultCalled, false); - assert.equal(provider1Called, false); - assert.equal(provider2Called, true); - assert.equal(provider3Called, false); - assert.equal(providerDefaultCanceled, false); - assert.equal(provider1Canceled, true); - assert.equal(provider2Canceled, false); - assert.equal(provider3Canceled, false); - assert.equal(providerDefaultDisposed, false); - assert.equal(provider1Disposed, true); - assert.equal(provider2Disposed, false); - assert.equal(provider3Disposed, false); + assert.strictEqual(providerDefaultCalled, false); + assert.strictEqual(provider1Called, false); + assert.strictEqual(provider2Called, true); + assert.strictEqual(provider3Called, false); + assert.strictEqual(providerDefaultCanceled, false); + assert.strictEqual(provider1Canceled, true); + assert.strictEqual(provider2Canceled, false); + assert.strictEqual(provider3Canceled, false); + assert.strictEqual(providerDefaultDisposed, false); + assert.strictEqual(provider1Disposed, true); + assert.strictEqual(provider2Disposed, false); + assert.strictEqual(provider3Disposed, false); provider2Called = false; provider1Canceled = false; provider1Disposed = false; accessor.quickInputService.quickAccess.show('usedefault'); - assert.equal(providerDefaultCalled, true); - assert.equal(provider1Called, false); - assert.equal(provider2Called, false); - assert.equal(provider3Called, false); - assert.equal(providerDefaultCanceled, false); - assert.equal(provider1Canceled, false); - assert.equal(provider2Canceled, true); - assert.equal(provider3Canceled, false); - assert.equal(providerDefaultDisposed, false); - assert.equal(provider1Disposed, false); - assert.equal(provider2Disposed, true); - assert.equal(provider3Disposed, false); + assert.strictEqual(providerDefaultCalled, true); + assert.strictEqual(provider1Called, false); + assert.strictEqual(provider2Called, false); + assert.strictEqual(provider3Called, false); + assert.strictEqual(providerDefaultCanceled, false); + assert.strictEqual(provider1Canceled, false); + assert.strictEqual(provider2Canceled, true); + assert.strictEqual(provider3Canceled, false); + assert.strictEqual(providerDefaultDisposed, false); + assert.strictEqual(provider1Disposed, false); + assert.strictEqual(provider2Disposed, true); + assert.strictEqual(provider3Disposed, false); await timeout(1); - assert.equal(providerDefaultCanceled, true); - assert.equal(providerDefaultDisposed, true); - assert.equal(provider3Called, true); + assert.strictEqual(providerDefaultCanceled, true); + assert.strictEqual(providerDefaultDisposed, true); + assert.strictEqual(provider3Called, true); await timeout(1); - assert.equal(provider3Canceled, true); - assert.equal(provider3Disposed, true); + assert.strictEqual(provider3Canceled, true); + assert.strictEqual(provider3Disposed, true); disposables.dispose(); @@ -272,40 +272,40 @@ suite('QuickAccess', () => { disposables.add(registry.registerQuickAccessProvider(fastAndSlowProviderDescriptor)); accessor.quickInputService.quickAccess.show('fast'); - assert.equal(fastProviderCalled, true); - assert.equal(slowProviderCalled, false); - assert.equal(fastAndSlowProviderCalled, false); + assert.strictEqual(fastProviderCalled, true); + assert.strictEqual(slowProviderCalled, false); + assert.strictEqual(fastAndSlowProviderCalled, false); fastProviderCalled = false; accessor.quickInputService.quickAccess.show('slow'); await timeout(2); - assert.equal(fastProviderCalled, false); - assert.equal(slowProviderCalled, true); - assert.equal(slowProviderCanceled, false); - assert.equal(fastAndSlowProviderCalled, false); + assert.strictEqual(fastProviderCalled, false); + assert.strictEqual(slowProviderCalled, true); + assert.strictEqual(slowProviderCanceled, false); + assert.strictEqual(fastAndSlowProviderCalled, false); slowProviderCalled = false; accessor.quickInputService.quickAccess.show('bothFastAndSlow'); await timeout(2); - assert.equal(fastProviderCalled, false); - assert.equal(slowProviderCalled, false); - assert.equal(fastAndSlowProviderCalled, true); - assert.equal(fastAndSlowProviderCanceled, false); + assert.strictEqual(fastProviderCalled, false); + assert.strictEqual(slowProviderCalled, false); + assert.strictEqual(fastAndSlowProviderCalled, true); + assert.strictEqual(fastAndSlowProviderCanceled, false); fastAndSlowProviderCalled = false; accessor.quickInputService.quickAccess.show('slow'); accessor.quickInputService.quickAccess.show('bothFastAndSlow'); accessor.quickInputService.quickAccess.show('fast'); - assert.equal(fastProviderCalled, true); - assert.equal(slowProviderCalled, true); - assert.equal(fastAndSlowProviderCalled, true); + assert.strictEqual(fastProviderCalled, true); + assert.strictEqual(slowProviderCalled, true); + assert.strictEqual(fastAndSlowProviderCalled, true); await timeout(2); - assert.equal(slowProviderCanceled, true); - assert.equal(fastAndSlowProviderCanceled, true); + assert.strictEqual(slowProviderCanceled, true); + assert.strictEqual(fastAndSlowProviderCanceled, true); disposables.dispose(); diff --git a/src/vs/workbench/test/browser/viewlet.test.ts b/src/vs/workbench/test/browser/viewlet.test.ts index 15a1cb526eb615ad17e322440ed59f47667e16dd..f2cac091a5bc888e0e398051f365be141feea437 100644 --- a/src/vs/workbench/test/browser/viewlet.test.ts +++ b/src/vs/workbench/test/browser/viewlet.test.ts @@ -49,6 +49,6 @@ suite('Viewlets', () => { Platform.Registry.as(Extensions.Viewlets).registerViewlet(d); assert(d === Platform.Registry.as(Extensions.Viewlets).getViewlet('reg-test-id')); - assert.equal(oldCount + 1, Platform.Registry.as(Extensions.Viewlets).getViewlets().length); + assert.strictEqual(oldCount + 1, Platform.Registry.as(Extensions.Viewlets).getViewlets().length); }); }); diff --git a/src/vs/workbench/test/common/memento.test.ts b/src/vs/workbench/test/common/memento.test.ts index edd54aea2dd86eddee44f002e1e4df06f8f77018..437688eae1cdf5e16e4d2a22977331b006c71bed 100644 --- a/src/vs/workbench/test/common/memento.test.ts +++ b/src/vs/workbench/test/common/memento.test.ts @@ -23,7 +23,7 @@ suite('Memento', () => { let memento = myMemento.getMemento(StorageScope.GLOBAL, StorageTarget.MACHINE); memento.foo = [1, 2, 3]; let globalMemento = myMemento.getMemento(StorageScope.GLOBAL, StorageTarget.MACHINE); - assert.deepEqual(globalMemento, memento); + assert.deepStrictEqual(globalMemento, memento); // Workspace memento = myMemento.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE); @@ -34,18 +34,18 @@ suite('Memento', () => { // Global memento = myMemento.getMemento(StorageScope.GLOBAL, StorageTarget.MACHINE); - assert.deepEqual(memento, { foo: [1, 2, 3] }); + assert.deepStrictEqual(memento, { foo: [1, 2, 3] }); globalMemento = myMemento.getMemento(StorageScope.GLOBAL, StorageTarget.MACHINE); - assert.deepEqual(globalMemento, memento); + assert.deepStrictEqual(globalMemento, memento); // Workspace memento = myMemento.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE); - assert.deepEqual(memento, { foo: 'Hello World' }); + assert.deepStrictEqual(memento, { foo: 'Hello World' }); // Assert the Mementos are stored properly in storage - assert.deepEqual(JSON.parse(storage.get('memento/memento.test', StorageScope.GLOBAL)!), { foo: [1, 2, 3] }); + assert.deepStrictEqual(JSON.parse(storage.get('memento/memento.test', StorageScope.GLOBAL)!), { foo: [1, 2, 3] }); - assert.deepEqual(JSON.parse(storage.get('memento/memento.test', StorageScope.WORKSPACE)!), { foo: 'Hello World' }); + assert.deepStrictEqual(JSON.parse(storage.get('memento/memento.test', StorageScope.WORKSPACE)!), { foo: 'Hello World' }); // Delete Global memento = myMemento.getMemento(context!, StorageTarget.MACHINE); @@ -59,11 +59,11 @@ suite('Memento', () => { // Global memento = myMemento.getMemento(context!, StorageTarget.MACHINE); - assert.deepEqual(memento, {}); + assert.deepStrictEqual(memento, {}); // Workspace memento = myMemento.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE); - assert.deepEqual(memento, {}); + assert.deepStrictEqual(memento, {}); // Assert the Mementos are also removed from storage assert.strictEqual(storage.get('memento/memento.test', StorageScope.GLOBAL, null!), null); @@ -87,13 +87,13 @@ suite('Memento', () => { // Global memento = myMemento.getMemento(context!, StorageTarget.MACHINE); - assert.deepEqual(memento, { foo: [1, 2, 3] }); + assert.deepStrictEqual(memento, { foo: [1, 2, 3] }); let globalMemento = myMemento.getMemento(StorageScope.GLOBAL, StorageTarget.MACHINE); - assert.deepEqual(globalMemento, memento); + assert.deepStrictEqual(globalMemento, memento); // Workspace memento = myMemento.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE); - assert.deepEqual(memento, { foo: 'Hello World' }); + assert.deepStrictEqual(memento, { foo: 'Hello World' }); // Global memento = myMemento.getMemento(context!, StorageTarget.MACHINE); @@ -108,13 +108,13 @@ suite('Memento', () => { // Global memento = myMemento.getMemento(context!, StorageTarget.MACHINE); - assert.deepEqual(memento, { foo: [4, 5, 6] }); + assert.deepStrictEqual(memento, { foo: [4, 5, 6] }); globalMemento = myMemento.getMemento(StorageScope.GLOBAL, StorageTarget.MACHINE); - assert.deepEqual(globalMemento, memento); + assert.deepStrictEqual(globalMemento, memento); // Workspace memento = myMemento.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE); - assert.deepEqual(memento, { foo: 'World Hello' }); + assert.deepStrictEqual(memento, { foo: 'World Hello' }); // Delete Global memento = myMemento.getMemento(context!, StorageTarget.MACHINE); @@ -128,11 +128,11 @@ suite('Memento', () => { // Global memento = myMemento.getMemento(context!, StorageTarget.MACHINE); - assert.deepEqual(memento, {}); + assert.deepStrictEqual(memento, {}); // Workspace memento = myMemento.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE); - assert.deepEqual(memento, {}); + assert.deepStrictEqual(memento, {}); }); test('Save and Load - 2 Components with same id', () => { @@ -160,20 +160,20 @@ suite('Memento', () => { // Global memento = myMemento.getMemento(context!, StorageTarget.MACHINE); - assert.deepEqual(memento, { foo: [1, 2, 3], bar: [1, 2, 3] }); + assert.deepStrictEqual(memento, { foo: [1, 2, 3], bar: [1, 2, 3] }); let globalMemento = myMemento.getMemento(StorageScope.GLOBAL, StorageTarget.MACHINE); - assert.deepEqual(globalMemento, memento); + assert.deepStrictEqual(globalMemento, memento); memento = myMemento2.getMemento(context!, StorageTarget.MACHINE); - assert.deepEqual(memento, { foo: [1, 2, 3], bar: [1, 2, 3] }); + assert.deepStrictEqual(memento, { foo: [1, 2, 3], bar: [1, 2, 3] }); globalMemento = myMemento2.getMemento(StorageScope.GLOBAL, StorageTarget.MACHINE); - assert.deepEqual(globalMemento, memento); + assert.deepStrictEqual(globalMemento, memento); // Workspace memento = myMemento.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE); - assert.deepEqual(memento, { foo: 'Hello World', bar: 'Hello World' }); + assert.deepStrictEqual(memento, { foo: 'Hello World', bar: 'Hello World' }); memento = myMemento2.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE); - assert.deepEqual(memento, { foo: 'Hello World', bar: 'Hello World' }); + assert.deepStrictEqual(memento, { foo: 'Hello World', bar: 'Hello World' }); }); }); diff --git a/src/vs/workbench/test/common/notifications.test.ts b/src/vs/workbench/test/common/notifications.test.ts index 765c140dc600b0e2a996e065d4a859e02a9db675..11655e5ad5fe19122ae5636fe7e54818539eecc3 100644 --- a/src/vs/workbench/test/common/notifications.test.ts +++ b/src/vs/workbench/test/common/notifications.test.ts @@ -25,24 +25,24 @@ suite('Notifications', () => { let item5 = NotificationViewItem.create({ severity: Severity.Error, message: 'Error Message', actions: { primary: [new Action('id', 'label')] } })!; let item6 = NotificationViewItem.create({ severity: Severity.Error, message: 'Error Message', actions: { primary: [new Action('id', 'label')] }, progress: { infinite: true } })!; - assert.equal(item1.equals(item1), true); - assert.equal(item2.equals(item2), true); - assert.equal(item3.equals(item3), true); - assert.equal(item4.equals(item4), true); - assert.equal(item5.equals(item5), true); + assert.strictEqual(item1.equals(item1), true); + assert.strictEqual(item2.equals(item2), true); + assert.strictEqual(item3.equals(item3), true); + assert.strictEqual(item4.equals(item4), true); + assert.strictEqual(item5.equals(item5), true); - assert.equal(item1.equals(item2), true); - assert.equal(item1.equals(item3), false); - assert.equal(item1.equals(item4), false); - assert.equal(item1.equals(item5), false); + assert.strictEqual(item1.equals(item2), true); + assert.strictEqual(item1.equals(item3), false); + assert.strictEqual(item1.equals(item4), false); + assert.strictEqual(item1.equals(item5), false); // Progress - assert.equal(item1.hasProgress, false); - assert.equal(item6.hasProgress, true); + assert.strictEqual(item1.hasProgress, false); + assert.strictEqual(item6.hasProgress, true); // Message Box - assert.equal(item5.canCollapse, false); - assert.equal(item5.expanded, true); + assert.strictEqual(item5.canCollapse, false); + assert.strictEqual(item5.expanded, true); // Events let called = 0; @@ -55,7 +55,7 @@ suite('Notifications', () => { item1.collapse(); item1.collapse(); - assert.equal(called, 2); + assert.strictEqual(called, 2); called = 0; item1.onDidChangeContent(e => { @@ -67,7 +67,7 @@ suite('Notifications', () => { item1.progress.infinite(); item1.progress.done(); - assert.equal(called, 2); + assert.strictEqual(called, 2); called = 0; item1.onDidChangeContent(e => { @@ -96,7 +96,7 @@ suite('Notifications', () => { item1.updateActions({ primary: [new Action('id2', 'label')] }); - assert.equal(called, 1); + assert.strictEqual(called, 1); called = 0; item1.onDidChangeVisibility(e => { @@ -107,7 +107,7 @@ suite('Notifications', () => { item1.updateVisibility(false); item1.updateVisibility(false); - assert.equal(called, 2); + assert.strictEqual(called, 2); called = 0; item1.onDidClose(() => { @@ -115,24 +115,24 @@ suite('Notifications', () => { }); item1.close(); - assert.equal(called, 1); + assert.strictEqual(called, 1); // Error with Action let item7 = NotificationViewItem.create({ severity: Severity.Error, message: createErrorWithActions('Hello Error', { actions: [new Action('id', 'label')] }) })!; - assert.equal(item7.actions!.primary!.length, 1); + assert.strictEqual(item7.actions!.primary!.length, 1); // Filter let item8 = NotificationViewItem.create({ severity: Severity.Error, message: 'Error Message' }, NotificationsFilter.SILENT)!; - assert.equal(item8.silent, true); + assert.strictEqual(item8.silent, true); let item9 = NotificationViewItem.create({ severity: Severity.Error, message: 'Error Message' }, NotificationsFilter.OFF)!; - assert.equal(item9.silent, false); + assert.strictEqual(item9.silent, false); let item10 = NotificationViewItem.create({ severity: Severity.Error, message: 'Error Message' }, NotificationsFilter.ERROR)!; - assert.equal(item10.silent, false); + assert.strictEqual(item10.silent, false); let item11 = NotificationViewItem.create({ severity: Severity.Warning, message: 'Error Message' }, NotificationsFilter.ERROR)!; - assert.equal(item11.silent, true); + assert.strictEqual(item11.silent, true); }); test('Model', () => { @@ -154,40 +154,40 @@ suite('Notifications', () => { let item3: INotification = { severity: Severity.Info, message: 'Info Message' }; let item1Handle = model.addNotification(item1); - assert.equal(lastNotificationEvent.item.severity, item1.severity); - assert.equal(lastNotificationEvent.item.message.linkedText.toString(), item1.message); - assert.equal(lastNotificationEvent.index, 0); - assert.equal(lastNotificationEvent.kind, NotificationChangeType.ADD); + assert.strictEqual(lastNotificationEvent.item.severity, item1.severity); + assert.strictEqual(lastNotificationEvent.item.message.linkedText.toString(), item1.message); + assert.strictEqual(lastNotificationEvent.index, 0); + assert.strictEqual(lastNotificationEvent.kind, NotificationChangeType.ADD); item1Handle.updateMessage('Error Message'); - assert.equal(lastNotificationEvent.kind, NotificationChangeType.CHANGE); - assert.equal(lastNotificationEvent.detail, NotificationViewItemContentChangeKind.MESSAGE); + assert.strictEqual(lastNotificationEvent.kind, NotificationChangeType.CHANGE); + assert.strictEqual(lastNotificationEvent.detail, NotificationViewItemContentChangeKind.MESSAGE); item1Handle.updateSeverity(Severity.Error); - assert.equal(lastNotificationEvent.kind, NotificationChangeType.CHANGE); - assert.equal(lastNotificationEvent.detail, NotificationViewItemContentChangeKind.SEVERITY); + assert.strictEqual(lastNotificationEvent.kind, NotificationChangeType.CHANGE); + assert.strictEqual(lastNotificationEvent.detail, NotificationViewItemContentChangeKind.SEVERITY); item1Handle.updateActions({ primary: [], secondary: [] }); - assert.equal(lastNotificationEvent.kind, NotificationChangeType.CHANGE); - assert.equal(lastNotificationEvent.detail, NotificationViewItemContentChangeKind.ACTIONS); + assert.strictEqual(lastNotificationEvent.kind, NotificationChangeType.CHANGE); + assert.strictEqual(lastNotificationEvent.detail, NotificationViewItemContentChangeKind.ACTIONS); item1Handle.progress.infinite(); - assert.equal(lastNotificationEvent.kind, NotificationChangeType.CHANGE); - assert.equal(lastNotificationEvent.detail, NotificationViewItemContentChangeKind.PROGRESS); + assert.strictEqual(lastNotificationEvent.kind, NotificationChangeType.CHANGE); + assert.strictEqual(lastNotificationEvent.detail, NotificationViewItemContentChangeKind.PROGRESS); let item2Handle = model.addNotification(item2); - assert.equal(lastNotificationEvent.item.severity, item2.severity); - assert.equal(lastNotificationEvent.item.message.linkedText.toString(), item2.message); - assert.equal(lastNotificationEvent.index, 0); - assert.equal(lastNotificationEvent.kind, NotificationChangeType.ADD); + assert.strictEqual(lastNotificationEvent.item.severity, item2.severity); + assert.strictEqual(lastNotificationEvent.item.message.linkedText.toString(), item2.message); + assert.strictEqual(lastNotificationEvent.index, 0); + assert.strictEqual(lastNotificationEvent.kind, NotificationChangeType.ADD); model.addNotification(item3); - assert.equal(lastNotificationEvent.item.severity, item3.severity); - assert.equal(lastNotificationEvent.item.message.linkedText.toString(), item3.message); - assert.equal(lastNotificationEvent.index, 0); - assert.equal(lastNotificationEvent.kind, NotificationChangeType.ADD); + assert.strictEqual(lastNotificationEvent.item.severity, item3.severity); + assert.strictEqual(lastNotificationEvent.item.message.linkedText.toString(), item3.message); + assert.strictEqual(lastNotificationEvent.index, 0); + assert.strictEqual(lastNotificationEvent.kind, NotificationChangeType.ADD); - assert.equal(model.notifications.length, 3); + assert.strictEqual(model.notifications.length, 3); let called = 0; item1Handle.onDidClose(() => { @@ -195,48 +195,48 @@ suite('Notifications', () => { }); item1Handle.close(); - assert.equal(called, 1); - assert.equal(model.notifications.length, 2); - assert.equal(lastNotificationEvent.item.severity, item1.severity); - assert.equal(lastNotificationEvent.item.message.linkedText.toString(), item1.message); - assert.equal(lastNotificationEvent.index, 2); - assert.equal(lastNotificationEvent.kind, NotificationChangeType.REMOVE); + assert.strictEqual(called, 1); + assert.strictEqual(model.notifications.length, 2); + assert.strictEqual(lastNotificationEvent.item.severity, item1.severity); + assert.strictEqual(lastNotificationEvent.item.message.linkedText.toString(), item1.message); + assert.strictEqual(lastNotificationEvent.index, 2); + assert.strictEqual(lastNotificationEvent.kind, NotificationChangeType.REMOVE); model.addNotification(item2Duplicate); - assert.equal(model.notifications.length, 2); - assert.equal(lastNotificationEvent.item.severity, item2Duplicate.severity); - assert.equal(lastNotificationEvent.item.message.linkedText.toString(), item2Duplicate.message); - assert.equal(lastNotificationEvent.index, 0); - assert.equal(lastNotificationEvent.kind, NotificationChangeType.ADD); + assert.strictEqual(model.notifications.length, 2); + assert.strictEqual(lastNotificationEvent.item.severity, item2Duplicate.severity); + assert.strictEqual(lastNotificationEvent.item.message.linkedText.toString(), item2Duplicate.message); + assert.strictEqual(lastNotificationEvent.index, 0); + assert.strictEqual(lastNotificationEvent.kind, NotificationChangeType.ADD); item2Handle.close(); - assert.equal(model.notifications.length, 1); - assert.equal(lastNotificationEvent.item.severity, item2Duplicate.severity); - assert.equal(lastNotificationEvent.item.message.linkedText.toString(), item2Duplicate.message); - assert.equal(lastNotificationEvent.index, 0); - assert.equal(lastNotificationEvent.kind, NotificationChangeType.REMOVE); + assert.strictEqual(model.notifications.length, 1); + assert.strictEqual(lastNotificationEvent.item.severity, item2Duplicate.severity); + assert.strictEqual(lastNotificationEvent.item.message.linkedText.toString(), item2Duplicate.message); + assert.strictEqual(lastNotificationEvent.index, 0); + assert.strictEqual(lastNotificationEvent.kind, NotificationChangeType.REMOVE); model.notifications[0].expand(); - assert.equal(lastNotificationEvent.item.severity, item3.severity); - assert.equal(lastNotificationEvent.item.message.linkedText.toString(), item3.message); - assert.equal(lastNotificationEvent.index, 0); - assert.equal(lastNotificationEvent.kind, NotificationChangeType.EXPAND_COLLAPSE); + assert.strictEqual(lastNotificationEvent.item.severity, item3.severity); + assert.strictEqual(lastNotificationEvent.item.message.linkedText.toString(), item3.message); + assert.strictEqual(lastNotificationEvent.index, 0); + assert.strictEqual(lastNotificationEvent.kind, NotificationChangeType.EXPAND_COLLAPSE); const disposable = model.showStatusMessage('Hello World'); - assert.equal(model.statusMessage!.message, 'Hello World'); - assert.equal(lastStatusMessageEvent.item.message, model.statusMessage!.message); - assert.equal(lastStatusMessageEvent.kind, StatusMessageChangeType.ADD); + assert.strictEqual(model.statusMessage!.message, 'Hello World'); + assert.strictEqual(lastStatusMessageEvent.item.message, model.statusMessage!.message); + assert.strictEqual(lastStatusMessageEvent.kind, StatusMessageChangeType.ADD); disposable.dispose(); assert.ok(!model.statusMessage); - assert.equal(lastStatusMessageEvent.kind, StatusMessageChangeType.REMOVE); + assert.strictEqual(lastStatusMessageEvent.kind, StatusMessageChangeType.REMOVE); let disposable2 = model.showStatusMessage('Hello World 2'); const disposable3 = model.showStatusMessage('Hello World 3'); - assert.equal(model.statusMessage!.message, 'Hello World 3'); + assert.strictEqual(model.statusMessage!.message, 'Hello World 3'); disposable2.dispose(); - assert.equal(model.statusMessage!.message, 'Hello World 3'); + assert.strictEqual(model.statusMessage!.message, 'Hello World 3'); disposable3.dispose(); assert.ok(!model.statusMessage);