cubetiq/code-server
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

chore(vscode): update to 1.56.0

Browse Source
This commit is contained in:
Akash Satheesan
2021-04-30 20:25:17 +05:30
parent 0d9fe6ff44 58ce849223
commit ec8894d6c4
1749 changed files with 88014 additions and 43316 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
lib/vscode/src/vs/base/test/browser/comparers.test.ts
View File

@@ -59,8 +59,8 @@ suite('Comparers', () => {
// name-only comparisons
assert(compareFileNames('a', 'A') !== compareLocale('a', 'A'), 'the same letter does not sort by locale');
assert(compareFileNames('â', 'Â') !== compareLocale('â', 'Â'), 'the same accented letter does not sort by locale');
assert.notDeepEqual(['artichoke', 'Artichoke', 'art', 'Art'].sort(compareFileNames), ['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(compareFileNames), ['email', 'Email', 'émail', 'Émail'].sort(compareLocale), 'the same base characters with different case or accents do not sort in locale order');
assert.notDeepStrictEqual(['artichoke', 'Artichoke', 'art', 'Art'].sort(compareFileNames), ['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(compareFileNames), ['email', 'Email', 'émail', 'Émail'].sort(compareLocale), 'the same base characters with different case or accents do not sort in locale order');
// numeric comparisons
assert(compareFileNames('abc02.txt', 'abc002.txt') > 0, 'filenames with equivalent numbers and leading zeros sort in unicode order');

30
lib/vscode/src/vs/base/test/browser/formattedTextRenderer.test.ts
View File

@@ -44,8 +44,14 @@ suite('FormattedTextRenderer', () => {
result = renderFormattedText('__italics__');
assert.strictEqual(result.innerHTML, '<i>italics</i>');
result = renderFormattedText('this string has **bold** and __italics__');
assert.strictEqual(result.innerHTML, 'this string has <b>bold</b> and <i>italics</i>');
result = renderFormattedText('``code``');
assert.strictEqual(result.innerHTML, '``code``');
result = renderFormattedText('``code``', { renderCodeSegements: true });
assert.strictEqual(result.innerHTML, '<code>code</code>');
result = renderFormattedText('this string has **bold**, __italics__, and ``code``!!', { renderCodeSegements: true });
assert.strictEqual(result.innerHTML, 'this string has <b>bold</b>, <i>italics</i>, and <code>code</code>!!');
});
test('no formatting', () => {
@@ -96,6 +102,26 @@ suite('FormattedTextRenderer', () => {
assert.strictEqual(callbackCalled, true);
});
test('fancier action', () => {
let callbackCalled = false;
let result: HTMLElement = renderFormattedText('``__**[[action]]**__``', {
renderCodeSegements: true,
actionHandler: {
callback(content) {
assert.strictEqual(content, '0');
callbackCalled = true;
},
disposeables: store
}
});
assert.strictEqual(result.innerHTML, '<code><i><b><a href="#">action</a></b></i></code>');
let event: MouseEvent = <any>document.createEvent('MouseEvent');
event.initEvent('click', true, true);
result.firstChild!.firstChild!.firstChild!.firstChild!.dispatchEvent(event);
assert.strictEqual(callbackCalled, true);
});
test('escaped formatting', () => {
let result: HTMLElement = renderFormattedText('\\*\\*bold\\*\\*');
assert.strictEqual(result.children.length, 0);

2
lib/vscode/src/vs/base/test/browser/markdownRenderer.test.ts
View File

@@ -111,7 +111,7 @@ suite('MarkdownRenderer', () => {
const data = <{ script: string, documentUri: URI }>parse(decodeURIComponent(uri.query));
assert.ok(data);
assert.equal(data.script, 'echo');
assert.strictEqual(data.script, 'echo');
assert.ok(data.documentUri.toString().startsWith('file:///c%3A/'));
});

546
lib/vscode/src/vs/base/test/browser/ui/grid/grid.test.ts
View File

@@ -40,35 +40,35 @@ suite('Grid', function () {
});
test('getRelativeLocation', () => {
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [0], Direction.Up), [0]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [0], Direction.Down), [1]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [0], Direction.Left), [0, 0]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [0], Direction.Right), [0, 1]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [0], Direction.Up), [0]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [0], Direction.Down), [1]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [0], Direction.Left), [0, 0]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [0], Direction.Right), [0, 1]);
assert.deepEqual(getRelativeLocation(Orientation.HORIZONTAL, [0], Direction.Up), [0, 0]);
assert.deepEqual(getRelativeLocation(Orientation.HORIZONTAL, [0], Direction.Down), [0, 1]);
assert.deepEqual(getRelativeLocation(Orientation.HORIZONTAL, [0], Direction.Left), [0]);
assert.deepEqual(getRelativeLocation(Orientation.HORIZONTAL, [0], Direction.Right), [1]);
assert.deepStrictEqual(getRelativeLocation(Orientation.HORIZONTAL, [0], Direction.Up), [0, 0]);
assert.deepStrictEqual(getRelativeLocation(Orientation.HORIZONTAL, [0], Direction.Down), [0, 1]);
assert.deepStrictEqual(getRelativeLocation(Orientation.HORIZONTAL, [0], Direction.Left), [0]);
assert.deepStrictEqual(getRelativeLocation(Orientation.HORIZONTAL, [0], Direction.Right), [1]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [4], Direction.Up), [4]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [4], Direction.Down), [5]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [4], Direction.Left), [4, 0]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [4], Direction.Right), [4, 1]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [4], Direction.Up), [4]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [4], Direction.Down), [5]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [4], Direction.Left), [4, 0]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [4], Direction.Right), [4, 1]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [0, 0], Direction.Up), [0, 0, 0]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [0, 0], Direction.Down), [0, 0, 1]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [0, 0], Direction.Left), [0, 0]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [0, 0], Direction.Right), [0, 1]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [0, 0], Direction.Up), [0, 0, 0]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [0, 0], Direction.Down), [0, 0, 1]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [0, 0], Direction.Left), [0, 0]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [0, 0], Direction.Right), [0, 1]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [1, 2], Direction.Up), [1, 2, 0]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [1, 2], Direction.Down), [1, 2, 1]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [1, 2], Direction.Left), [1, 2]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [1, 2], Direction.Right), [1, 3]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [1, 2], Direction.Up), [1, 2, 0]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [1, 2], Direction.Down), [1, 2, 1]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [1, 2], Direction.Left), [1, 2]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [1, 2], Direction.Right), [1, 3]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [1, 2, 3], Direction.Up), [1, 2, 3]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [1, 2, 3], Direction.Down), [1, 2, 4]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [1, 2, 3], Direction.Left), [1, 2, 3, 0]);
assert.deepEqual(getRelativeLocation(Orientation.VERTICAL, [1, 2, 3], Direction.Right), [1, 2, 3, 1]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [1, 2, 3], Direction.Up), [1, 2, 3]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [1, 2, 3], Direction.Down), [1, 2, 4]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [1, 2, 3], Direction.Left), [1, 2, 3, 0]);
assert.deepStrictEqual(getRelativeLocation(Orientation.VERTICAL, [1, 2, 3], Direction.Right), [1, 2, 3, 1]);
});
test('empty', () => {
@@ -77,7 +77,7 @@ suite('Grid', function () {
container.appendChild(gridview.element);
gridview.layout(800, 600);
assert.deepEqual(view1.size, [800, 600]);
assert.deepStrictEqual(view1.size, [800, 600]);
});
test('two views vertically', function () {
@@ -85,12 +85,12 @@ suite('Grid', function () {
const grid = new Grid(view1);
container.appendChild(grid.element);
grid.layout(800, 600);
assert.deepEqual(view1.size, [800, 600]);
assert.deepStrictEqual(view1.size, [800, 600]);
const view2 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view2, 200, view1, Direction.Up);
assert.deepEqual(view1.size, [800, 400]);
assert.deepEqual(view2.size, [800, 200]);
assert.deepStrictEqual(view1.size, [800, 400]);
assert.deepStrictEqual(view2.size, [800, 200]);
});
test('two views horizontally', function () {
@@ -99,12 +99,12 @@ suite('Grid', function () {
container.appendChild(grid.element);
grid.layout(800, 600);
assert.deepEqual(view1.size, [800, 600]);
assert.deepStrictEqual(view1.size, [800, 600]);
const view2 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view2, 300, view1, Direction.Right);
assert.deepEqual(view1.size, [500, 600]);
assert.deepEqual(view2.size, [300, 600]);
assert.deepStrictEqual(view1.size, [500, 600]);
assert.deepStrictEqual(view2.size, [300, 600]);
});
test('simple layout', function () {
@@ -113,33 +113,33 @@ suite('Grid', function () {
container.appendChild(grid.element);
grid.layout(800, 600);
assert.deepEqual(view1.size, [800, 600]);
assert.deepStrictEqual(view1.size, [800, 600]);
const view2 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view2, 200, view1, Direction.Up);
assert.deepEqual(view1.size, [800, 400]);
assert.deepEqual(view2.size, [800, 200]);
assert.deepStrictEqual(view1.size, [800, 400]);
assert.deepStrictEqual(view2.size, [800, 200]);
const view3 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view3, 200, view1, Direction.Right);
assert.deepEqual(view1.size, [600, 400]);
assert.deepEqual(view2.size, [800, 200]);
assert.deepEqual(view3.size, [200, 400]);
assert.deepStrictEqual(view1.size, [600, 400]);
assert.deepStrictEqual(view2.size, [800, 200]);
assert.deepStrictEqual(view3.size, [200, 400]);
const view4 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view4, 200, view2, Direction.Left);
assert.deepEqual(view1.size, [600, 400]);
assert.deepEqual(view2.size, [600, 200]);
assert.deepEqual(view3.size, [200, 400]);
assert.deepEqual(view4.size, [200, 200]);
assert.deepStrictEqual(view1.size, [600, 400]);
assert.deepStrictEqual(view2.size, [600, 200]);
assert.deepStrictEqual(view3.size, [200, 400]);
assert.deepStrictEqual(view4.size, [200, 200]);
const view5 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view5, 100, view1, Direction.Down);
assert.deepEqual(view1.size, [600, 300]);
assert.deepEqual(view2.size, [600, 200]);
assert.deepEqual(view3.size, [200, 400]);
assert.deepEqual(view4.size, [200, 200]);
assert.deepEqual(view5.size, [600, 100]);
assert.deepStrictEqual(view1.size, [600, 300]);
assert.deepStrictEqual(view2.size, [600, 200]);
assert.deepStrictEqual(view3.size, [200, 400]);
assert.deepStrictEqual(view4.size, [200, 200]);
assert.deepStrictEqual(view5.size, [600, 100]);
});
test('another simple layout with automatic size distribution', function () {
@@ -148,42 +148,42 @@ suite('Grid', function () {
container.appendChild(grid.element);
grid.layout(800, 600);
assert.deepEqual(view1.size, [800, 600]);
assert.deepStrictEqual(view1.size, [800, 600]);
const view2 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view2, Sizing.Distribute, view1, Direction.Left);
assert.deepEqual(view1.size, [400, 600]);
assert.deepEqual(view2.size, [400, 600]);
assert.deepStrictEqual(view1.size, [400, 600]);
assert.deepStrictEqual(view2.size, [400, 600]);
const view3 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view3, Sizing.Distribute, view1, Direction.Right);
assert.deepEqual(view1.size, [266, 600]);
assert.deepEqual(view2.size, [266, 600]);
assert.deepEqual(view3.size, [268, 600]);
assert.deepStrictEqual(view1.size, [266, 600]);
assert.deepStrictEqual(view2.size, [266, 600]);
assert.deepStrictEqual(view3.size, [268, 600]);
const view4 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view4, Sizing.Distribute, view2, Direction.Down);
assert.deepEqual(view1.size, [266, 600]);
assert.deepEqual(view2.size, [266, 300]);
assert.deepEqual(view3.size, [268, 600]);
assert.deepEqual(view4.size, [266, 300]);
assert.deepStrictEqual(view1.size, [266, 600]);
assert.deepStrictEqual(view2.size, [266, 300]);
assert.deepStrictEqual(view3.size, [268, 600]);
assert.deepStrictEqual(view4.size, [266, 300]);
const view5 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view5, Sizing.Distribute, view3, Direction.Up);
assert.deepEqual(view1.size, [266, 600]);
assert.deepEqual(view2.size, [266, 300]);
assert.deepEqual(view3.size, [268, 300]);
assert.deepEqual(view4.size, [266, 300]);
assert.deepEqual(view5.size, [268, 300]);
assert.deepStrictEqual(view1.size, [266, 600]);
assert.deepStrictEqual(view2.size, [266, 300]);
assert.deepStrictEqual(view3.size, [268, 300]);
assert.deepStrictEqual(view4.size, [266, 300]);
assert.deepStrictEqual(view5.size, [268, 300]);
const view6 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view6, Sizing.Distribute, view3, Direction.Down);
assert.deepEqual(view1.size, [266, 600]);
assert.deepEqual(view2.size, [266, 300]);
assert.deepEqual(view3.size, [268, 200]);
assert.deepEqual(view4.size, [266, 300]);
assert.deepEqual(view5.size, [268, 200]);
assert.deepEqual(view6.size, [268, 200]);
assert.deepStrictEqual(view1.size, [266, 600]);
assert.deepStrictEqual(view2.size, [266, 300]);
assert.deepStrictEqual(view3.size, [268, 200]);
assert.deepStrictEqual(view4.size, [266, 300]);
assert.deepStrictEqual(view5.size, [268, 200]);
assert.deepStrictEqual(view6.size, [268, 200]);
});
test('another simple layout with split size distribution', function () {
@@ -192,42 +192,42 @@ suite('Grid', function () {
container.appendChild(grid.element);
grid.layout(800, 600);
assert.deepEqual(view1.size, [800, 600]);
assert.deepStrictEqual(view1.size, [800, 600]);
const view2 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view2, Sizing.Split, view1, Direction.Left);
assert.deepEqual(view1.size, [400, 600]);
assert.deepEqual(view2.size, [400, 600]);
assert.deepStrictEqual(view1.size, [400, 600]);
assert.deepStrictEqual(view2.size, [400, 600]);
const view3 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view3, Sizing.Split, view1, Direction.Right);
assert.deepEqual(view1.size, [200, 600]);
assert.deepEqual(view2.size, [400, 600]);
assert.deepEqual(view3.size, [200, 600]);
assert.deepStrictEqual(view1.size, [200, 600]);
assert.deepStrictEqual(view2.size, [400, 600]);
assert.deepStrictEqual(view3.size, [200, 600]);
const view4 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view4, Sizing.Split, view2, Direction.Down);
assert.deepEqual(view1.size, [200, 600]);
assert.deepEqual(view2.size, [400, 300]);
assert.deepEqual(view3.size, [200, 600]);
assert.deepEqual(view4.size, [400, 300]);
assert.deepStrictEqual(view1.size, [200, 600]);
assert.deepStrictEqual(view2.size, [400, 300]);
assert.deepStrictEqual(view3.size, [200, 600]);
assert.deepStrictEqual(view4.size, [400, 300]);
const view5 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view5, Sizing.Split, view3, Direction.Up);
assert.deepEqual(view1.size, [200, 600]);
assert.deepEqual(view2.size, [400, 300]);
assert.deepEqual(view3.size, [200, 300]);
assert.deepEqual(view4.size, [400, 300]);
assert.deepEqual(view5.size, [200, 300]);
assert.deepStrictEqual(view1.size, [200, 600]);
assert.deepStrictEqual(view2.size, [400, 300]);
assert.deepStrictEqual(view3.size, [200, 300]);
assert.deepStrictEqual(view4.size, [400, 300]);
assert.deepStrictEqual(view5.size, [200, 300]);
const view6 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view6, Sizing.Split, view3, Direction.Down);
assert.deepEqual(view1.size, [200, 600]);
assert.deepEqual(view2.size, [400, 300]);
assert.deepEqual(view3.size, [200, 150]);
assert.deepEqual(view4.size, [400, 300]);
assert.deepEqual(view5.size, [200, 300]);
assert.deepEqual(view6.size, [200, 150]);
assert.deepStrictEqual(view1.size, [200, 600]);
assert.deepStrictEqual(view2.size, [400, 300]);
assert.deepStrictEqual(view3.size, [200, 150]);
assert.deepStrictEqual(view4.size, [400, 300]);
assert.deepStrictEqual(view5.size, [200, 300]);
assert.deepStrictEqual(view6.size, [200, 150]);
});
test('3/2 layout with split', function () {
@@ -236,33 +236,33 @@ suite('Grid', function () {
container.appendChild(grid.element);
grid.layout(800, 600);
assert.deepEqual(view1.size, [800, 600]);
assert.deepStrictEqual(view1.size, [800, 600]);
const view2 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view2, Sizing.Split, view1, Direction.Down);
assert.deepEqual(view1.size, [800, 300]);
assert.deepEqual(view2.size, [800, 300]);
assert.deepStrictEqual(view1.size, [800, 300]);
assert.deepStrictEqual(view2.size, [800, 300]);
const view3 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view3, Sizing.Split, view2, Direction.Right);
assert.deepEqual(view1.size, [800, 300]);
assert.deepEqual(view2.size, [400, 300]);
assert.deepEqual(view3.size, [400, 300]);
assert.deepStrictEqual(view1.size, [800, 300]);
assert.deepStrictEqual(view2.size, [400, 300]);
assert.deepStrictEqual(view3.size, [400, 300]);
const view4 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view4, Sizing.Split, view1, Direction.Right);
assert.deepEqual(view1.size, [400, 300]);
assert.deepEqual(view2.size, [400, 300]);
assert.deepEqual(view3.size, [400, 300]);
assert.deepEqual(view4.size, [400, 300]);
assert.deepStrictEqual(view1.size, [400, 300]);
assert.deepStrictEqual(view2.size, [400, 300]);
assert.deepStrictEqual(view3.size, [400, 300]);
assert.deepStrictEqual(view4.size, [400, 300]);
const view5 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view5, Sizing.Split, view1, Direction.Right);
assert.deepEqual(view1.size, [200, 300]);
assert.deepEqual(view2.size, [400, 300]);
assert.deepEqual(view3.size, [400, 300]);
assert.deepEqual(view4.size, [400, 300]);
assert.deepEqual(view5.size, [200, 300]);
assert.deepStrictEqual(view1.size, [200, 300]);
assert.deepStrictEqual(view2.size, [400, 300]);
assert.deepStrictEqual(view3.size, [400, 300]);
assert.deepStrictEqual(view4.size, [400, 300]);
assert.deepStrictEqual(view5.size, [200, 300]);
});
test('sizing should be correct after branch demotion #50564', function () {
@@ -280,15 +280,15 @@ suite('Grid', function () {
const view4 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view4, Sizing.Split, view2, Direction.Right);
assert.deepEqual(view1.size, [400, 600]);
assert.deepEqual(view2.size, [200, 300]);
assert.deepEqual(view3.size, [400, 300]);
assert.deepEqual(view4.size, [200, 300]);
assert.deepStrictEqual(view1.size, [400, 600]);
assert.deepStrictEqual(view2.size, [200, 300]);
assert.deepStrictEqual(view3.size, [400, 300]);
assert.deepStrictEqual(view4.size, [200, 300]);
grid.removeView(view3);
assert.deepEqual(view1.size, [400, 600]);
assert.deepEqual(view2.size, [200, 600]);
assert.deepEqual(view4.size, [200, 600]);
assert.deepStrictEqual(view1.size, [400, 600]);
assert.deepStrictEqual(view2.size, [200, 600]);
assert.deepStrictEqual(view4.size, [200, 600]);
});
test('sizing should be correct after branch demotion #50675', function () {
@@ -306,15 +306,15 @@ suite('Grid', function () {
const view4 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view4, Sizing.Distribute, view3, Direction.Right);
assert.deepEqual(view1.size, [800, 200]);
assert.deepEqual(view2.size, [800, 200]);
assert.deepEqual(view3.size, [400, 200]);
assert.deepEqual(view4.size, [400, 200]);
assert.deepStrictEqual(view1.size, [800, 200]);
assert.deepStrictEqual(view2.size, [800, 200]);
assert.deepStrictEqual(view3.size, [400, 200]);
assert.deepStrictEqual(view4.size, [400, 200]);
grid.removeView(view3, Sizing.Distribute);
assert.deepEqual(view1.size, [800, 200]);
assert.deepEqual(view2.size, [800, 200]);
assert.deepEqual(view4.size, [800, 200]);
assert.deepStrictEqual(view1.size, [800, 200]);
assert.deepStrictEqual(view2.size, [800, 200]);
assert.deepStrictEqual(view4.size, [800, 200]);
});
test('getNeighborViews should work on single view layout', function () {
@@ -324,15 +324,15 @@ suite('Grid', function () {
grid.layout(800, 600);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Up), []);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Right), []);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Down), []);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Left), []);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Up), []);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Right), []);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Down), []);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Left), []);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Up, true), [view1]);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Right, true), [view1]);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Down, true), [view1]);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Left, true), [view1]);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Up, true), [view1]);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Right, true), [view1]);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Down, true), [view1]);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Left, true), [view1]);
});
test('getNeighborViews should work on simple layout', function () {
@@ -348,35 +348,35 @@ suite('Grid', function () {
const view3 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view3, Sizing.Distribute, view2, Direction.Down);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Up), []);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Right), []);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Down), [view2]);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Left), []);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Up), []);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Right), []);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Down), [view2]);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Left), []);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Up, true), [view3]);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Right, true), [view1]);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Down, true), [view2]);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Left, true), [view1]);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Up, true), [view3]);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Right, true), [view1]);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Down, true), [view2]);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Left, true), [view1]);
assert.deepEqual(grid.getNeighborViews(view2, Direction.Up), [view1]);
assert.deepEqual(grid.getNeighborViews(view2, Direction.Right), []);
assert.deepEqual(grid.getNeighborViews(view2, Direction.Down), [view3]);
assert.deepEqual(grid.getNeighborViews(view2, Direction.Left), []);
assert.deepStrictEqual(grid.getNeighborViews(view2, Direction.Up), [view1]);
assert.deepStrictEqual(grid.getNeighborViews(view2, Direction.Right), []);
assert.deepStrictEqual(grid.getNeighborViews(view2, Direction.Down), [view3]);
assert.deepStrictEqual(grid.getNeighborViews(view2, Direction.Left), []);
assert.deepEqual(grid.getNeighborViews(view2, Direction.Up, true), [view1]);
assert.deepEqual(grid.getNeighborViews(view2, Direction.Right, true), [view2]);
assert.deepEqual(grid.getNeighborViews(view2, Direction.Down, true), [view3]);
assert.deepEqual(grid.getNeighborViews(view2, Direction.Left, true), [view2]);
assert.deepStrictEqual(grid.getNeighborViews(view2, Direction.Up, true), [view1]);
assert.deepStrictEqual(grid.getNeighborViews(view2, Direction.Right, true), [view2]);
assert.deepStrictEqual(grid.getNeighborViews(view2, Direction.Down, true), [view3]);
assert.deepStrictEqual(grid.getNeighborViews(view2, Direction.Left, true), [view2]);
assert.deepEqual(grid.getNeighborViews(view3, Direction.Up), [view2]);
assert.deepEqual(grid.getNeighborViews(view3, Direction.Right), []);
assert.deepEqual(grid.getNeighborViews(view3, Direction.Down), []);
assert.deepEqual(grid.getNeighborViews(view3, Direction.Left), []);
assert.deepStrictEqual(grid.getNeighborViews(view3, Direction.Up), [view2]);
assert.deepStrictEqual(grid.getNeighborViews(view3, Direction.Right), []);
assert.deepStrictEqual(grid.getNeighborViews(view3, Direction.Down), []);
assert.deepStrictEqual(grid.getNeighborViews(view3, Direction.Left), []);
assert.deepEqual(grid.getNeighborViews(view3, Direction.Up, true), [view2]);
assert.deepEqual(grid.getNeighborViews(view3, Direction.Right, true), [view3]);
assert.deepEqual(grid.getNeighborViews(view3, Direction.Down, true), [view1]);
assert.deepEqual(grid.getNeighborViews(view3, Direction.Left, true), [view3]);
assert.deepStrictEqual(grid.getNeighborViews(view3, Direction.Up, true), [view2]);
assert.deepStrictEqual(grid.getNeighborViews(view3, Direction.Right, true), [view3]);
assert.deepStrictEqual(grid.getNeighborViews(view3, Direction.Down, true), [view1]);
assert.deepStrictEqual(grid.getNeighborViews(view3, Direction.Left, true), [view3]);
});
test('getNeighborViews should work on a complex layout', function () {
@@ -398,26 +398,26 @@ suite('Grid', function () {
const view5 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view5, Sizing.Distribute, view4, Direction.Down);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Up), []);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Right), []);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Down), [view2, view4]);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Left), []);
assert.deepEqual(grid.getNeighborViews(view2, Direction.Up), [view1]);
assert.deepEqual(grid.getNeighborViews(view2, Direction.Right), [view4, view5]);
assert.deepEqual(grid.getNeighborViews(view2, Direction.Down), [view3]);
assert.deepEqual(grid.getNeighborViews(view2, Direction.Left), []);
assert.deepEqual(grid.getNeighborViews(view4, Direction.Up), [view1]);
assert.deepEqual(grid.getNeighborViews(view4, Direction.Right), []);
assert.deepEqual(grid.getNeighborViews(view4, Direction.Down), [view5]);
assert.deepEqual(grid.getNeighborViews(view4, Direction.Left), [view2]);
assert.deepEqual(grid.getNeighborViews(view5, Direction.Up), [view4]);
assert.deepEqual(grid.getNeighborViews(view5, Direction.Right), []);
assert.deepEqual(grid.getNeighborViews(view5, Direction.Down), [view3]);
assert.deepEqual(grid.getNeighborViews(view5, Direction.Left), [view2]);
assert.deepEqual(grid.getNeighborViews(view3, Direction.Up), [view2, view5]);
assert.deepEqual(grid.getNeighborViews(view3, Direction.Right), []);
assert.deepEqual(grid.getNeighborViews(view3, Direction.Down), []);
assert.deepEqual(grid.getNeighborViews(view3, Direction.Left), []);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Up), []);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Right), []);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Down), [view2, view4]);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Left), []);
assert.deepStrictEqual(grid.getNeighborViews(view2, Direction.Up), [view1]);
assert.deepStrictEqual(grid.getNeighborViews(view2, Direction.Right), [view4, view5]);
assert.deepStrictEqual(grid.getNeighborViews(view2, Direction.Down), [view3]);
assert.deepStrictEqual(grid.getNeighborViews(view2, Direction.Left), []);
assert.deepStrictEqual(grid.getNeighborViews(view4, Direction.Up), [view1]);
assert.deepStrictEqual(grid.getNeighborViews(view4, Direction.Right), []);
assert.deepStrictEqual(grid.getNeighborViews(view4, Direction.Down), [view5]);
assert.deepStrictEqual(grid.getNeighborViews(view4, Direction.Left), [view2]);
assert.deepStrictEqual(grid.getNeighborViews(view5, Direction.Up), [view4]);
assert.deepStrictEqual(grid.getNeighborViews(view5, Direction.Right), []);
assert.deepStrictEqual(grid.getNeighborViews(view5, Direction.Down), [view3]);
assert.deepStrictEqual(grid.getNeighborViews(view5, Direction.Left), [view2]);
assert.deepStrictEqual(grid.getNeighborViews(view3, Direction.Up), [view2, view5]);
assert.deepStrictEqual(grid.getNeighborViews(view3, Direction.Right), []);
assert.deepStrictEqual(grid.getNeighborViews(view3, Direction.Down), []);
assert.deepStrictEqual(grid.getNeighborViews(view3, Direction.Left), []);
});
test('getNeighborViews should work on another simple layout', function () {
@@ -436,10 +436,10 @@ suite('Grid', function () {
const view4 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view4, Sizing.Distribute, view2, Direction.Right);
assert.deepEqual(grid.getNeighborViews(view4, Direction.Up), []);
assert.deepEqual(grid.getNeighborViews(view4, Direction.Right), []);
assert.deepEqual(grid.getNeighborViews(view4, Direction.Down), [view3]);
assert.deepEqual(grid.getNeighborViews(view4, Direction.Left), [view2]);
assert.deepStrictEqual(grid.getNeighborViews(view4, Direction.Up), []);
assert.deepStrictEqual(grid.getNeighborViews(view4, Direction.Right), []);
assert.deepStrictEqual(grid.getNeighborViews(view4, Direction.Down), [view3]);
assert.deepStrictEqual(grid.getNeighborViews(view4, Direction.Left), [view2]);
});
test('getNeighborViews should only return immediate neighbors', function () {
@@ -458,7 +458,7 @@ suite('Grid', function () {
const view4 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view4, Sizing.Distribute, view2, Direction.Right);
assert.deepEqual(grid.getNeighborViews(view1, Direction.Right), [view2, view3]);
assert.deepStrictEqual(grid.getNeighborViews(view1, Direction.Right), [view2, view3]);
});
});
@@ -524,7 +524,7 @@ suite('SerializableGrid', function () {
grid.layout(800, 600);
const actual = grid.serialize();
assert.deepEqual(actual, {
assert.deepStrictEqual(actual, {
orientation: 0,
width: 800,
height: 600,
@@ -562,7 +562,7 @@ suite('SerializableGrid', function () {
const view5 = new TestSerializableView('view5', 50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view5, 100, view1, Direction.Down);
assert.deepEqual(grid.serialize(), {
assert.deepStrictEqual(grid.serialize(), {
orientation: 0,
width: 800,
height: 600,
@@ -611,7 +611,7 @@ suite('SerializableGrid', function () {
const grid2 = SerializableGrid.deserialize(json, deserializer);
grid2.layout(800, 600);
assert.deepEqual(nodesToNames(grid2.getViews()), ['view1']);
assert.deepStrictEqual(nodesToNames(grid2.getViews()), ['view1']);
});
test('deserialize simple layout', function () {
@@ -645,15 +645,15 @@ suite('SerializableGrid', function () {
const view4Copy = deserializer.getView('view4');
const view5Copy = deserializer.getView('view5');
assert.deepEqual(nodesToArrays(grid2.getViews()), [[view4Copy, view2Copy], [[view1Copy, view5Copy], view3Copy]]);
assert.deepStrictEqual(nodesToArrays(grid2.getViews()), [[view4Copy, view2Copy], [[view1Copy, view5Copy], view3Copy]]);
grid2.layout(800, 600);
assert.deepEqual(view1Copy.size, [600, 300]);
assert.deepEqual(view2Copy.size, [600, 200]);
assert.deepEqual(view3Copy.size, [200, 400]);
assert.deepEqual(view4Copy.size, [200, 200]);
assert.deepEqual(view5Copy.size, [600, 100]);
assert.deepStrictEqual(view1Copy.size, [600, 300]);
assert.deepStrictEqual(view2Copy.size, [600, 200]);
assert.deepStrictEqual(view3Copy.size, [200, 400]);
assert.deepStrictEqual(view4Copy.size, [200, 200]);
assert.deepStrictEqual(view5Copy.size, [600, 100]);
});
test('deserialize simple layout with scaling', function () {
@@ -688,11 +688,11 @@ suite('SerializableGrid', function () {
const view5Copy = deserializer.getView('view5');
grid2.layout(400, 800); // [/2, *4/3]
assert.deepEqual(view1Copy.size, [300, 400]);
assert.deepEqual(view2Copy.size, [300, 267]);
assert.deepEqual(view3Copy.size, [100, 533]);
assert.deepEqual(view4Copy.size, [100, 267]);
assert.deepEqual(view5Copy.size, [300, 133]);
assert.deepStrictEqual(view1Copy.size, [300, 400]);
assert.deepStrictEqual(view2Copy.size, [300, 267]);
assert.deepStrictEqual(view3Copy.size, [100, 533]);
assert.deepStrictEqual(view4Copy.size, [100, 267]);
assert.deepStrictEqual(view5Copy.size, [300, 133]);
});
test('deserialize 4 view layout (ben issue #2)', function () {
@@ -723,10 +723,10 @@ suite('SerializableGrid', function () {
grid2.layout(800, 600);
assert.deepEqual(view1Copy.size, [800, 300]);
assert.deepEqual(view2Copy.size, [800, 150]);
assert.deepEqual(view3Copy.size, [400, 150]);
assert.deepEqual(view4Copy.size, [400, 150]);
assert.deepStrictEqual(view1Copy.size, [800, 300]);
assert.deepStrictEqual(view2Copy.size, [800, 150]);
assert.deepStrictEqual(view3Copy.size, [400, 150]);
assert.deepStrictEqual(view4Copy.size, [400, 150]);
});
test('deserialize 2 view layout (ben issue #3)', function () {
@@ -750,8 +750,8 @@ suite('SerializableGrid', function () {
grid2.layout(800, 600);
assert.deepEqual(view1Copy.size, [400, 600]);
assert.deepEqual(view2Copy.size, [400, 600]);
assert.deepStrictEqual(view1Copy.size, [400, 600]);
assert.deepStrictEqual(view2Copy.size, [400, 600]);
});
test('deserialize simple view layout #50609', function () {
@@ -780,21 +780,21 @@ suite('SerializableGrid', function () {
grid2.layout(800, 600);
assert.deepEqual(view2Copy.size, [800, 300]);
assert.deepEqual(view3Copy.size, [800, 300]);
assert.deepStrictEqual(view2Copy.size, [800, 300]);
assert.deepStrictEqual(view3Copy.size, [800, 300]);
});
test('sanitizeGridNodeDescriptor', () => {
const nodeDescriptor = { groups: [{ size: 0.2 }, { size: 0.2 }, { size: 0.6, groups: [{}, {}] }] };
const nodeDescriptorCopy = deepClone<GridNodeDescriptor>(nodeDescriptor);
sanitizeGridNodeDescriptor(nodeDescriptorCopy, true);
assert.deepEqual(nodeDescriptorCopy, { groups: [{ size: 0.2 }, { size: 0.2 }, { size: 0.6, groups: [{ size: 0.5 }, { size: 0.5 }] }] });
assert.deepStrictEqual(nodeDescriptorCopy, { groups: [{ size: 0.2 }, { size: 0.2 }, { size: 0.6, groups: [{ size: 0.5 }, { size: 0.5 }] }] });
});
test('createSerializedGrid', () => {
const gridDescriptor = { orientation: Orientation.VERTICAL, groups: [{ size: 0.2 }, { size: 0.2 }, { size: 0.6, groups: [{}, {}] }] };
const serializedGrid = createSerializedGrid(gridDescriptor);
assert.deepEqual(serializedGrid, {
assert.deepStrictEqual(serializedGrid, {
root: {
type: 'branch',
size: undefined,
@@ -836,7 +836,7 @@ suite('SerializableGrid', function () {
};
const grid = SerializableGrid.deserialize(serializedGrid, deserializer);
assert.equal(views.length, 3);
assert.strictEqual(views.length, 3);
// should not throw
grid.removeView(views[2]);
@@ -860,40 +860,40 @@ suite('SerializableGrid', function () {
const view5 = new TestSerializableView('view5', 50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view5, 100, view1, Direction.Down);
assert.deepEqual(view1.size, [600, 300]);
assert.deepEqual(view2.size, [600, 200]);
assert.deepEqual(view3.size, [200, 400]);
assert.deepEqual(view4.size, [200, 200]);
assert.deepEqual(view5.size, [600, 100]);
assert.deepStrictEqual(view1.size, [600, 300]);
assert.deepStrictEqual(view2.size, [600, 200]);
assert.deepStrictEqual(view3.size, [200, 400]);
assert.deepStrictEqual(view4.size, [200, 200]);
assert.deepStrictEqual(view5.size, [600, 100]);
grid.setViewVisible(view5, false);
assert.deepEqual(view1.size, [600, 400]);
assert.deepEqual(view2.size, [600, 200]);
assert.deepEqual(view3.size, [200, 400]);
assert.deepEqual(view4.size, [200, 200]);
assert.deepEqual(view5.size, [600, 0]);
assert.deepStrictEqual(view1.size, [600, 400]);
assert.deepStrictEqual(view2.size, [600, 200]);
assert.deepStrictEqual(view3.size, [200, 400]);
assert.deepStrictEqual(view4.size, [200, 200]);
assert.deepStrictEqual(view5.size, [600, 0]);
grid.setViewVisible(view5, true);
assert.deepEqual(view1.size, [600, 300]);
assert.deepEqual(view2.size, [600, 200]);
assert.deepEqual(view3.size, [200, 400]);
assert.deepEqual(view4.size, [200, 200]);
assert.deepEqual(view5.size, [600, 100]);
assert.deepStrictEqual(view1.size, [600, 300]);
assert.deepStrictEqual(view2.size, [600, 200]);
assert.deepStrictEqual(view3.size, [200, 400]);
assert.deepStrictEqual(view4.size, [200, 200]);
assert.deepStrictEqual(view5.size, [600, 100]);
grid.setViewVisible(view5, false);
assert.deepEqual(view1.size, [600, 400]);
assert.deepEqual(view2.size, [600, 200]);
assert.deepEqual(view3.size, [200, 400]);
assert.deepEqual(view4.size, [200, 200]);
assert.deepEqual(view5.size, [600, 0]);
assert.deepStrictEqual(view1.size, [600, 400]);
assert.deepStrictEqual(view2.size, [600, 200]);
assert.deepStrictEqual(view3.size, [200, 400]);
assert.deepStrictEqual(view4.size, [200, 200]);
assert.deepStrictEqual(view5.size, [600, 0]);
grid.setViewVisible(view5, false);
const json = grid.serialize();
assert.deepEqual(json, {
assert.deepStrictEqual(json, {
orientation: 0,
width: 800,
height: 600,
@@ -939,34 +939,34 @@ suite('SerializableGrid', function () {
const view4Copy = deserializer.getView('view4');
const view5Copy = deserializer.getView('view5');
assert.deepEqual(nodesToArrays(grid2.getViews()), [[view4Copy, view2Copy], [[view1Copy, view5Copy], view3Copy]]);
assert.deepStrictEqual(nodesToArrays(grid2.getViews()), [[view4Copy, view2Copy], [[view1Copy, view5Copy], view3Copy]]);
grid2.layout(800, 600);
assert.deepEqual(view1Copy.size, [600, 400]);
assert.deepEqual(view2Copy.size, [600, 200]);
assert.deepEqual(view3Copy.size, [200, 400]);
assert.deepEqual(view4Copy.size, [200, 200]);
assert.deepEqual(view5Copy.size, [600, 0]);
assert.deepStrictEqual(view1Copy.size, [600, 400]);
assert.deepStrictEqual(view2Copy.size, [600, 200]);
assert.deepStrictEqual(view3Copy.size, [200, 400]);
assert.deepStrictEqual(view4Copy.size, [200, 200]);
assert.deepStrictEqual(view5Copy.size, [600, 0]);
assert.deepEqual(grid2.isViewVisible(view1Copy), true);
assert.deepEqual(grid2.isViewVisible(view2Copy), true);
assert.deepEqual(grid2.isViewVisible(view3Copy), true);
assert.deepEqual(grid2.isViewVisible(view4Copy), true);
assert.deepEqual(grid2.isViewVisible(view5Copy), false);
assert.deepStrictEqual(grid2.isViewVisible(view1Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view2Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view3Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view4Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view5Copy), false);
grid2.setViewVisible(view5Copy, true);
assert.deepEqual(view1Copy.size, [600, 300]);
assert.deepEqual(view2Copy.size, [600, 200]);
assert.deepEqual(view3Copy.size, [200, 400]);
assert.deepEqual(view4Copy.size, [200, 200]);
assert.deepEqual(view5Copy.size, [600, 100]);
assert.deepStrictEqual(view1Copy.size, [600, 300]);
assert.deepStrictEqual(view2Copy.size, [600, 200]);
assert.deepStrictEqual(view3Copy.size, [200, 400]);
assert.deepStrictEqual(view4Copy.size, [200, 200]);
assert.deepStrictEqual(view5Copy.size, [600, 100]);
assert.deepEqual(grid2.isViewVisible(view1Copy), true);
assert.deepEqual(grid2.isViewVisible(view2Copy), true);
assert.deepEqual(grid2.isViewVisible(view3Copy), true);
assert.deepEqual(grid2.isViewVisible(view4Copy), true);
assert.deepEqual(grid2.isViewVisible(view5Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view1Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view2Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view3Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view4Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view5Copy), true);
});
test('serialize should store visibility and previous size even for first leaf', function () {
@@ -987,22 +987,22 @@ suite('SerializableGrid', function () {
const view5 = new TestSerializableView('view5', 50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
grid.addView(view5, 100, view1, Direction.Down);
assert.deepEqual(view1.size, [600, 300]);
assert.deepEqual(view2.size, [600, 200]);
assert.deepEqual(view3.size, [200, 400]);
assert.deepEqual(view4.size, [200, 200]);
assert.deepEqual(view5.size, [600, 100]);
assert.deepStrictEqual(view1.size, [600, 300]);
assert.deepStrictEqual(view2.size, [600, 200]);
assert.deepStrictEqual(view3.size, [200, 400]);
assert.deepStrictEqual(view4.size, [200, 200]);
assert.deepStrictEqual(view5.size, [600, 100]);
grid.setViewVisible(view4, false);
assert.deepEqual(view1.size, [600, 300]);
assert.deepEqual(view2.size, [800, 200]);
assert.deepEqual(view3.size, [200, 400]);
assert.deepEqual(view4.size, [0, 200]);
assert.deepEqual(view5.size, [600, 100]);
assert.deepStrictEqual(view1.size, [600, 300]);
assert.deepStrictEqual(view2.size, [800, 200]);
assert.deepStrictEqual(view3.size, [200, 400]);
assert.deepStrictEqual(view4.size, [0, 200]);
assert.deepStrictEqual(view5.size, [600, 100]);
const json = grid.serialize();
assert.deepEqual(json, {
assert.deepStrictEqual(json, {
orientation: 0,
width: 800,
height: 600,
@@ -1048,33 +1048,33 @@ suite('SerializableGrid', function () {
const view4Copy = deserializer.getView('view4');
const view5Copy = deserializer.getView('view5');
assert.deepEqual(nodesToArrays(grid2.getViews()), [[view4Copy, view2Copy], [[view1Copy, view5Copy], view3Copy]]);
assert.deepStrictEqual(nodesToArrays(grid2.getViews()), [[view4Copy, view2Copy], [[view1Copy, view5Copy], view3Copy]]);
grid2.layout(800, 600);
assert.deepEqual(view1Copy.size, [600, 300]);
assert.deepEqual(view2Copy.size, [800, 200]);
assert.deepEqual(view3Copy.size, [200, 400]);
assert.deepEqual(view4Copy.size, [0, 200]);
assert.deepEqual(view5Copy.size, [600, 100]);
assert.deepStrictEqual(view1Copy.size, [600, 300]);
assert.deepStrictEqual(view2Copy.size, [800, 200]);
assert.deepStrictEqual(view3Copy.size, [200, 400]);
assert.deepStrictEqual(view4Copy.size, [0, 200]);
assert.deepStrictEqual(view5Copy.size, [600, 100]);
assert.deepEqual(grid2.isViewVisible(view1Copy), true);
assert.deepEqual(grid2.isViewVisible(view2Copy), true);
assert.deepEqual(grid2.isViewVisible(view3Copy), true);
assert.deepEqual(grid2.isViewVisible(view4Copy), false);
assert.deepEqual(grid2.isViewVisible(view5Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view1Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view2Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view3Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view4Copy), false);
assert.deepStrictEqual(grid2.isViewVisible(view5Copy), true);
grid2.setViewVisible(view4Copy, true);
assert.deepEqual(view1Copy.size, [600, 300]);
assert.deepEqual(view2Copy.size, [600, 200]);
assert.deepEqual(view3Copy.size, [200, 400]);
assert.deepEqual(view4Copy.size, [200, 200]);
assert.deepEqual(view5Copy.size, [600, 100]);
assert.deepStrictEqual(view1Copy.size, [600, 300]);
assert.deepStrictEqual(view2Copy.size, [600, 200]);
assert.deepStrictEqual(view3Copy.size, [200, 400]);
assert.deepStrictEqual(view4Copy.size, [200, 200]);
assert.deepStrictEqual(view5Copy.size, [600, 100]);
assert.deepEqual(grid2.isViewVisible(view1Copy), true);
assert.deepEqual(grid2.isViewVisible(view2Copy), true);
assert.deepEqual(grid2.isViewVisible(view3Copy), true);
assert.deepEqual(grid2.isViewVisible(view4Copy), true);
assert.deepEqual(grid2.isViewVisible(view5Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view1Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view2Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view3Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view4Copy), true);
assert.deepStrictEqual(grid2.isViewVisible(view5Copy), true);
});
});

126
lib/vscode/src/vs/base/test/browser/ui/grid/gridview.test.ts
View File

@@ -22,7 +22,7 @@ suite('Gridview', function () {
});
test('empty gridview is empty', function () {
assert.deepEqual(nodesToArrays(gridview.getView()), []);
assert.deepStrictEqual(nodesToArrays(gridview.getView()), []);
gridview.dispose();
});
@@ -43,7 +43,7 @@ suite('Gridview', function () {
gridview.addView(views[1], 200, [1]);
gridview.addView(views[2], 200, [2]);
assert.deepEqual(nodesToArrays(gridview.getView()), views);
assert.deepStrictEqual(nodesToArrays(gridview.getView()), views);
gridview.dispose();
});
@@ -62,7 +62,7 @@ suite('Gridview', function () {
gridview.addView((views[1] as TestView[])[0] as IView, 200, [1]);
gridview.addView((views[1] as TestView[])[1] as IView, 200, [1, 1]);
assert.deepEqual(nodesToArrays(gridview.getView()), views);
assert.deepStrictEqual(nodesToArrays(gridview.getView()), views);
gridview.dispose();
});
@@ -71,35 +71,35 @@ suite('Gridview', function () {
const view1 = new TestView(20, 20, 20, 20);
gridview.addView(view1 as IView, 200, [0]);
assert.deepEqual(nodesToArrays(gridview.getView()), [view1]);
assert.deepStrictEqual(nodesToArrays(gridview.getView()), [view1]);
const view2 = new TestView(20, 20, 20, 20);
gridview.addView(view2 as IView, 200, [1]);
assert.deepEqual(nodesToArrays(gridview.getView()), [view1, view2]);
assert.deepStrictEqual(nodesToArrays(gridview.getView()), [view1, view2]);
const view3 = new TestView(20, 20, 20, 20);
gridview.addView(view3 as IView, 200, [1, 0]);
assert.deepEqual(nodesToArrays(gridview.getView()), [view1, [view3, view2]]);
assert.deepStrictEqual(nodesToArrays(gridview.getView()), [view1, [view3, view2]]);
const view4 = new TestView(20, 20, 20, 20);
gridview.addView(view4 as IView, 200, [1, 0, 0]);
assert.deepEqual(nodesToArrays(gridview.getView()), [view1, [[view4, view3], view2]]);
assert.deepStrictEqual(nodesToArrays(gridview.getView()), [view1, [[view4, view3], view2]]);
const view5 = new TestView(20, 20, 20, 20);
gridview.addView(view5 as IView, 200, [1, 0]);
assert.deepEqual(nodesToArrays(gridview.getView()), [view1, [view5, [view4, view3], view2]]);
assert.deepStrictEqual(nodesToArrays(gridview.getView()), [view1, [view5, [view4, view3], view2]]);
const view6 = new TestView(20, 20, 20, 20);
gridview.addView(view6 as IView, 200, [2]);
assert.deepEqual(nodesToArrays(gridview.getView()), [view1, [view5, [view4, view3], view2], view6]);
assert.deepStrictEqual(nodesToArrays(gridview.getView()), [view1, [view5, [view4, view3], view2], view6]);
const view7 = new TestView(20, 20, 20, 20);
gridview.addView(view7 as IView, 200, [1, 1]);
assert.deepEqual(nodesToArrays(gridview.getView()), [view1, [view5, view7, [view4, view3], view2], view6]);
assert.deepStrictEqual(nodesToArrays(gridview.getView()), [view1, [view5, view7, [view4, view3], view2], view6]);
const view8 = new TestView(20, 20, 20, 20);
gridview.addView(view8 as IView, 200, [1, 1, 0]);
assert.deepEqual(nodesToArrays(gridview.getView()), [view1, [view5, [view8, view7], [view4, view3], view2], view6]);
assert.deepStrictEqual(nodesToArrays(gridview.getView()), [view1, [view5, [view8, view7], [view4, view3], view2], view6]);
gridview.dispose();
});
@@ -109,48 +109,48 @@ suite('Gridview', function () {
const view1 = new TestView(50, Number.POSITIVE_INFINITY, 50, Number.POSITIVE_INFINITY);
gridview.addView(view1, 200, [0]);
assert.deepEqual(view1.size, [800, 600]);
assert.deepEqual(gridview.getViewSize([0]), { width: 800, height: 600 });
assert.deepStrictEqual(view1.size, [800, 600]);
assert.deepStrictEqual(gridview.getViewSize([0]), { width: 800, height: 600 });
const view2 = new TestView(50, Number.POSITIVE_INFINITY, 50, Number.POSITIVE_INFINITY);
gridview.addView(view2, 200, [0]);
assert.deepEqual(view1.size, [800, 400]);
assert.deepEqual(gridview.getViewSize([1]), { width: 800, height: 400 });
assert.deepEqual(view2.size, [800, 200]);
assert.deepEqual(gridview.getViewSize([0]), { width: 800, height: 200 });
assert.deepStrictEqual(view1.size, [800, 400]);
assert.deepStrictEqual(gridview.getViewSize([1]), { width: 800, height: 400 });
assert.deepStrictEqual(view2.size, [800, 200]);
assert.deepStrictEqual(gridview.getViewSize([0]), { width: 800, height: 200 });
const view3 = new TestView(50, Number.POSITIVE_INFINITY, 50, Number.POSITIVE_INFINITY);
gridview.addView(view3, 200, [1, 1]);
assert.deepEqual(view1.size, [600, 400]);
assert.deepEqual(gridview.getViewSize([1, 0]), { width: 600, height: 400 });
assert.deepEqual(view2.size, [800, 200]);
assert.deepEqual(gridview.getViewSize([0]), { width: 800, height: 200 });
assert.deepEqual(view3.size, [200, 400]);
assert.deepEqual(gridview.getViewSize([1, 1]), { width: 200, height: 400 });
assert.deepStrictEqual(view1.size, [600, 400]);
assert.deepStrictEqual(gridview.getViewSize([1, 0]), { width: 600, height: 400 });
assert.deepStrictEqual(view2.size, [800, 200]);
assert.deepStrictEqual(gridview.getViewSize([0]), { width: 800, height: 200 });
assert.deepStrictEqual(view3.size, [200, 400]);
assert.deepStrictEqual(gridview.getViewSize([1, 1]), { width: 200, height: 400 });
const view4 = new TestView(50, Number.POSITIVE_INFINITY, 50, Number.POSITIVE_INFINITY);
gridview.addView(view4, 200, [0, 0]);
assert.deepEqual(view1.size, [600, 400]);
assert.deepEqual(gridview.getViewSize([1, 0]), { width: 600, height: 400 });
assert.deepEqual(view2.size, [600, 200]);
assert.deepEqual(gridview.getViewSize([0, 1]), { width: 600, height: 200 });
assert.deepEqual(view3.size, [200, 400]);
assert.deepEqual(gridview.getViewSize([1, 1]), { width: 200, height: 400 });
assert.deepEqual(view4.size, [200, 200]);
assert.deepEqual(gridview.getViewSize([0, 0]), { width: 200, height: 200 });
assert.deepStrictEqual(view1.size, [600, 400]);
assert.deepStrictEqual(gridview.getViewSize([1, 0]), { width: 600, height: 400 });
assert.deepStrictEqual(view2.size, [600, 200]);
assert.deepStrictEqual(gridview.getViewSize([0, 1]), { width: 600, height: 200 });
assert.deepStrictEqual(view3.size, [200, 400]);
assert.deepStrictEqual(gridview.getViewSize([1, 1]), { width: 200, height: 400 });
assert.deepStrictEqual(view4.size, [200, 200]);
assert.deepStrictEqual(gridview.getViewSize([0, 0]), { width: 200, height: 200 });
const view5 = new TestView(50, Number.POSITIVE_INFINITY, 50, Number.POSITIVE_INFINITY);
gridview.addView(view5, 100, [1, 0, 1]);
assert.deepEqual(view1.size, [600, 300]);
assert.deepEqual(gridview.getViewSize([1, 0, 0]), { width: 600, height: 300 });
assert.deepEqual(view2.size, [600, 200]);
assert.deepEqual(gridview.getViewSize([0, 1]), { width: 600, height: 200 });
assert.deepEqual(view3.size, [200, 400]);
assert.deepEqual(gridview.getViewSize([1, 1]), { width: 200, height: 400 });
assert.deepEqual(view4.size, [200, 200]);
assert.deepEqual(gridview.getViewSize([0, 0]), { width: 200, height: 200 });
assert.deepEqual(view5.size, [600, 100]);
assert.deepEqual(gridview.getViewSize([1, 0, 1]), { width: 600, height: 100 });
assert.deepStrictEqual(view1.size, [600, 300]);
assert.deepStrictEqual(gridview.getViewSize([1, 0, 0]), { width: 600, height: 300 });
assert.deepStrictEqual(view2.size, [600, 200]);
assert.deepStrictEqual(gridview.getViewSize([0, 1]), { width: 600, height: 200 });
assert.deepStrictEqual(view3.size, [200, 400]);
assert.deepStrictEqual(gridview.getViewSize([1, 1]), { width: 200, height: 400 });
assert.deepStrictEqual(view4.size, [200, 200]);
assert.deepStrictEqual(gridview.getViewSize([0, 0]), { width: 200, height: 200 });
assert.deepStrictEqual(view5.size, [600, 100]);
assert.deepStrictEqual(gridview.getViewSize([1, 0, 1]), { width: 600, height: 100 });
});
test('simple layout with automatic size distribution', function () {
@@ -158,34 +158,34 @@ suite('Gridview', function () {
const view1 = new TestView(50, Number.POSITIVE_INFINITY, 50, Number.POSITIVE_INFINITY);
gridview.addView(view1, Sizing.Distribute, [0]);
assert.deepEqual(view1.size, [800, 600]);
assert.deepEqual(gridview.getViewSize([0]), { width: 800, height: 600 });
assert.deepStrictEqual(view1.size, [800, 600]);
assert.deepStrictEqual(gridview.getViewSize([0]), { width: 800, height: 600 });
const view2 = new TestView(50, Number.POSITIVE_INFINITY, 50, Number.POSITIVE_INFINITY);
gridview.addView(view2, Sizing.Distribute, [0]);
assert.deepEqual(view1.size, [800, 300]);
assert.deepEqual(view2.size, [800, 300]);
assert.deepStrictEqual(view1.size, [800, 300]);
assert.deepStrictEqual(view2.size, [800, 300]);
const view3 = new TestView(50, Number.POSITIVE_INFINITY, 50, Number.POSITIVE_INFINITY);
gridview.addView(view3, Sizing.Distribute, [1, 1]);
assert.deepEqual(view1.size, [400, 300]);
assert.deepEqual(view2.size, [800, 300]);
assert.deepEqual(view3.size, [400, 300]);
assert.deepStrictEqual(view1.size, [400, 300]);
assert.deepStrictEqual(view2.size, [800, 300]);
assert.deepStrictEqual(view3.size, [400, 300]);
const view4 = new TestView(50, Number.POSITIVE_INFINITY, 50, Number.POSITIVE_INFINITY);
gridview.addView(view4, Sizing.Distribute, [0, 0]);
assert.deepEqual(view1.size, [400, 300]);
assert.deepEqual(view2.size, [400, 300]);
assert.deepEqual(view3.size, [400, 300]);
assert.deepEqual(view4.size, [400, 300]);
assert.deepStrictEqual(view1.size, [400, 300]);
assert.deepStrictEqual(view2.size, [400, 300]);
assert.deepStrictEqual(view3.size, [400, 300]);
assert.deepStrictEqual(view4.size, [400, 300]);
const view5 = new TestView(50, Number.POSITIVE_INFINITY, 50, Number.POSITIVE_INFINITY);
gridview.addView(view5, Sizing.Distribute, [1, 0, 1]);
assert.deepEqual(view1.size, [400, 150]);
assert.deepEqual(view2.size, [400, 300]);
assert.deepEqual(view3.size, [400, 300]);
assert.deepEqual(view4.size, [400, 300]);
assert.deepEqual(view5.size, [400, 150]);
assert.deepStrictEqual(view1.size, [400, 150]);
assert.deepStrictEqual(view2.size, [400, 300]);
assert.deepStrictEqual(view3.size, [400, 300]);
assert.deepStrictEqual(view4.size, [400, 300]);
assert.deepStrictEqual(view5.size, [400, 150]);
});
test('addviews before layout call 1', function () {
@@ -201,9 +201,9 @@ suite('Gridview', function () {
gridview.layout(800, 600);
assert.deepEqual(view1.size, [400, 300]);
assert.deepEqual(view2.size, [800, 300]);
assert.deepEqual(view3.size, [400, 300]);
assert.deepStrictEqual(view1.size, [400, 300]);
assert.deepStrictEqual(view2.size, [800, 300]);
assert.deepStrictEqual(view3.size, [400, 300]);
});
test('addviews before layout call 2', function () {
@@ -218,8 +218,8 @@ suite('Gridview', function () {
gridview.layout(800, 600);
assert.deepEqual(view1.size, [800, 300]);
assert.deepEqual(view2.size, [400, 300]);
assert.deepEqual(view3.size, [400, 300]);
assert.deepStrictEqual(view1.size, [800, 300]);
assert.deepStrictEqual(view2.size, [400, 300]);
assert.deepStrictEqual(view3.size, [400, 300]);
});
});

8
lib/vscode/src/vs/base/test/browser/ui/list/listView.test.ts
View File

@@ -31,10 +31,10 @@ suite('ListView', function () {
const listView = new ListView<number>(element, delegate, [renderer]);
listView.layout(200);
assert.equal(templatesCount, 0, 'no templates have been allocated');
assert.strictEqual(templatesCount, 0, 'no templates have been allocated');
listView.splice(0, 0, range(100));
assert.equal(templatesCount, 10, 'some templates have been allocated');
assert.strictEqual(templatesCount, 10, 'some templates have been allocated');
listView.dispose();
assert.equal(templatesCount, 0, 'all templates have been disposed');
assert.strictEqual(templatesCount, 0, 'all templates have been disposed');
});
});
});

236
lib/vscode/src/vs/base/test/browser/ui/list/rangeMap.test.ts
View File

@@ -15,24 +15,24 @@ suite('RangeMap', () => {
});
test('intersection', () => {
assert.deepEqual(Range.intersect({ start: 0, end: 0 }, { start: 0, end: 0 }), { start: 0, end: 0 });
assert.deepEqual(Range.intersect({ start: 0, end: 0 }, { start: 5, end: 5 }), { start: 0, end: 0 });
assert.deepEqual(Range.intersect({ start: 0, end: 1 }, { start: 5, end: 6 }), { start: 0, end: 0 });
assert.deepEqual(Range.intersect({ start: 5, end: 6 }, { start: 0, end: 1 }), { start: 0, end: 0 });
assert.deepEqual(Range.intersect({ start: 0, end: 5 }, { start: 2, end: 2 }), { start: 0, end: 0 });
assert.deepEqual(Range.intersect({ start: 0, end: 1 }, { start: 0, end: 1 }), { start: 0, end: 1 });
assert.deepEqual(Range.intersect({ start: 0, end: 10 }, { start: 0, end: 5 }), { start: 0, end: 5 });
assert.deepEqual(Range.intersect({ start: 0, end: 5 }, { start: 0, end: 10 }), { start: 0, end: 5 });
assert.deepEqual(Range.intersect({ start: 0, end: 10 }, { start: 5, end: 10 }), { start: 5, end: 10 });
assert.deepEqual(Range.intersect({ start: 5, end: 10 }, { start: 0, end: 10 }), { start: 5, end: 10 });
assert.deepEqual(Range.intersect({ start: 0, end: 10 }, { start: 2, end: 8 }), { start: 2, end: 8 });
assert.deepEqual(Range.intersect({ start: 2, end: 8 }, { start: 0, end: 10 }), { start: 2, end: 8 });
assert.deepEqual(Range.intersect({ start: 0, end: 10 }, { start: 5, end: 15 }), { start: 5, end: 10 });
assert.deepEqual(Range.intersect({ start: 5, end: 15 }, { start: 0, end: 10 }), { start: 5, end: 10 });
assert.deepStrictEqual(Range.intersect({ start: 0, end: 0 }, { start: 0, end: 0 }), { start: 0, end: 0 });
assert.deepStrictEqual(Range.intersect({ start: 0, end: 0 }, { start: 5, end: 5 }), { start: 0, end: 0 });
assert.deepStrictEqual(Range.intersect({ start: 0, end: 1 }, { start: 5, end: 6 }), { start: 0, end: 0 });
assert.deepStrictEqual(Range.intersect({ start: 5, end: 6 }, { start: 0, end: 1 }), { start: 0, end: 0 });
assert.deepStrictEqual(Range.intersect({ start: 0, end: 5 }, { start: 2, end: 2 }), { start: 0, end: 0 });
assert.deepStrictEqual(Range.intersect({ start: 0, end: 1 }, { start: 0, end: 1 }), { start: 0, end: 1 });
assert.deepStrictEqual(Range.intersect({ start: 0, end: 10 }, { start: 0, end: 5 }), { start: 0, end: 5 });
assert.deepStrictEqual(Range.intersect({ start: 0, end: 5 }, { start: 0, end: 10 }), { start: 0, end: 5 });
assert.deepStrictEqual(Range.intersect({ start: 0, end: 10 }, { start: 5, end: 10 }), { start: 5, end: 10 });
assert.deepStrictEqual(Range.intersect({ start: 5, end: 10 }, { start: 0, end: 10 }), { start: 5, end: 10 });
assert.deepStrictEqual(Range.intersect({ start: 0, end: 10 }, { start: 2, end: 8 }), { start: 2, end: 8 });
assert.deepStrictEqual(Range.intersect({ start: 2, end: 8 }, { start: 0, end: 10 }), { start: 2, end: 8 });
assert.deepStrictEqual(Range.intersect({ start: 0, end: 10 }, { start: 5, end: 15 }), { start: 5, end: 10 });
assert.deepStrictEqual(Range.intersect({ start: 5, end: 15 }, { start: 0, end: 10 }), { start: 5, end: 10 });
});
test('multiIntersect', () => {
assert.deepEqual(
assert.deepStrictEqual(
groupIntersect(
{ start: 0, end: 0 },
[{ range: { start: 0, end: 10 }, size: 1 }]
@@ -40,7 +40,7 @@ suite('RangeMap', () => {
[]
);
assert.deepEqual(
assert.deepStrictEqual(
groupIntersect(
{ start: 10, end: 20 },
[{ range: { start: 0, end: 10 }, size: 1 }]
@@ -48,7 +48,7 @@ suite('RangeMap', () => {
[]
);
assert.deepEqual(
assert.deepStrictEqual(
groupIntersect(
{ start: 2, end: 8 },
[{ range: { start: 0, end: 10 }, size: 1 }]
@@ -56,7 +56,7 @@ suite('RangeMap', () => {
[{ range: { start: 2, end: 8 }, size: 1 }]
);
assert.deepEqual(
assert.deepStrictEqual(
groupIntersect(
{ start: 2, end: 8 },
[{ range: { start: 0, end: 10 }, size: 1 }, { range: { start: 10, end: 20 }, size: 5 }]
@@ -64,7 +64,7 @@ suite('RangeMap', () => {
[{ range: { start: 2, end: 8 }, size: 1 }]
);
assert.deepEqual(
assert.deepStrictEqual(
groupIntersect(
{ start: 12, end: 18 },
[{ range: { start: 0, end: 10 }, size: 1 }, { range: { start: 10, end: 20 }, size: 5 }]
@@ -72,7 +72,7 @@ suite('RangeMap', () => {
[{ range: { start: 12, end: 18 }, size: 5 }]
);
assert.deepEqual(
assert.deepStrictEqual(
groupIntersect(
{ start: 2, end: 18 },
[{ range: { start: 0, end: 10 }, size: 1 }, { range: { start: 10, end: 20 }, size: 5 }]
@@ -80,7 +80,7 @@ suite('RangeMap', () => {
[{ range: { start: 2, end: 10 }, size: 1 }, { range: { start: 10, end: 18 }, size: 5 }]
);
assert.deepEqual(
assert.deepStrictEqual(
groupIntersect(
{ start: 2, end: 28 },
[{ range: { start: 0, end: 10 }, size: 1 }, { range: { start: 10, end: 20 }, size: 5 }, { range: { start: 20, end: 30 }, size: 10 }]
@@ -90,14 +90,14 @@ suite('RangeMap', () => {
});
test('consolidate', () => {
assert.deepEqual(consolidate([]), []);
assert.deepStrictEqual(consolidate([]), []);
assert.deepEqual(
assert.deepStrictEqual(
consolidate([{ range: { start: 0, end: 10 }, size: 1 }]),
[{ range: { start: 0, end: 10 }, size: 1 }]
);
assert.deepEqual(
assert.deepStrictEqual(
consolidate([
{ range: { start: 0, end: 10 }, size: 1 },
{ range: { start: 10, end: 20 }, size: 1 }
@@ -105,7 +105,7 @@ suite('RangeMap', () => {
[{ range: { start: 0, end: 20 }, size: 1 }]
);
assert.deepEqual(
assert.deepStrictEqual(
consolidate([
{ range: { start: 0, end: 10 }, size: 1 },
{ range: { start: 10, end: 20 }, size: 1 },
@@ -114,7 +114,7 @@ suite('RangeMap', () => {
[{ range: { start: 0, end: 100 }, size: 1 }]
);
assert.deepEqual(
assert.deepStrictEqual(
consolidate([
{ range: { start: 0, end: 10 }, size: 1 },
{ range: { start: 10, end: 20 }, size: 5 },
@@ -127,7 +127,7 @@ suite('RangeMap', () => {
]
);
assert.deepEqual(
assert.deepStrictEqual(
consolidate([
{ range: { start: 0, end: 10 }, size: 1 },
{ range: { start: 10, end: 20 }, size: 2 },
@@ -141,8 +141,8 @@ suite('RangeMap', () => {
});
test('empty', () => {
assert.equal(rangeMap.size, 0);
assert.equal(rangeMap.count, 0);
assert.strictEqual(rangeMap.size, 0);
assert.strictEqual(rangeMap.count, 0);
});
const one = { size: 1 };
@@ -153,44 +153,44 @@ suite('RangeMap', () => {
test('length & count', () => {
rangeMap.splice(0, 0, [one]);
assert.equal(rangeMap.size, 1);
assert.equal(rangeMap.count, 1);
assert.strictEqual(rangeMap.size, 1);
assert.strictEqual(rangeMap.count, 1);
});
test('length & count #2', () => {
rangeMap.splice(0, 0, [one, one, one, one, one]);
assert.equal(rangeMap.size, 5);
assert.equal(rangeMap.count, 5);
assert.strictEqual(rangeMap.size, 5);
assert.strictEqual(rangeMap.count, 5);
});
test('length & count #3', () => {
rangeMap.splice(0, 0, [five]);
assert.equal(rangeMap.size, 5);
assert.equal(rangeMap.count, 1);
assert.strictEqual(rangeMap.size, 5);
assert.strictEqual(rangeMap.count, 1);
});
test('length & count #4', () => {
rangeMap.splice(0, 0, [five, five, five, five, five]);
assert.equal(rangeMap.size, 25);
assert.equal(rangeMap.count, 5);
assert.strictEqual(rangeMap.size, 25);
assert.strictEqual(rangeMap.count, 5);
});
test('insert', () => {
rangeMap.splice(0, 0, [five, five, five, five, five]);
assert.equal(rangeMap.size, 25);
assert.equal(rangeMap.count, 5);
assert.strictEqual(rangeMap.size, 25);
assert.strictEqual(rangeMap.count, 5);
rangeMap.splice(0, 0, [five, five, five, five, five]);
assert.equal(rangeMap.size, 50);
assert.equal(rangeMap.count, 10);
assert.strictEqual(rangeMap.size, 50);
assert.strictEqual(rangeMap.count, 10);
rangeMap.splice(5, 0, [ten, ten]);
assert.equal(rangeMap.size, 70);
assert.equal(rangeMap.count, 12);
assert.strictEqual(rangeMap.size, 70);
assert.strictEqual(rangeMap.count, 12);
rangeMap.splice(12, 0, [{ size: 200 }]);
assert.equal(rangeMap.size, 270);
assert.equal(rangeMap.count, 13);
assert.strictEqual(rangeMap.size, 270);
assert.strictEqual(rangeMap.count, 13);
});
test('delete', () => {
@@ -198,45 +198,45 @@ suite('RangeMap', () => {
five, five, five, five, five,
five, five, five, five, five,
five, five, five, five, five]);
assert.equal(rangeMap.size, 100);
assert.equal(rangeMap.count, 20);
assert.strictEqual(rangeMap.size, 100);
assert.strictEqual(rangeMap.count, 20);
rangeMap.splice(10, 5);
assert.equal(rangeMap.size, 75);
assert.equal(rangeMap.count, 15);
assert.strictEqual(rangeMap.size, 75);
assert.strictEqual(rangeMap.count, 15);
rangeMap.splice(0, 1);
assert.equal(rangeMap.size, 70);
assert.equal(rangeMap.count, 14);
assert.strictEqual(rangeMap.size, 70);
assert.strictEqual(rangeMap.count, 14);
rangeMap.splice(1, 13);
assert.equal(rangeMap.size, 5);
assert.equal(rangeMap.count, 1);
assert.strictEqual(rangeMap.size, 5);
assert.strictEqual(rangeMap.count, 1);
rangeMap.splice(1, 1);
assert.equal(rangeMap.size, 5);
assert.equal(rangeMap.count, 1);
assert.strictEqual(rangeMap.size, 5);
assert.strictEqual(rangeMap.count, 1);
});
test('insert & delete', () => {
assert.equal(rangeMap.size, 0);
assert.equal(rangeMap.count, 0);
assert.strictEqual(rangeMap.size, 0);
assert.strictEqual(rangeMap.count, 0);
rangeMap.splice(0, 0, [one]);
assert.equal(rangeMap.size, 1);
assert.equal(rangeMap.count, 1);
assert.strictEqual(rangeMap.size, 1);
assert.strictEqual(rangeMap.count, 1);
rangeMap.splice(0, 1);
assert.equal(rangeMap.size, 0);
assert.equal(rangeMap.count, 0);
assert.strictEqual(rangeMap.size, 0);
assert.strictEqual(rangeMap.count, 0);
});
test('insert & delete #2', () => {
rangeMap.splice(0, 0, [one, one, one, one, one,
one, one, one, one, one]);
rangeMap.splice(2, 6);
assert.equal(rangeMap.count, 4);
assert.equal(rangeMap.size, 4);
assert.strictEqual(rangeMap.count, 4);
assert.strictEqual(rangeMap.size, 4);
});
test('insert & delete #3', () => {
@@ -245,8 +245,8 @@ suite('RangeMap', () => {
two, two, two, two, two,
two, two, two, two, two]);
rangeMap.splice(8, 4);
assert.equal(rangeMap.count, 16);
assert.equal(rangeMap.size, 24);
assert.strictEqual(rangeMap.count, 16);
assert.strictEqual(rangeMap.size, 24);
});
test('insert & delete #3', () => {
@@ -255,91 +255,91 @@ suite('RangeMap', () => {
two, two, two, two, two,
two, two, two, two, two]);
rangeMap.splice(5, 0, [three, three, three, three, three]);
assert.equal(rangeMap.count, 25);
assert.equal(rangeMap.size, 45);
assert.strictEqual(rangeMap.count, 25);
assert.strictEqual(rangeMap.size, 45);
rangeMap.splice(4, 7);
assert.equal(rangeMap.count, 18);
assert.equal(rangeMap.size, 28);
assert.strictEqual(rangeMap.count, 18);
assert.strictEqual(rangeMap.size, 28);
});
suite('indexAt, positionAt', () => {
test('empty', () => {
assert.equal(rangeMap.indexAt(0), 0);
assert.equal(rangeMap.indexAt(10), 0);
assert.equal(rangeMap.indexAt(-1), -1);
assert.equal(rangeMap.positionAt(0), -1);
assert.equal(rangeMap.positionAt(10), -1);
assert.equal(rangeMap.positionAt(-1), -1);
assert.strictEqual(rangeMap.indexAt(0), 0);
assert.strictEqual(rangeMap.indexAt(10), 0);
assert.strictEqual(rangeMap.indexAt(-1), -1);
assert.strictEqual(rangeMap.positionAt(0), -1);
assert.strictEqual(rangeMap.positionAt(10), -1);
assert.strictEqual(rangeMap.positionAt(-1), -1);
});
test('simple', () => {
rangeMap.splice(0, 0, [one]);
assert.equal(rangeMap.indexAt(0), 0);
assert.equal(rangeMap.indexAt(1), 1);
assert.equal(rangeMap.positionAt(0), 0);
assert.equal(rangeMap.positionAt(1), -1);
assert.strictEqual(rangeMap.indexAt(0), 0);
assert.strictEqual(rangeMap.indexAt(1), 1);
assert.strictEqual(rangeMap.positionAt(0), 0);
assert.strictEqual(rangeMap.positionAt(1), -1);
});
test('simple #2', () => {
rangeMap.splice(0, 0, [ten]);
assert.equal(rangeMap.indexAt(0), 0);
assert.equal(rangeMap.indexAt(5), 0);
assert.equal(rangeMap.indexAt(9), 0);
assert.equal(rangeMap.indexAt(10), 1);
assert.equal(rangeMap.positionAt(0), 0);
assert.equal(rangeMap.positionAt(1), -1);
assert.strictEqual(rangeMap.indexAt(0), 0);
assert.strictEqual(rangeMap.indexAt(5), 0);
assert.strictEqual(rangeMap.indexAt(9), 0);
assert.strictEqual(rangeMap.indexAt(10), 1);
assert.strictEqual(rangeMap.positionAt(0), 0);
assert.strictEqual(rangeMap.positionAt(1), -1);
});
test('insert', () => {
rangeMap.splice(0, 0, [one, one, one, one, one, one, one, one, one, one]);
assert.equal(rangeMap.indexAt(0), 0);
assert.equal(rangeMap.indexAt(1), 1);
assert.equal(rangeMap.indexAt(5), 5);
assert.equal(rangeMap.indexAt(9), 9);
assert.equal(rangeMap.indexAt(10), 10);
assert.equal(rangeMap.indexAt(11), 10);
assert.strictEqual(rangeMap.indexAt(0), 0);
assert.strictEqual(rangeMap.indexAt(1), 1);
assert.strictEqual(rangeMap.indexAt(5), 5);
assert.strictEqual(rangeMap.indexAt(9), 9);
assert.strictEqual(rangeMap.indexAt(10), 10);
assert.strictEqual(rangeMap.indexAt(11), 10);
rangeMap.splice(10, 0, [one, one, one, one, one, one, one, one, one, one]);
assert.equal(rangeMap.indexAt(10), 10);
assert.equal(rangeMap.indexAt(19), 19);
assert.equal(rangeMap.indexAt(20), 20);
assert.equal(rangeMap.indexAt(21), 20);
assert.equal(rangeMap.positionAt(0), 0);
assert.equal(rangeMap.positionAt(1), 1);
assert.equal(rangeMap.positionAt(19), 19);
assert.equal(rangeMap.positionAt(20), -1);
assert.strictEqual(rangeMap.indexAt(10), 10);
assert.strictEqual(rangeMap.indexAt(19), 19);
assert.strictEqual(rangeMap.indexAt(20), 20);
assert.strictEqual(rangeMap.indexAt(21), 20);
assert.strictEqual(rangeMap.positionAt(0), 0);
assert.strictEqual(rangeMap.positionAt(1), 1);
assert.strictEqual(rangeMap.positionAt(19), 19);
assert.strictEqual(rangeMap.positionAt(20), -1);
});
test('delete', () => {
rangeMap.splice(0, 0, [one, one, one, one, one, one, one, one, one, one]);
rangeMap.splice(2, 6);
assert.equal(rangeMap.indexAt(0), 0);
assert.equal(rangeMap.indexAt(1), 1);
assert.equal(rangeMap.indexAt(3), 3);
assert.equal(rangeMap.indexAt(4), 4);
assert.equal(rangeMap.indexAt(5), 4);
assert.equal(rangeMap.positionAt(0), 0);
assert.equal(rangeMap.positionAt(1), 1);
assert.equal(rangeMap.positionAt(3), 3);
assert.equal(rangeMap.positionAt(4), -1);
assert.strictEqual(rangeMap.indexAt(0), 0);
assert.strictEqual(rangeMap.indexAt(1), 1);
assert.strictEqual(rangeMap.indexAt(3), 3);
assert.strictEqual(rangeMap.indexAt(4), 4);
assert.strictEqual(rangeMap.indexAt(5), 4);
assert.strictEqual(rangeMap.positionAt(0), 0);
assert.strictEqual(rangeMap.positionAt(1), 1);
assert.strictEqual(rangeMap.positionAt(3), 3);
assert.strictEqual(rangeMap.positionAt(4), -1);
});
test('delete #2', () => {
rangeMap.splice(0, 0, [ten, ten, ten, ten, ten, ten, ten, ten, ten, ten]);
rangeMap.splice(2, 6);
assert.equal(rangeMap.indexAt(0), 0);
assert.equal(rangeMap.indexAt(1), 0);
assert.equal(rangeMap.indexAt(30), 3);
assert.equal(rangeMap.indexAt(40), 4);
assert.equal(rangeMap.indexAt(50), 4);
assert.equal(rangeMap.positionAt(0), 0);
assert.equal(rangeMap.positionAt(1), 10);
assert.equal(rangeMap.positionAt(2), 20);
assert.equal(rangeMap.positionAt(3), 30);
assert.equal(rangeMap.positionAt(4), -1);
assert.strictEqual(rangeMap.indexAt(0), 0);
assert.strictEqual(rangeMap.indexAt(1), 0);
assert.strictEqual(rangeMap.indexAt(30), 3);
assert.strictEqual(rangeMap.indexAt(40), 4);
assert.strictEqual(rangeMap.indexAt(50), 4);
assert.strictEqual(rangeMap.positionAt(0), 0);
assert.strictEqual(rangeMap.positionAt(1), 10);
assert.strictEqual(rangeMap.positionAt(2), 20);
assert.strictEqual(rangeMap.positionAt(3), 30);
assert.strictEqual(rangeMap.positionAt(4), -1);
});
});
});

4
lib/vscode/src/vs/base/test/browser/ui/menu/menubar.test.ts
View File

@@ -56,7 +56,7 @@ function validateMenuBarItem(menubar: MenuBar, menubarContainer: HTMLElement, la
assert(titleDiv !== null, `Title div not found for ${readableLabel} button.`);
const mnem = getMnemonicFromTitleDiv(titleDiv!);
assert.equal(mnem, mnemonic, 'Mnemonic not correct');
assert.strictEqual(mnem, mnemonic, 'Mnemonic not correct');
}
suite('Menubar', () => {
@@ -78,4 +78,4 @@ suite('Menubar', () => {
test('Chinese File menu renders mnemonics', function () {
validateMenuBarItem(menubar, container, '文件(&F)', '文件', 'F');
});
});
});

188
lib/vscode/src/vs/base/test/browser/ui/splitview/splitview.test.ts
View File

@@ -77,7 +77,7 @@ suite('Splitview', () => {
test('empty splitview has empty DOM', () => {
const splitview = new SplitView(container);
assert.equal(container.firstElementChild!.firstElementChild!.childElementCount, 0, 'split view should be empty');
assert.strictEqual(container.firstElementChild!.firstElementChild!.childElementCount, 0, 'split view should be empty');
splitview.dispose();
});
@@ -92,34 +92,34 @@ suite('Splitview', () => {
splitview.addView(view3, 20);
let viewQuery = container.querySelectorAll('.monaco-split-view2 > .monaco-scrollable-element > .split-view-container > .split-view-view');
assert.equal(viewQuery.length, 3, 'split view should have 3 views');
assert.strictEqual(viewQuery.length, 3, 'split view should have 3 views');
let sashQuery = container.querySelectorAll('.monaco-split-view2 > .sash-container > .monaco-sash');
assert.equal(sashQuery.length, 2, 'split view should have 2 sashes');
assert.strictEqual(sashQuery.length, 2, 'split view should have 2 sashes');
splitview.removeView(2);
viewQuery = container.querySelectorAll('.monaco-split-view2 > .monaco-scrollable-element > .split-view-container > .split-view-view');
assert.equal(viewQuery.length, 2, 'split view should have 2 views');
assert.strictEqual(viewQuery.length, 2, 'split view should have 2 views');
sashQuery = container.querySelectorAll('.monaco-split-view2 > .sash-container > .monaco-sash');
assert.equal(sashQuery.length, 1, 'split view should have 1 sash');
assert.strictEqual(sashQuery.length, 1, 'split view should have 1 sash');
splitview.removeView(0);
viewQuery = container.querySelectorAll('.monaco-split-view2 > .monaco-scrollable-element > .split-view-container > .split-view-view');
assert.equal(viewQuery.length, 1, 'split view should have 1 view');
assert.strictEqual(viewQuery.length, 1, 'split view should have 1 view');
sashQuery = container.querySelectorAll('.monaco-split-view2 > .sash-container > .monaco-sash');
assert.equal(sashQuery.length, 0, 'split view should have no sashes');
assert.strictEqual(sashQuery.length, 0, 'split view should have no sashes');
splitview.removeView(0);
viewQuery = container.querySelectorAll('.monaco-split-view2 > .monaco-scrollable-element > .split-view-container > .split-view-view');
assert.equal(viewQuery.length, 0, 'split view should have no views');
assert.strictEqual(viewQuery.length, 0, 'split view should have no views');
sashQuery = container.querySelectorAll('.monaco-split-view2 > .sash-container > .monaco-sash');
assert.equal(sashQuery.length, 0, 'split view should have no sashes');
assert.strictEqual(sashQuery.length, 0, 'split view should have no sashes');
splitview.dispose();
view1.dispose();
@@ -138,7 +138,7 @@ suite('Splitview', () => {
splitview.addView(view, 20);
assert.equal(view.size, 20, 'view has right size');
assert.strictEqual(view.size, 20, 'view has right size');
assert(didLayout, 'layout is called');
assert(didLayout, 'render is called');
@@ -154,22 +154,22 @@ suite('Splitview', () => {
splitview.layout(200);
splitview.addView(view, 20);
assert.equal(view.size, 200, 'view is stretched');
assert.strictEqual(view.size, 200, 'view is stretched');
splitview.layout(200);
assert.equal(view.size, 200, 'view stayed the same');
assert.strictEqual(view.size, 200, 'view stayed the same');
splitview.layout(100);
assert.equal(view.size, 100, 'view is collapsed');
assert.strictEqual(view.size, 100, 'view is collapsed');
splitview.layout(20);
assert.equal(view.size, 20, 'view is collapsed');
assert.strictEqual(view.size, 20, 'view is collapsed');
splitview.layout(10);
assert.equal(view.size, 20, 'view is clamped');
assert.strictEqual(view.size, 20, 'view is clamped');
splitview.layout(200);
assert.equal(view.size, 200, 'view is stretched');
assert.strictEqual(view.size, 200, 'view is stretched');
splitview.dispose();
view.dispose();
@@ -186,27 +186,27 @@ suite('Splitview', () => {
splitview.addView(view2, 20);
splitview.addView(view3, 20);
assert.equal(view1.size, 160, 'view1 is stretched');
assert.equal(view2.size, 20, 'view2 size is 20');
assert.equal(view3.size, 20, 'view3 size is 20');
assert.strictEqual(view1.size, 160, 'view1 is stretched');
assert.strictEqual(view2.size, 20, 'view2 size is 20');
assert.strictEqual(view3.size, 20, 'view3 size is 20');
splitview.resizeView(1, 40);
assert.equal(view1.size, 140, 'view1 is collapsed');
assert.equal(view2.size, 40, 'view2 is stretched');
assert.equal(view3.size, 20, 'view3 stays the same');
assert.strictEqual(view1.size, 140, 'view1 is collapsed');
assert.strictEqual(view2.size, 40, 'view2 is stretched');
assert.strictEqual(view3.size, 20, 'view3 stays the same');
splitview.resizeView(0, 70);
assert.equal(view1.size, 70, 'view1 is collapsed');
assert.equal(view2.size, 40, 'view2 stays the same');
assert.equal(view3.size, 90, 'view3 is stretched');
assert.strictEqual(view1.size, 70, 'view1 is collapsed');
assert.strictEqual(view2.size, 40, 'view2 stays the same');
assert.strictEqual(view3.size, 90, 'view3 is stretched');
splitview.resizeView(2, 40);
assert.equal(view1.size, 70, 'view1 stays the same');
assert.equal(view2.size, 90, 'view2 is collapsed');
assert.equal(view3.size, 40, 'view3 is stretched');
assert.strictEqual(view1.size, 70, 'view1 stays the same');
assert.strictEqual(view2.size, 90, 'view2 is collapsed');
assert.strictEqual(view3.size, 40, 'view3 is stretched');
splitview.dispose();
view3.dispose();
@@ -225,34 +225,34 @@ suite('Splitview', () => {
splitview.addView(view2, 20);
splitview.addView(view3, 20);
assert.equal(view1.size, 160, 'view1 is stretched');
assert.equal(view2.size, 20, 'view2 size is 20');
assert.equal(view3.size, 20, 'view3 size is 20');
assert.strictEqual(view1.size, 160, 'view1 is stretched');
assert.strictEqual(view2.size, 20, 'view2 size is 20');
assert.strictEqual(view3.size, 20, 'view3 size is 20');
view1.maximumSize = 20;
assert.equal(view1.size, 20, 'view1 is collapsed');
assert.equal(view2.size, 20, 'view2 stays the same');
assert.equal(view3.size, 160, 'view3 is stretched');
assert.strictEqual(view1.size, 20, 'view1 is collapsed');
assert.strictEqual(view2.size, 20, 'view2 stays the same');
assert.strictEqual(view3.size, 160, 'view3 is stretched');
view3.maximumSize = 40;
assert.equal(view1.size, 20, 'view1 stays the same');
assert.equal(view2.size, 140, 'view2 is stretched');
assert.equal(view3.size, 40, 'view3 is collapsed');
assert.strictEqual(view1.size, 20, 'view1 stays the same');
assert.strictEqual(view2.size, 140, 'view2 is stretched');
assert.strictEqual(view3.size, 40, 'view3 is collapsed');
view2.maximumSize = 200;
assert.equal(view1.size, 20, 'view1 stays the same');
assert.equal(view2.size, 140, 'view2 stays the same');
assert.equal(view3.size, 40, 'view3 stays the same');
assert.strictEqual(view1.size, 20, 'view1 stays the same');
assert.strictEqual(view2.size, 140, 'view2 stays the same');
assert.strictEqual(view3.size, 40, 'view3 stays the same');
view3.maximumSize = Number.POSITIVE_INFINITY;
view3.minimumSize = 100;
assert.equal(view1.size, 20, 'view1 is collapsed');
assert.equal(view2.size, 80, 'view2 is collapsed');
assert.equal(view3.size, 100, 'view3 is stretched');
assert.strictEqual(view1.size, 20, 'view1 is collapsed');
assert.strictEqual(view2.size, 80, 'view2 is collapsed');
assert.strictEqual(view3.size, 100, 'view3 is stretched');
splitview.dispose();
view3.dispose();
@@ -272,41 +272,41 @@ suite('Splitview', () => {
splitview.addView(view3, Sizing.Distribute);
let sashes = getSashes(splitview);
assert.equal(sashes.length, 2, 'there are two sashes');
assert.equal(sashes[0].state, SashState.Enabled, 'first sash is enabled');
assert.equal(sashes[1].state, SashState.Enabled, 'second sash is enabled');
assert.strictEqual(sashes.length, 2, 'there are two sashes');
assert.strictEqual(sashes[0].state, SashState.Enabled, 'first sash is enabled');
assert.strictEqual(sashes[1].state, SashState.Enabled, 'second sash is enabled');
splitview.layout(60);
assert.equal(sashes[0].state, SashState.Disabled, 'first sash is disabled');
assert.equal(sashes[1].state, SashState.Disabled, 'second sash is disabled');
assert.strictEqual(sashes[0].state, SashState.Disabled, 'first sash is disabled');
assert.strictEqual(sashes[1].state, SashState.Disabled, 'second sash is disabled');
splitview.layout(20);
assert.equal(sashes[0].state, SashState.Disabled, 'first sash is disabled');
assert.equal(sashes[1].state, SashState.Disabled, 'second sash is disabled');
assert.strictEqual(sashes[0].state, SashState.Disabled, 'first sash is disabled');
assert.strictEqual(sashes[1].state, SashState.Disabled, 'second sash is disabled');
splitview.layout(200);
assert.equal(sashes[0].state, SashState.Enabled, 'first sash is enabled');
assert.equal(sashes[1].state, SashState.Enabled, 'second sash is enabled');
assert.strictEqual(sashes[0].state, SashState.Enabled, 'first sash is enabled');
assert.strictEqual(sashes[1].state, SashState.Enabled, 'second sash is enabled');
view1.maximumSize = 20;
assert.equal(sashes[0].state, SashState.Disabled, 'first sash is disabled');
assert.equal(sashes[1].state, SashState.Enabled, 'second sash is enabled');
assert.strictEqual(sashes[0].state, SashState.Disabled, 'first sash is disabled');
assert.strictEqual(sashes[1].state, SashState.Enabled, 'second sash is enabled');
view2.maximumSize = 20;
assert.equal(sashes[0].state, SashState.Disabled, 'first sash is disabled');
assert.equal(sashes[1].state, SashState.Disabled, 'second sash is disabled');
assert.strictEqual(sashes[0].state, SashState.Disabled, 'first sash is disabled');
assert.strictEqual(sashes[1].state, SashState.Disabled, 'second sash is disabled');
view1.maximumSize = 300;
assert.equal(sashes[0].state, SashState.Minimum, 'first sash is enabled');
assert.equal(sashes[1].state, SashState.Minimum, 'second sash is enabled');
assert.strictEqual(sashes[0].state, SashState.Minimum, 'first sash is enabled');
assert.strictEqual(sashes[1].state, SashState.Minimum, 'second sash is enabled');
view2.maximumSize = 200;
assert.equal(sashes[0].state, SashState.Minimum, 'first sash is enabled');
assert.equal(sashes[1].state, SashState.Minimum, 'second sash is enabled');
assert.strictEqual(sashes[0].state, SashState.Minimum, 'first sash is enabled');
assert.strictEqual(sashes[1].state, SashState.Minimum, 'second sash is enabled');
splitview.resizeView(0, 40);
assert.equal(sashes[0].state, SashState.Enabled, 'first sash is enabled');
assert.equal(sashes[1].state, SashState.Enabled, 'second sash is enabled');
assert.strictEqual(sashes[0].state, SashState.Enabled, 'first sash is enabled');
assert.strictEqual(sashes[1].state, SashState.Enabled, 'second sash is enabled');
splitview.dispose();
view3.dispose();
@@ -322,7 +322,7 @@ suite('Splitview', () => {
splitview.layout(986);
splitview.addView(view1, 142, 0);
assert.equal(view1.size, 986, 'first view is stretched');
assert.strictEqual(view1.size, 986, 'first view is stretched');
view2.onDidGetElement(() => {
assert.throws(() => splitview.resizeView(1, 922));
@@ -330,13 +330,13 @@ suite('Splitview', () => {
});
splitview.addView(view2, 66, 0);
assert.equal(view2.size, 66, 'second view is fixed');
assert.equal(view1.size, 986 - 66, 'first view is collapsed');
assert.strictEqual(view2.size, 66, 'second view is fixed');
assert.strictEqual(view1.size, 986 - 66, 'first view is collapsed');
const viewContainers = container.querySelectorAll('.split-view-view');
assert.equal(viewContainers.length, 2, 'there are two view containers');
assert.equal((viewContainers.item(0) as HTMLElement).style.height, '66px', 'second view container is 66px');
assert.equal((viewContainers.item(1) as HTMLElement).style.height, `${986 - 66}px`, 'first view container is 66px');
assert.strictEqual(viewContainers.length, 2, 'there are two view containers');
assert.strictEqual((viewContainers.item(0) as HTMLElement).style.height, '66px', 'second view container is 66px');
assert.strictEqual((viewContainers.item(1) as HTMLElement).style.height, `${986 - 66}px`, 'first view container is 66px');
splitview.dispose();
view2.dispose();
@@ -351,16 +351,16 @@ suite('Splitview', () => {
splitview.layout(200);
splitview.addView(view1, Sizing.Distribute);
assert.equal(view1.size, 200);
assert.strictEqual(view1.size, 200);
splitview.addView(view2, 50);
assert.deepEqual([view1.size, view2.size], [150, 50]);
assert.deepStrictEqual([view1.size, view2.size], [150, 50]);
splitview.addView(view3, Sizing.Distribute);
assert.deepEqual([view1.size, view2.size, view3.size], [66, 66, 68]);
assert.deepStrictEqual([view1.size, view2.size, view3.size], [66, 66, 68]);
splitview.removeView(1, Sizing.Distribute);
assert.deepEqual([view1.size, view3.size], [100, 100]);
assert.deepStrictEqual([view1.size, view3.size], [100, 100]);
splitview.dispose();
view3.dispose();
@@ -379,7 +379,7 @@ suite('Splitview', () => {
splitview.addView(view3, 25);
splitview.layout(200);
assert.deepEqual([view1.size, view2.size, view3.size], [67, 67, 66]);
assert.deepStrictEqual([view1.size, view2.size, view3.size], [67, 67, 66]);
splitview.dispose();
view3.dispose();
@@ -395,13 +395,13 @@ suite('Splitview', () => {
splitview.layout(200);
splitview.addView(view1, Sizing.Distribute);
assert.equal(view1.size, 200);
assert.strictEqual(view1.size, 200);
splitview.addView(view2, Sizing.Split(0));
assert.deepEqual([view1.size, view2.size], [100, 100]);
assert.deepStrictEqual([view1.size, view2.size], [100, 100]);
splitview.addView(view3, Sizing.Split(1));
assert.deepEqual([view1.size, view2.size, view3.size], [100, 50, 50]);
assert.deepStrictEqual([view1.size, view2.size, view3.size], [100, 50, 50]);
splitview.dispose();
view3.dispose();
@@ -417,13 +417,13 @@ suite('Splitview', () => {
splitview.layout(200);
splitview.addView(view1, Sizing.Distribute);
assert.equal(view1.size, 200);
assert.strictEqual(view1.size, 200);
splitview.addView(view2, Sizing.Split(0));
assert.deepEqual([view1.size, view2.size], [100, 100]);
assert.deepStrictEqual([view1.size, view2.size], [100, 100]);
splitview.addView(view3, Sizing.Split(0));
assert.deepEqual([view1.size, view2.size, view3.size], [50, 100, 50]);
assert.deepStrictEqual([view1.size, view2.size, view3.size], [50, 100, 50]);
splitview.dispose();
view3.dispose();
@@ -439,10 +439,10 @@ suite('Splitview', () => {
splitview.addView(view1, Sizing.Distribute);
splitview.addView(view2, Sizing.Distribute);
assert.deepEqual([view1.size, view2.size], [100, 100]);
assert.deepStrictEqual([view1.size, view2.size], [100, 100]);
splitview.layout(100);
assert.deepEqual([view1.size, view2.size], [50, 50]);
assert.deepStrictEqual([view1.size, view2.size], [50, 50]);
splitview.dispose();
view2.dispose();
@@ -457,10 +457,10 @@ suite('Splitview', () => {
splitview.addView(view1, Sizing.Distribute);
splitview.addView(view2, Sizing.Distribute);
assert.deepEqual([view1.size, view2.size], [100, 100]);
assert.deepStrictEqual([view1.size, view2.size], [100, 100]);
splitview.layout(100);
assert.deepEqual([view1.size, view2.size], [80, 20]);
assert.deepStrictEqual([view1.size, view2.size], [80, 20]);
splitview.dispose();
view2.dispose();
@@ -477,19 +477,19 @@ suite('Splitview', () => {
splitview.addView(view1, Sizing.Distribute);
splitview.addView(view2, Sizing.Distribute);
splitview.addView(view3, Sizing.Distribute);
assert.deepEqual([view1.size, view2.size, view3.size], [66, 68, 66]);
assert.deepStrictEqual([view1.size, view2.size, view3.size], [66, 68, 66]);
splitview.layout(180);
assert.deepEqual([view1.size, view2.size, view3.size], [66, 48, 66]);
assert.deepStrictEqual([view1.size, view2.size, view3.size], [66, 48, 66]);
splitview.layout(124);
assert.deepEqual([view1.size, view2.size, view3.size], [66, 20, 38]);
assert.deepStrictEqual([view1.size, view2.size, view3.size], [66, 20, 38]);
splitview.layout(60);
assert.deepEqual([view1.size, view2.size, view3.size], [20, 20, 20]);
assert.deepStrictEqual([view1.size, view2.size, view3.size], [20, 20, 20]);
splitview.layout(200);
assert.deepEqual([view1.size, view2.size, view3.size], [20, 160, 20]);
assert.deepStrictEqual([view1.size, view2.size, view3.size], [20, 160, 20]);
splitview.dispose();
view3.dispose();
@@ -507,19 +507,19 @@ suite('Splitview', () => {
splitview.addView(view1, Sizing.Distribute);
splitview.addView(view2, Sizing.Distribute);
splitview.addView(view3, Sizing.Distribute);
assert.deepEqual([view1.size, view2.size, view3.size], [66, 68, 66]);
assert.deepStrictEqual([view1.size, view2.size, view3.size], [66, 68, 66]);
splitview.layout(180);
assert.deepEqual([view1.size, view2.size, view3.size], [66, 48, 66]);
assert.deepStrictEqual([view1.size, view2.size, view3.size], [66, 48, 66]);
splitview.layout(132);
assert.deepEqual([view1.size, view2.size, view3.size], [46, 20, 66]);
assert.deepStrictEqual([view1.size, view2.size, view3.size], [46, 20, 66]);
splitview.layout(60);
assert.deepEqual([view1.size, view2.size, view3.size], [20, 20, 20]);
assert.deepStrictEqual([view1.size, view2.size, view3.size], [20, 20, 20]);
splitview.layout(200);
assert.deepEqual([view1.size, view2.size, view3.size], [20, 160, 20]);
assert.deepStrictEqual([view1.size, view2.size, view3.size], [20, 160, 20]);
splitview.dispose();
view3.dispose();
@@ -539,7 +539,7 @@ suite('Splitview', () => {
splitview.addView(view3, Sizing.Distribute);
splitview.layout(200, 100);
assert.deepEqual([view1.orthogonalSize, view2.orthogonalSize, view3.orthogonalSize], [100, 100, 100]);
assert.deepStrictEqual([view1.orthogonalSize, view2.orthogonalSize, view3.orthogonalSize], [100, 100, 100]);
splitview.dispose();
view3.dispose();

36
lib/vscode/src/vs/base/test/browser/ui/tree/asyncDataTree.test.ts
View File

@@ -97,10 +97,10 @@ suite('AsyncDataTree', function () {
const tree = new AsyncDataTree<Element, Element>('test', container, new VirtualDelegate(), [new Renderer()], new DataSource(), { identityProvider: new IdentityProvider() });
tree.layout(200);
assert.equal(container.querySelectorAll('.monaco-list-row').length, 0);
assert.strictEqual(container.querySelectorAll('.monaco-list-row').length, 0);
await tree.setInput(model.root);
assert.equal(container.querySelectorAll('.monaco-list-row').length, 1);
assert.strictEqual(container.querySelectorAll('.monaco-list-row').length, 1);
let twistie = container.querySelector('.monaco-list-row:first-child .monaco-tl-twistie') as HTMLElement;
assert(!twistie.classList.contains('collapsible'));
assert(!twistie.classList.contains('collapsed'));
@@ -112,14 +112,14 @@ suite('AsyncDataTree', function () {
];
await tree.updateChildren(model.root);
assert.equal(container.querySelectorAll('.monaco-list-row').length, 1);
assert.strictEqual(container.querySelectorAll('.monaco-list-row').length, 1);
await tree.expand(model.get('a'));
assert.equal(container.querySelectorAll('.monaco-list-row').length, 4);
assert.strictEqual(container.querySelectorAll('.monaco-list-row').length, 4);
model.get('a').children = [];
await tree.updateChildren(model.root);
assert.equal(container.querySelectorAll('.monaco-list-row').length, 1);
assert.strictEqual(container.querySelectorAll('.monaco-list-row').length, 1);
});
test('issue #68648', async () => {
@@ -316,16 +316,16 @@ suite('AsyncDataTree', function () {
const pUpdateChildrenA = tree.updateChildren(model.get('a'));
const pExpandA = tree.expand(model.get('a'));
assert.equal(calls.length, 1, 'expand(a) still hasn\'t called getChildren(a)');
assert.strictEqual(calls.length, 1, 'expand(a) still hasn\'t called getChildren(a)');
calls.pop()!();
assert.equal(calls.length, 0, 'no pending getChildren calls');
assert.strictEqual(calls.length, 0, 'no pending getChildren calls');
await pUpdateChildrenA;
assert.equal(calls.length, 0, 'expand(a) should not have forced a second refresh');
assert.strictEqual(calls.length, 0, 'expand(a) should not have forced a second refresh');
const result = await pExpandA;
assert.equal(result, true, 'expand(a) should be done');
assert.strictEqual(result, true, 'expand(a) should be done');
});
test('issue #80098 - first expand should call getChildren', async () => {
@@ -358,16 +358,16 @@ suite('AsyncDataTree', function () {
await pSetInput;
const pExpandA = tree.expand(model.get('a'));
assert.equal(calls.length, 1, 'expand(a) should\'ve called getChildren(a)');
assert.strictEqual(calls.length, 1, 'expand(a) should\'ve called getChildren(a)');
let race = await Promise.race([pExpandA.then(() => 'expand'), timeout(1).then(() => 'timeout')]);
assert.equal(race, 'timeout', 'expand(a) should not be yet done');
assert.strictEqual(race, 'timeout', 'expand(a) should not be yet done');
calls.pop()!();
assert.equal(calls.length, 0, 'no pending getChildren calls');
assert.strictEqual(calls.length, 0, 'no pending getChildren calls');
race = await Promise.race([pExpandA.then(() => 'expand'), timeout(1).then(() => 'timeout')]);
assert.equal(race, 'expand', 'expand(a) should now be done');
assert.strictEqual(race, 'expand', 'expand(a) should now be done');
});
test('issue #78388 - tree should react to hasChildren toggles', async () => {
@@ -383,7 +383,7 @@ suite('AsyncDataTree', function () {
tree.layout(200);
await tree.setInput(model.root);
assert.equal(container.querySelectorAll('.monaco-list-row').length, 1);
assert.strictEqual(container.querySelectorAll('.monaco-list-row').length, 1);
let twistie = container.querySelector('.monaco-list-row:first-child .monaco-tl-twistie') as HTMLElement;
assert(!twistie.classList.contains('collapsible'));
@@ -391,14 +391,14 @@ suite('AsyncDataTree', function () {
model.get('a').children = [{ id: 'aa' }];
await tree.updateChildren(model.get('a'), false);
assert.equal(container.querySelectorAll('.monaco-list-row').length, 1);
assert.strictEqual(container.querySelectorAll('.monaco-list-row').length, 1);
twistie = container.querySelector('.monaco-list-row:first-child .monaco-tl-twistie') as HTMLElement;
assert(twistie.classList.contains('collapsible'));
assert(twistie.classList.contains('collapsed'));
model.get('a').children = [];
await tree.updateChildren(model.get('a'), false);
assert.equal(container.querySelectorAll('.monaco-list-row').length, 1);
assert.strictEqual(container.querySelectorAll('.monaco-list-row').length, 1);
twistie = container.querySelector('.monaco-list-row:first-child .monaco-tl-twistie') as HTMLElement;
assert(!twistie.classList.contains('collapsible'));
assert(!twistie.classList.contains('collapsed'));
@@ -422,7 +422,7 @@ suite('AsyncDataTree', function () {
await tree.setInput(model.root);
await tree.expand(model.get('a'));
assert.deepEqual(Array.from(container.querySelectorAll('.monaco-list-row')).map(e => e.textContent), ['a', 'b1']);
assert.deepStrictEqual(Array.from(container.querySelectorAll('.monaco-list-row')).map(e => e.textContent), ['a', 'b1']);
const a = model.get('a');
const b = model.get('b');
@@ -433,6 +433,6 @@ suite('AsyncDataTree', function () {
tree.updateChildren(b, true, true)
]);
assert.deepEqual(Array.from(container.querySelectorAll('.monaco-list-row')).map(e => e.textContent), ['a', 'b2']);
assert.deepStrictEqual(Array.from(container.querySelectorAll('.monaco-list-row')).map(e => e.textContent), ['a', 'b2']);
});
});

88
lib/vscode/src/vs/base/test/browser/ui/tree/compressedObjectTreeModel.test.ts
View File

@@ -39,8 +39,8 @@ suite('CompressedObjectTree', function () {
const compressed: IResolvedCompressedTreeElement<ICompressedTreeNode<number>> =
{ element: { elements: [1], incompressible: false } };
assert.deepEqual(resolve(compress(decompressed)), compressed);
assert.deepEqual(resolve(decompress(compressed)), decompressed);
assert.deepStrictEqual(resolve(compress(decompressed)), compressed);
assert.deepStrictEqual(resolve(decompress(compressed)), decompressed);
});
test('no compression', function () {
@@ -61,8 +61,8 @@ suite('CompressedObjectTree', function () {
]
};
assert.deepEqual(resolve(compress(decompressed)), compressed);
assert.deepEqual(resolve(decompress(compressed)), decompressed);
assert.deepStrictEqual(resolve(compress(decompressed)), compressed);
assert.deepStrictEqual(resolve(decompress(compressed)), decompressed);
});
test('single hierarchy', function () {
@@ -84,8 +84,8 @@ suite('CompressedObjectTree', function () {
element: { elements: [1, 11, 111, 1111], incompressible: false }
};
assert.deepEqual(resolve(compress(decompressed)), compressed);
assert.deepEqual(resolve(decompress(compressed)), decompressed);
assert.deepStrictEqual(resolve(compress(decompressed)), compressed);
assert.deepStrictEqual(resolve(decompress(compressed)), decompressed);
});
test('deep compression', function () {
@@ -116,8 +116,8 @@ suite('CompressedObjectTree', function () {
]
};
assert.deepEqual(resolve(compress(decompressed)), compressed);
assert.deepEqual(resolve(decompress(compressed)), decompressed);
assert.deepStrictEqual(resolve(compress(decompressed)), compressed);
assert.deepStrictEqual(resolve(decompress(compressed)), decompressed);
});
test('double deep compression', function () {
@@ -166,8 +166,8 @@ suite('CompressedObjectTree', function () {
]
};
assert.deepEqual(resolve(compress(decompressed)), compressed);
assert.deepEqual(resolve(decompress(compressed)), decompressed);
assert.deepStrictEqual(resolve(compress(decompressed)), compressed);
assert.deepStrictEqual(resolve(decompress(compressed)), decompressed);
});
test('incompressible leaf', function () {
@@ -192,8 +192,8 @@ suite('CompressedObjectTree', function () {
]
};
assert.deepEqual(resolve(compress(decompressed)), compressed);
assert.deepEqual(resolve(decompress(compressed)), decompressed);
assert.deepStrictEqual(resolve(compress(decompressed)), compressed);
assert.deepStrictEqual(resolve(decompress(compressed)), decompressed);
});
test('incompressible branch', function () {
@@ -218,8 +218,8 @@ suite('CompressedObjectTree', function () {
]
};
assert.deepEqual(resolve(compress(decompressed)), compressed);
assert.deepEqual(resolve(decompress(compressed)), decompressed);
assert.deepStrictEqual(resolve(compress(decompressed)), compressed);
assert.deepStrictEqual(resolve(decompress(compressed)), decompressed);
});
test('incompressible chain', function () {
@@ -249,8 +249,8 @@ suite('CompressedObjectTree', function () {
]
};
assert.deepEqual(resolve(compress(decompressed)), compressed);
assert.deepEqual(resolve(decompress(compressed)), decompressed);
assert.deepStrictEqual(resolve(compress(decompressed)), compressed);
assert.deepStrictEqual(resolve(decompress(compressed)), decompressed);
});
test('incompressible tree', function () {
@@ -285,8 +285,8 @@ suite('CompressedObjectTree', function () {
]
};
assert.deepEqual(resolve(compress(decompressed)), compressed);
assert.deepEqual(resolve(decompress(compressed)), decompressed);
assert.deepStrictEqual(resolve(compress(decompressed)), compressed);
assert.deepStrictEqual(resolve(decompress(compressed)), decompressed);
});
});
@@ -319,8 +319,8 @@ suite('CompressedObjectTree', function () {
const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
const model = new CompressedObjectTreeModel<number>('test', toList(list));
assert(model);
assert.equal(list.length, 0);
assert.equal(model.size, 0);
assert.strictEqual(list.length, 0);
assert.strictEqual(model.size, 0);
});
test('flat', () => withSmartSplice(options => {
@@ -333,8 +333,8 @@ suite('CompressedObjectTree', function () {
{ element: 2 }
], options);
assert.deepEqual(toArray(list), [[0], [1], [2]]);
assert.equal(model.size, 3);
assert.deepStrictEqual(toArray(list), [[0], [1], [2]]);
assert.strictEqual(model.size, 3);
model.setChildren(null, [
{ element: 3 },
@@ -342,12 +342,12 @@ suite('CompressedObjectTree', function () {
{ element: 5 },
], options);
assert.deepEqual(toArray(list), [[3], [4], [5]]);
assert.equal(model.size, 3);
assert.deepStrictEqual(toArray(list), [[3], [4], [5]]);
assert.strictEqual(model.size, 3);
model.setChildren(null, [], options);
assert.deepEqual(toArray(list), []);
assert.equal(model.size, 0);
assert.deepStrictEqual(toArray(list), []);
assert.strictEqual(model.size, 0);
}));
test('nested', () => withSmartSplice(options => {
@@ -366,24 +366,24 @@ suite('CompressedObjectTree', function () {
{ element: 2 }
], options);
assert.deepEqual(toArray(list), [[0], [10], [11], [12], [1], [2]]);
assert.equal(model.size, 6);
assert.deepStrictEqual(toArray(list), [[0], [10], [11], [12], [1], [2]]);
assert.strictEqual(model.size, 6);
model.setChildren(12, [
{ element: 120 },
{ element: 121 }
], options);
assert.deepEqual(toArray(list), [[0], [10], [11], [12], [120], [121], [1], [2]]);
assert.equal(model.size, 8);
assert.deepStrictEqual(toArray(list), [[0], [10], [11], [12], [120], [121], [1], [2]]);
assert.strictEqual(model.size, 8);
model.setChildren(0, [], options);
assert.deepEqual(toArray(list), [[0], [1], [2]]);
assert.equal(model.size, 3);
assert.deepStrictEqual(toArray(list), [[0], [1], [2]]);
assert.strictEqual(model.size, 3);
model.setChildren(null, [], options);
assert.deepEqual(toArray(list), []);
assert.equal(model.size, 0);
assert.deepStrictEqual(toArray(list), []);
assert.strictEqual(model.size, 0);
}));
test('compressed', () => withSmartSplice(options => {
@@ -404,8 +404,8 @@ suite('CompressedObjectTree', function () {
}
], options);
assert.deepEqual(toArray(list), [[1, 11, 111], [1111], [1112], [1113]]);
assert.equal(model.size, 6);
assert.deepStrictEqual(toArray(list), [[1, 11, 111], [1111], [1112], [1113]]);
assert.strictEqual(model.size, 6);
model.setChildren(11, [
{ element: 111 },
@@ -413,30 +413,30 @@ suite('CompressedObjectTree', function () {
{ element: 113 },
], options);
assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113]]);
assert.equal(model.size, 5);
assert.deepStrictEqual(toArray(list), [[1, 11], [111], [112], [113]]);
assert.strictEqual(model.size, 5);
model.setChildren(113, [
{ element: 1131 }
], options);
assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113, 1131]]);
assert.equal(model.size, 6);
assert.deepStrictEqual(toArray(list), [[1, 11], [111], [112], [113, 1131]]);
assert.strictEqual(model.size, 6);
model.setChildren(1131, [
{ element: 1132 }
], options);
assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113, 1131, 1132]]);
assert.equal(model.size, 7);
assert.deepStrictEqual(toArray(list), [[1, 11], [111], [112], [113, 1131, 1132]]);
assert.strictEqual(model.size, 7);
model.setChildren(1131, [
{ element: 1132 },
{ element: 1133 },
], options);
assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113, 1131], [1132], [1133]]);
assert.equal(model.size, 8);
assert.deepStrictEqual(toArray(list), [[1, 11], [111], [112], [113, 1131], [1132], [1133]]);
assert.strictEqual(model.size, 8);
}));
});
});

74
lib/vscode/src/vs/base/test/browser/ui/tree/dataTree.test.ts
View File

@@ -77,20 +77,20 @@ suite('DataTree', function () {
tree.setInput(root);
let navigator = tree.navigate();
assert.equal(navigator.next()!.value, 0);
assert.equal(navigator.next()!.value, 10);
assert.equal(navigator.next()!.value, 11);
assert.equal(navigator.next()!.value, 12);
assert.equal(navigator.next()!.value, 1);
assert.equal(navigator.next()!.value, 2);
assert.equal(navigator.next()!, null);
assert.strictEqual(navigator.next()!.value, 0);
assert.strictEqual(navigator.next()!.value, 10);
assert.strictEqual(navigator.next()!.value, 11);
assert.strictEqual(navigator.next()!.value, 12);
assert.strictEqual(navigator.next()!.value, 1);
assert.strictEqual(navigator.next()!.value, 2);
assert.strictEqual(navigator.next()!, null);
tree.collapse(root.children![0]);
navigator = tree.navigate();
assert.equal(navigator.next()!.value, 0);
assert.equal(navigator.next()!.value, 1);
assert.equal(navigator.next()!.value, 2);
assert.equal(navigator.next()!, null);
assert.strictEqual(navigator.next()!.value, 0);
assert.strictEqual(navigator.next()!.value, 1);
assert.strictEqual(navigator.next()!.value, 2);
assert.strictEqual(navigator.next()!, null);
tree.setSelection([root.children![1]]);
tree.setFocus([root.children![2]]);
@@ -98,36 +98,36 @@ suite('DataTree', function () {
tree.setInput(empty);
tree.setInput(root);
navigator = tree.navigate();
assert.equal(navigator.next()!.value, 0);
assert.equal(navigator.next()!.value, 10);
assert.equal(navigator.next()!.value, 11);
assert.equal(navigator.next()!.value, 12);
assert.equal(navigator.next()!.value, 1);
assert.equal(navigator.next()!.value, 2);
assert.equal(navigator.next()!, null);
assert.strictEqual(navigator.next()!.value, 0);
assert.strictEqual(navigator.next()!.value, 10);
assert.strictEqual(navigator.next()!.value, 11);
assert.strictEqual(navigator.next()!.value, 12);
assert.strictEqual(navigator.next()!.value, 1);
assert.strictEqual(navigator.next()!.value, 2);
assert.strictEqual(navigator.next()!, null);
assert.deepEqual(tree.getSelection(), []);
assert.deepEqual(tree.getFocus(), []);
assert.deepStrictEqual(tree.getSelection(), []);
assert.deepStrictEqual(tree.getFocus(), []);
});
test('view state can be preserved', () => {
tree.setInput(root);
let navigator = tree.navigate();
assert.equal(navigator.next()!.value, 0);
assert.equal(navigator.next()!.value, 10);
assert.equal(navigator.next()!.value, 11);
assert.equal(navigator.next()!.value, 12);
assert.equal(navigator.next()!.value, 1);
assert.equal(navigator.next()!.value, 2);
assert.equal(navigator.next()!, null);
assert.strictEqual(navigator.next()!.value, 0);
assert.strictEqual(navigator.next()!.value, 10);
assert.strictEqual(navigator.next()!.value, 11);
assert.strictEqual(navigator.next()!.value, 12);
assert.strictEqual(navigator.next()!.value, 1);
assert.strictEqual(navigator.next()!.value, 2);
assert.strictEqual(navigator.next()!, null);
tree.collapse(root.children![0]);
navigator = tree.navigate();
assert.equal(navigator.next()!.value, 0);
assert.equal(navigator.next()!.value, 1);
assert.equal(navigator.next()!.value, 2);
assert.equal(navigator.next()!, null);
assert.strictEqual(navigator.next()!.value, 0);
assert.strictEqual(navigator.next()!.value, 1);
assert.strictEqual(navigator.next()!.value, 2);
assert.strictEqual(navigator.next()!, null);
tree.setSelection([root.children![1]]);
tree.setFocus([root.children![2]]);
@@ -137,12 +137,12 @@ suite('DataTree', function () {
tree.setInput(empty);
tree.setInput(root, viewState);
navigator = tree.navigate();
assert.equal(navigator.next()!.value, 0);
assert.equal(navigator.next()!.value, 1);
assert.equal(navigator.next()!.value, 2);
assert.equal(navigator.next()!, null);
assert.strictEqual(navigator.next()!.value, 0);
assert.strictEqual(navigator.next()!.value, 1);
assert.strictEqual(navigator.next()!.value, 2);
assert.strictEqual(navigator.next()!, null);
assert.deepEqual(tree.getSelection(), [root.children![1]]);
assert.deepEqual(tree.getFocus(), [root.children![2]]);
assert.deepStrictEqual(tree.getSelection(), [root.children![1]]);
assert.deepStrictEqual(tree.getFocus(), [root.children![2]]);
});
});

412
lib/vscode/src/vs/base/test/browser/ui/tree/indexTreeModel.test.ts
View File

@@ -42,7 +42,7 @@ suite('IndexTreeModel', () => {
const list: ITreeNode<number>[] = [];
const model = new IndexTreeModel<number>('test', toList(list), -1);
assert(model);
assert.equal(list.length, 0);
assert.strictEqual(list.length, 0);
});
test('insert', () => withSmartSplice(options => {
@@ -55,16 +55,16 @@ suite('IndexTreeModel', () => {
{ element: 2 }
], options);
assert.deepEqual(list.length, 3);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsed, false);
assert.deepEqual(list[0].depth, 1);
assert.deepEqual(list[1].element, 1);
assert.deepEqual(list[1].collapsed, false);
assert.deepEqual(list[1].depth, 1);
assert.deepEqual(list[2].element, 2);
assert.deepEqual(list[2].collapsed, false);
assert.deepEqual(list[2].depth, 1);
assert.deepStrictEqual(list.length, 3);
assert.deepStrictEqual(list[0].element, 0);
assert.deepStrictEqual(list[0].collapsed, false);
assert.deepStrictEqual(list[0].depth, 1);
assert.deepStrictEqual(list[1].element, 1);
assert.deepStrictEqual(list[1].collapsed, false);
assert.deepStrictEqual(list[1].depth, 1);
assert.deepStrictEqual(list[2].element, 2);
assert.deepStrictEqual(list[2].collapsed, false);
assert.deepStrictEqual(list[2].depth, 1);
}));
test('deep insert', () => withSmartSplice(options => {
@@ -83,25 +83,25 @@ suite('IndexTreeModel', () => {
{ element: 2 }
]);
assert.deepEqual(list.length, 6);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsed, false);
assert.deepEqual(list[0].depth, 1);
assert.deepEqual(list[1].element, 10);
assert.deepEqual(list[1].collapsed, false);
assert.deepEqual(list[1].depth, 2);
assert.deepEqual(list[2].element, 11);
assert.deepEqual(list[2].collapsed, false);
assert.deepEqual(list[2].depth, 2);
assert.deepEqual(list[3].element, 12);
assert.deepEqual(list[3].collapsed, false);
assert.deepEqual(list[3].depth, 2);
assert.deepEqual(list[4].element, 1);
assert.deepEqual(list[4].collapsed, false);
assert.deepEqual(list[4].depth, 1);
assert.deepEqual(list[5].element, 2);
assert.deepEqual(list[5].collapsed, false);
assert.deepEqual(list[5].depth, 1);
assert.deepStrictEqual(list.length, 6);
assert.deepStrictEqual(list[0].element, 0);
assert.deepStrictEqual(list[0].collapsed, false);
assert.deepStrictEqual(list[0].depth, 1);
assert.deepStrictEqual(list[1].element, 10);
assert.deepStrictEqual(list[1].collapsed, false);
assert.deepStrictEqual(list[1].depth, 2);
assert.deepStrictEqual(list[2].element, 11);
assert.deepStrictEqual(list[2].collapsed, false);
assert.deepStrictEqual(list[2].depth, 2);
assert.deepStrictEqual(list[3].element, 12);
assert.deepStrictEqual(list[3].collapsed, false);
assert.deepStrictEqual(list[3].depth, 2);
assert.deepStrictEqual(list[4].element, 1);
assert.deepStrictEqual(list[4].collapsed, false);
assert.deepStrictEqual(list[4].depth, 1);
assert.deepStrictEqual(list[5].element, 2);
assert.deepStrictEqual(list[5].collapsed, false);
assert.deepStrictEqual(list[5].depth, 1);
}));
test('deep insert collapsed', () => withSmartSplice(options => {
@@ -120,16 +120,16 @@ suite('IndexTreeModel', () => {
{ element: 2 }
], options);
assert.deepEqual(list.length, 3);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsed, true);
assert.deepEqual(list[0].depth, 1);
assert.deepEqual(list[1].element, 1);
assert.deepEqual(list[1].collapsed, false);
assert.deepEqual(list[1].depth, 1);
assert.deepEqual(list[2].element, 2);
assert.deepEqual(list[2].collapsed, false);
assert.deepEqual(list[2].depth, 1);
assert.deepStrictEqual(list.length, 3);
assert.deepStrictEqual(list[0].element, 0);
assert.deepStrictEqual(list[0].collapsed, true);
assert.deepStrictEqual(list[0].depth, 1);
assert.deepStrictEqual(list[1].element, 1);
assert.deepStrictEqual(list[1].collapsed, false);
assert.deepStrictEqual(list[1].depth, 1);
assert.deepStrictEqual(list[2].element, 2);
assert.deepStrictEqual(list[2].collapsed, false);
assert.deepStrictEqual(list[2].depth, 1);
}));
test('delete', () => withSmartSplice(options => {
@@ -142,19 +142,19 @@ suite('IndexTreeModel', () => {
{ element: 2 }
], options);
assert.deepEqual(list.length, 3);
assert.deepStrictEqual(list.length, 3);
model.splice([1], 1, undefined, options);
assert.deepEqual(list.length, 2);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsed, false);
assert.deepEqual(list[0].depth, 1);
assert.deepEqual(list[1].element, 2);
assert.deepEqual(list[1].collapsed, false);
assert.deepEqual(list[1].depth, 1);
assert.deepStrictEqual(list.length, 2);
assert.deepStrictEqual(list[0].element, 0);
assert.deepStrictEqual(list[0].collapsed, false);
assert.deepStrictEqual(list[0].depth, 1);
assert.deepStrictEqual(list[1].element, 2);
assert.deepStrictEqual(list[1].collapsed, false);
assert.deepStrictEqual(list[1].depth, 1);
model.splice([0], 2, undefined, options);
assert.deepEqual(list.length, 0);
assert.deepStrictEqual(list.length, 0);
}));
test('nested delete', () => withSmartSplice(options => {
@@ -173,22 +173,22 @@ suite('IndexTreeModel', () => {
{ element: 2 }
], options);
assert.deepEqual(list.length, 6);
assert.deepStrictEqual(list.length, 6);
model.splice([1], 2, undefined, options);
assert.deepEqual(list.length, 4);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsed, false);
assert.deepEqual(list[0].depth, 1);
assert.deepEqual(list[1].element, 10);
assert.deepEqual(list[1].collapsed, false);
assert.deepEqual(list[1].depth, 2);
assert.deepEqual(list[2].element, 11);
assert.deepEqual(list[2].collapsed, false);
assert.deepEqual(list[2].depth, 2);
assert.deepEqual(list[3].element, 12);
assert.deepEqual(list[3].collapsed, false);
assert.deepEqual(list[3].depth, 2);
assert.deepStrictEqual(list.length, 4);
assert.deepStrictEqual(list[0].element, 0);
assert.deepStrictEqual(list[0].collapsed, false);
assert.deepStrictEqual(list[0].depth, 1);
assert.deepStrictEqual(list[1].element, 10);
assert.deepStrictEqual(list[1].collapsed, false);
assert.deepStrictEqual(list[1].depth, 2);
assert.deepStrictEqual(list[2].element, 11);
assert.deepStrictEqual(list[2].collapsed, false);
assert.deepStrictEqual(list[2].depth, 2);
assert.deepStrictEqual(list[3].element, 12);
assert.deepStrictEqual(list[3].collapsed, false);
assert.deepStrictEqual(list[3].depth, 2);
}));
test('deep delete', () => withSmartSplice(options => {
@@ -207,16 +207,16 @@ suite('IndexTreeModel', () => {
{ element: 2 }
], options);
assert.deepEqual(list.length, 6);
assert.deepStrictEqual(list.length, 6);
model.splice([0], 1, undefined, options);
assert.deepEqual(list.length, 2);
assert.deepEqual(list[0].element, 1);
assert.deepEqual(list[0].collapsed, false);
assert.deepEqual(list[0].depth, 1);
assert.deepEqual(list[1].element, 2);
assert.deepEqual(list[1].collapsed, false);
assert.deepEqual(list[1].depth, 1);
assert.deepStrictEqual(list.length, 2);
assert.deepStrictEqual(list[0].element, 1);
assert.deepStrictEqual(list[0].collapsed, false);
assert.deepStrictEqual(list[0].depth, 1);
assert.deepStrictEqual(list[1].element, 2);
assert.deepStrictEqual(list[1].collapsed, false);
assert.deepStrictEqual(list[1].depth, 1);
}));
test('smart splice deep', () => {
@@ -269,13 +269,13 @@ suite('IndexTreeModel', () => {
{ element: 2 }
], options);
assert.deepEqual(list.length, 3);
assert.deepStrictEqual(list.length, 3);
model.splice([0, 1], 1, undefined, options);
assert.deepEqual(list.length, 3);
assert.deepStrictEqual(list.length, 3);
model.splice([0, 0], 2, undefined, options);
assert.deepEqual(list.length, 3);
assert.deepStrictEqual(list.length, 3);
}));
test('collapse', () => withSmartSplice(options => {
@@ -294,19 +294,19 @@ suite('IndexTreeModel', () => {
{ element: 2 }
], options);
assert.deepEqual(list.length, 6);
assert.deepStrictEqual(list.length, 6);
model.setCollapsed([0], true);
assert.deepEqual(list.length, 3);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsed, true);
assert.deepEqual(list[0].depth, 1);
assert.deepEqual(list[1].element, 1);
assert.deepEqual(list[1].collapsed, false);
assert.deepEqual(list[1].depth, 1);
assert.deepEqual(list[2].element, 2);
assert.deepEqual(list[2].collapsed, false);
assert.deepEqual(list[2].depth, 1);
assert.deepStrictEqual(list.length, 3);
assert.deepStrictEqual(list[0].element, 0);
assert.deepStrictEqual(list[0].collapsed, true);
assert.deepStrictEqual(list[0].depth, 1);
assert.deepStrictEqual(list[1].element, 1);
assert.deepStrictEqual(list[1].collapsed, false);
assert.deepStrictEqual(list[1].depth, 1);
assert.deepStrictEqual(list[2].element, 2);
assert.deepStrictEqual(list[2].collapsed, false);
assert.deepStrictEqual(list[2].depth, 1);
}));
test('updates collapsible', () => withSmartSplice(options => {
@@ -325,12 +325,18 @@ suite('IndexTreeModel', () => {
assert.strictEqual(list[1].collapsible, false);
model.splice([0, 0], 1, [], options);
assert.strictEqual(list[0].collapsible, false);
assert.strictEqual(list[1], undefined);
{
const [first, second] = list;
assert.strictEqual(first.collapsible, false);
assert.strictEqual(second, undefined);
}
model.splice([0, 0], 0, [{ element: 1 }], options);
assert.strictEqual(list[0].collapsible, true);
assert.strictEqual(list[1].collapsible, false);
{
const [first, second] = list;
assert.strictEqual(first.collapsible, true);
assert.strictEqual(second.collapsible, false);
}
}));
test('expand', () => withSmartSplice(options => {
@@ -349,28 +355,28 @@ suite('IndexTreeModel', () => {
{ element: 2 }
], options);
assert.deepEqual(list.length, 3);
assert.deepStrictEqual(list.length, 3);
model.setCollapsed([0], false);
assert.deepEqual(list.length, 6);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsed, false);
assert.deepEqual(list[0].depth, 1);
assert.deepEqual(list[1].element, 10);
assert.deepEqual(list[1].collapsed, false);
assert.deepEqual(list[1].depth, 2);
assert.deepEqual(list[2].element, 11);
assert.deepEqual(list[2].collapsed, false);
assert.deepEqual(list[2].depth, 2);
assert.deepEqual(list[3].element, 12);
assert.deepEqual(list[3].collapsed, false);
assert.deepEqual(list[3].depth, 2);
assert.deepEqual(list[4].element, 1);
assert.deepEqual(list[4].collapsed, false);
assert.deepEqual(list[4].depth, 1);
assert.deepEqual(list[5].element, 2);
assert.deepEqual(list[5].collapsed, false);
assert.deepEqual(list[5].depth, 1);
assert.deepStrictEqual(list.length, 6);
assert.deepStrictEqual(list[0].element, 0);
assert.deepStrictEqual(list[0].collapsed, false);
assert.deepStrictEqual(list[0].depth, 1);
assert.deepStrictEqual(list[1].element, 10);
assert.deepStrictEqual(list[1].collapsed, false);
assert.deepStrictEqual(list[1].depth, 2);
assert.deepStrictEqual(list[2].element, 11);
assert.deepStrictEqual(list[2].collapsed, false);
assert.deepStrictEqual(list[2].depth, 2);
assert.deepStrictEqual(list[3].element, 12);
assert.deepStrictEqual(list[3].collapsed, false);
assert.deepStrictEqual(list[3].depth, 2);
assert.deepStrictEqual(list[4].element, 1);
assert.deepStrictEqual(list[4].collapsed, false);
assert.deepStrictEqual(list[4].depth, 1);
assert.deepStrictEqual(list[5].element, 2);
assert.deepStrictEqual(list[5].collapsed, false);
assert.deepStrictEqual(list[5].depth, 1);
}));
test('smart diff consistency', () => {
@@ -437,16 +443,16 @@ suite('IndexTreeModel', () => {
}
]);
assert.deepEqual(list.length, 5);
assert.deepEqual(toArray(list), [1, 11, 111, 2, 21]);
assert.deepStrictEqual(list.length, 5);
assert.deepStrictEqual(toArray(list), [1, 11, 111, 2, 21]);
model.setCollapsed([0, 0], true);
assert.deepEqual(list.length, 4);
assert.deepEqual(toArray(list), [1, 11, 2, 21]);
assert.deepStrictEqual(list.length, 4);
assert.deepStrictEqual(toArray(list), [1, 11, 2, 21]);
model.setCollapsed([1], true);
assert.deepEqual(list.length, 3);
assert.deepEqual(toArray(list), [1, 11, 2]);
assert.deepStrictEqual(list.length, 3);
assert.deepStrictEqual(toArray(list), [1, 11, 2]);
});
test('setCollapsible', () => {
@@ -461,55 +467,55 @@ suite('IndexTreeModel', () => {
}
]);
assert.deepEqual(list.length, 2);
assert.deepStrictEqual(list.length, 2);
model.setCollapsible([0], false);
assert.deepEqual(list.length, 2);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsible, false);
assert.deepEqual(list[0].collapsed, false);
assert.deepEqual(list[1].element, 10);
assert.deepEqual(list[1].collapsible, false);
assert.deepEqual(list[1].collapsed, false);
assert.deepStrictEqual(list.length, 2);
assert.deepStrictEqual(list[0].element, 0);
assert.deepStrictEqual(list[0].collapsible, false);
assert.deepStrictEqual(list[0].collapsed, false);
assert.deepStrictEqual(list[1].element, 10);
assert.deepStrictEqual(list[1].collapsible, false);
assert.deepStrictEqual(list[1].collapsed, false);
assert.deepEqual(model.setCollapsed([0], true), false);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsible, false);
assert.deepEqual(list[0].collapsed, false);
assert.deepEqual(list[1].element, 10);
assert.deepEqual(list[1].collapsible, false);
assert.deepEqual(list[1].collapsed, false);
assert.deepStrictEqual(model.setCollapsed([0], true), false);
assert.deepStrictEqual(list[0].element, 0);
assert.deepStrictEqual(list[0].collapsible, false);
assert.deepStrictEqual(list[0].collapsed, false);
assert.deepStrictEqual(list[1].element, 10);
assert.deepStrictEqual(list[1].collapsible, false);
assert.deepStrictEqual(list[1].collapsed, false);
assert.deepEqual(model.setCollapsed([0], false), false);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsible, false);
assert.deepEqual(list[0].collapsed, false);
assert.deepEqual(list[1].element, 10);
assert.deepEqual(list[1].collapsible, false);
assert.deepEqual(list[1].collapsed, false);
assert.deepStrictEqual(model.setCollapsed([0], false), false);
assert.deepStrictEqual(list[0].element, 0);
assert.deepStrictEqual(list[0].collapsible, false);
assert.deepStrictEqual(list[0].collapsed, false);
assert.deepStrictEqual(list[1].element, 10);
assert.deepStrictEqual(list[1].collapsible, false);
assert.deepStrictEqual(list[1].collapsed, false);
model.setCollapsible([0], true);
assert.deepEqual(list.length, 2);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsible, true);
assert.deepEqual(list[0].collapsed, false);
assert.deepEqual(list[1].element, 10);
assert.deepEqual(list[1].collapsible, false);
assert.deepEqual(list[1].collapsed, false);
assert.deepStrictEqual(list.length, 2);
assert.deepStrictEqual(list[0].element, 0);
assert.deepStrictEqual(list[0].collapsible, true);
assert.deepStrictEqual(list[0].collapsed, false);
assert.deepStrictEqual(list[1].element, 10);
assert.deepStrictEqual(list[1].collapsible, false);
assert.deepStrictEqual(list[1].collapsed, false);
assert.deepEqual(model.setCollapsed([0], true), true);
assert.deepEqual(list.length, 1);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsible, true);
assert.deepEqual(list[0].collapsed, true);
assert.deepStrictEqual(model.setCollapsed([0], true), true);
assert.deepStrictEqual(list.length, 1);
assert.deepStrictEqual(list[0].element, 0);
assert.deepStrictEqual(list[0].collapsible, true);
assert.deepStrictEqual(list[0].collapsed, true);
assert.deepEqual(model.setCollapsed([0], false), true);
assert.deepEqual(list[0].element, 0);
assert.deepEqual(list[0].collapsible, true);
assert.deepEqual(list[0].collapsed, false);
assert.deepEqual(list[1].element, 10);
assert.deepEqual(list[1].collapsible, false);
assert.deepEqual(list[1].collapsed, false);
assert.deepStrictEqual(model.setCollapsed([0], false), true);
assert.deepStrictEqual(list[0].element, 0);
assert.deepStrictEqual(list[0].collapsible, true);
assert.deepStrictEqual(list[0].collapsed, false);
assert.deepStrictEqual(list[1].element, 10);
assert.deepStrictEqual(list[1].collapsible, false);
assert.deepStrictEqual(list[1].collapsed, false);
});
test('simple filter', () => {
@@ -536,14 +542,14 @@ suite('IndexTreeModel', () => {
}
]);
assert.deepEqual(list.length, 4);
assert.deepEqual(toArray(list), [0, 2, 4, 6]);
assert.deepStrictEqual(list.length, 4);
assert.deepStrictEqual(toArray(list), [0, 2, 4, 6]);
model.setCollapsed([0], true);
assert.deepEqual(toArray(list), [0]);
assert.deepStrictEqual(toArray(list), [0]);
model.setCollapsed([0], false);
assert.deepEqual(toArray(list), [0, 2, 4, 6]);
assert.deepStrictEqual(toArray(list), [0, 2, 4, 6]);
});
test('recursive filter on initial model', () => {
@@ -565,7 +571,7 @@ suite('IndexTreeModel', () => {
}
]);
assert.deepEqual(toArray(list), []);
assert.deepStrictEqual(toArray(list), []);
});
test('refilter', () => {
@@ -593,18 +599,18 @@ suite('IndexTreeModel', () => {
},
]);
assert.deepEqual(toArray(list), [0, 1, 2, 3, 4, 5, 6, 7]);
assert.deepStrictEqual(toArray(list), [0, 1, 2, 3, 4, 5, 6, 7]);
model.refilter();
assert.deepEqual(toArray(list), [0, 1, 2, 3, 4, 5, 6, 7]);
assert.deepStrictEqual(toArray(list), [0, 1, 2, 3, 4, 5, 6, 7]);
shouldFilter = true;
model.refilter();
assert.deepEqual(toArray(list), [0, 2, 4, 6]);
assert.deepStrictEqual(toArray(list), [0, 2, 4, 6]);
shouldFilter = false;
model.refilter();
assert.deepEqual(toArray(list), [0, 1, 2, 3, 4, 5, 6, 7]);
assert.deepStrictEqual(toArray(list), [0, 1, 2, 3, 4, 5, 6, 7]);
});
test('recursive filter', () => {
@@ -640,17 +646,17 @@ suite('IndexTreeModel', () => {
},
]);
assert.deepEqual(list.length, 10);
assert.deepStrictEqual(list.length, 10);
query = /build/;
model.refilter();
assert.deepEqual(toArray(list), ['vscode', '.build', 'github', 'build.js', 'build']);
assert.deepStrictEqual(toArray(list), ['vscode', '.build', 'github', 'build.js', 'build']);
model.setCollapsed([0], true);
assert.deepEqual(toArray(list), ['vscode']);
assert.deepStrictEqual(toArray(list), ['vscode']);
model.setCollapsed([0], false);
assert.deepEqual(toArray(list), ['vscode', '.build', 'github', 'build.js', 'build']);
assert.deepStrictEqual(toArray(list), ['vscode', '.build', 'github', 'build.js', 'build']);
});
test('recursive filter with collapse', () => {
@@ -686,17 +692,17 @@ suite('IndexTreeModel', () => {
},
]);
assert.deepEqual(list.length, 10);
assert.deepStrictEqual(list.length, 10);
query = /gulp/;
model.refilter();
assert.deepEqual(toArray(list), ['vscode', 'build', 'gulpfile.js']);
assert.deepStrictEqual(toArray(list), ['vscode', 'build', 'gulpfile.js']);
model.setCollapsed([0, 3], true);
assert.deepEqual(toArray(list), ['vscode', 'build']);
assert.deepStrictEqual(toArray(list), ['vscode', 'build']);
model.setCollapsed([0], true);
assert.deepEqual(toArray(list), ['vscode']);
assert.deepStrictEqual(toArray(list), ['vscode']);
});
test('recursive filter while collapsed', () => {
@@ -732,24 +738,24 @@ suite('IndexTreeModel', () => {
},
]);
assert.deepEqual(toArray(list), ['vscode']);
assert.deepStrictEqual(toArray(list), ['vscode']);
query = /gulp/;
model.refilter();
assert.deepEqual(toArray(list), ['vscode']);
assert.deepStrictEqual(toArray(list), ['vscode']);
model.setCollapsed([0], false);
assert.deepEqual(toArray(list), ['vscode', 'build', 'gulpfile.js']);
assert.deepStrictEqual(toArray(list), ['vscode', 'build', 'gulpfile.js']);
model.setCollapsed([0], true);
assert.deepEqual(toArray(list), ['vscode']);
assert.deepStrictEqual(toArray(list), ['vscode']);
query = new RegExp('');
model.refilter();
assert.deepEqual(toArray(list), ['vscode']);
assert.deepStrictEqual(toArray(list), ['vscode']);
model.setCollapsed([0], false);
assert.deepEqual(list.length, 10);
assert.deepStrictEqual(list.length, 10);
});
suite('getNodeLocation', () => {
@@ -770,12 +776,12 @@ suite('IndexTreeModel', () => {
{ element: 2 }
]);
assert.deepEqual(model.getNodeLocation(list[0]), [0]);
assert.deepEqual(model.getNodeLocation(list[1]), [0, 0]);
assert.deepEqual(model.getNodeLocation(list[2]), [0, 1]);
assert.deepEqual(model.getNodeLocation(list[3]), [0, 2]);
assert.deepEqual(model.getNodeLocation(list[4]), [1]);
assert.deepEqual(model.getNodeLocation(list[5]), [2]);
assert.deepStrictEqual(model.getNodeLocation(list[0]), [0]);
assert.deepStrictEqual(model.getNodeLocation(list[1]), [0, 0]);
assert.deepStrictEqual(model.getNodeLocation(list[2]), [0, 1]);
assert.deepStrictEqual(model.getNodeLocation(list[3]), [0, 2]);
assert.deepStrictEqual(model.getNodeLocation(list[4]), [1]);
assert.deepStrictEqual(model.getNodeLocation(list[5]), [2]);
});
test('with filter', () => {
@@ -802,10 +808,10 @@ suite('IndexTreeModel', () => {
}
]);
assert.deepEqual(model.getNodeLocation(list[0]), [0]);
assert.deepEqual(model.getNodeLocation(list[1]), [0, 1]);
assert.deepEqual(model.getNodeLocation(list[2]), [0, 3]);
assert.deepEqual(model.getNodeLocation(list[3]), [0, 5]);
assert.deepStrictEqual(model.getNodeLocation(list[0]), [0]);
assert.deepStrictEqual(model.getNodeLocation(list[1]), [0, 1]);
assert.deepStrictEqual(model.getNodeLocation(list[2]), [0, 3]);
assert.deepStrictEqual(model.getNodeLocation(list[3]), [0, 5]);
});
});
@@ -826,21 +832,21 @@ suite('IndexTreeModel', () => {
{ element: 'platinum' }
]);
assert.deepEqual(toArray(list), ['silver', 'gold', 'platinum']);
assert.deepStrictEqual(toArray(list), ['silver', 'gold', 'platinum']);
query = /platinum/;
model.refilter();
assert.deepEqual(toArray(list), ['platinum']);
assert.deepStrictEqual(toArray(list), ['platinum']);
model.splice([0], Number.POSITIVE_INFINITY, [
{ element: 'silver' },
{ element: 'gold' },
{ element: 'platinum' }
]);
assert.deepEqual(toArray(list), ['platinum']);
assert.deepStrictEqual(toArray(list), ['platinum']);
model.refilter();
assert.deepEqual(toArray(list), ['platinum']);
assert.deepStrictEqual(toArray(list), ['platinum']);
});
test('explicit hidden nodes should have renderNodeCount == 0, issue #83211', () => {
@@ -859,18 +865,18 @@ suite('IndexTreeModel', () => {
{ element: 'b', children: [{ element: 'bb' }] }
]);
assert.deepEqual(toArray(list), ['a', 'aa', 'b', 'bb']);
assert.deepEqual(model.getListIndex([0]), 0);
assert.deepEqual(model.getListIndex([0, 0]), 1);
assert.deepEqual(model.getListIndex([1]), 2);
assert.deepEqual(model.getListIndex([1, 0]), 3);
assert.deepStrictEqual(toArray(list), ['a', 'aa', 'b', 'bb']);
assert.deepStrictEqual(model.getListIndex([0]), 0);
assert.deepStrictEqual(model.getListIndex([0, 0]), 1);
assert.deepStrictEqual(model.getListIndex([1]), 2);
assert.deepStrictEqual(model.getListIndex([1, 0]), 3);
query = /b/;
model.refilter();
assert.deepEqual(toArray(list), ['b', 'bb']);
assert.deepEqual(model.getListIndex([0]), -1);
assert.deepEqual(model.getListIndex([0, 0]), -1);
assert.deepEqual(model.getListIndex([1]), 0);
assert.deepEqual(model.getListIndex([1, 0]), 1);
assert.deepStrictEqual(toArray(list), ['b', 'bb']);
assert.deepStrictEqual(model.getListIndex([0]), -1);
assert.deepStrictEqual(model.getListIndex([0, 0]), -1);
assert.deepStrictEqual(model.getListIndex([1]), 0);
assert.deepStrictEqual(model.getListIndex([1, 0]), 1);
});
});

84
lib/vscode/src/vs/base/test/browser/ui/tree/objectTreeModel.test.ts
View File

@@ -28,8 +28,8 @@ suite('ObjectTreeModel', function () {
const list: ITreeNode<number>[] = [];
const model = new ObjectTreeModel<number>('test', toList(list));
assert(model);
assert.equal(list.length, 0);
assert.equal(model.size, 0);
assert.strictEqual(list.length, 0);
assert.strictEqual(model.size, 0);
});
test('flat', () => {
@@ -42,8 +42,8 @@ suite('ObjectTreeModel', function () {
{ element: 2 }
]);
assert.deepEqual(toArray(list), [0, 1, 2]);
assert.equal(model.size, 3);
assert.deepStrictEqual(toArray(list), [0, 1, 2]);
assert.strictEqual(model.size, 3);
model.setChildren(null, [
{ element: 3 },
@@ -51,12 +51,12 @@ suite('ObjectTreeModel', function () {
{ element: 5 },
]);
assert.deepEqual(toArray(list), [3, 4, 5]);
assert.equal(model.size, 3);
assert.deepStrictEqual(toArray(list), [3, 4, 5]);
assert.strictEqual(model.size, 3);
model.setChildren(null);
assert.deepEqual(toArray(list), []);
assert.equal(model.size, 0);
assert.deepStrictEqual(toArray(list), []);
assert.strictEqual(model.size, 0);
});
test('nested', () => {
@@ -75,24 +75,24 @@ suite('ObjectTreeModel', function () {
{ element: 2 }
]);
assert.deepEqual(toArray(list), [0, 10, 11, 12, 1, 2]);
assert.equal(model.size, 6);
assert.deepStrictEqual(toArray(list), [0, 10, 11, 12, 1, 2]);
assert.strictEqual(model.size, 6);
model.setChildren(12, [
{ element: 120 },
{ element: 121 }
]);
assert.deepEqual(toArray(list), [0, 10, 11, 12, 120, 121, 1, 2]);
assert.equal(model.size, 8);
assert.deepStrictEqual(toArray(list), [0, 10, 11, 12, 120, 121, 1, 2]);
assert.strictEqual(model.size, 8);
model.setChildren(0);
assert.deepEqual(toArray(list), [0, 1, 2]);
assert.equal(model.size, 3);
assert.deepStrictEqual(toArray(list), [0, 1, 2]);
assert.strictEqual(model.size, 3);
model.setChildren(null);
assert.deepEqual(toArray(list), []);
assert.equal(model.size, 0);
assert.deepStrictEqual(toArray(list), []);
assert.strictEqual(model.size, 0);
});
test('setChildren on collapsed node', () => {
@@ -103,17 +103,17 @@ suite('ObjectTreeModel', function () {
{ element: 0, collapsed: true }
]);
assert.deepEqual(toArray(list), [0]);
assert.deepStrictEqual(toArray(list), [0]);
model.setChildren(0, [
{ element: 1 },
{ element: 2 }
]);
assert.deepEqual(toArray(list), [0]);
assert.deepStrictEqual(toArray(list), [0]);
model.setCollapsed(0, false);
assert.deepEqual(toArray(list), [0, 1, 2]);
assert.deepStrictEqual(toArray(list), [0, 1, 2]);
});
test('setChildren on expanded, unrevealed node', () => {
@@ -129,17 +129,17 @@ suite('ObjectTreeModel', function () {
{ element: 2 }
]);
assert.deepEqual(toArray(list), [1, 2]);
assert.deepStrictEqual(toArray(list), [1, 2]);
model.setChildren(11, [
{ element: 111 },
{ element: 112 }
]);
assert.deepEqual(toArray(list), [1, 2]);
assert.deepStrictEqual(toArray(list), [1, 2]);
model.setCollapsed(1, false);
assert.deepEqual(toArray(list), [1, 11, 111, 112, 2]);
assert.deepStrictEqual(toArray(list), [1, 11, 111, 112, 2]);
});
test('collapse state is preserved with strict identity', () => {
@@ -148,26 +148,26 @@ suite('ObjectTreeModel', function () {
const data = [{ element: 'father', children: [{ element: 'child' }] }];
model.setChildren(null, data);
assert.deepEqual(toArray(list), ['father']);
assert.deepStrictEqual(toArray(list), ['father']);
model.setCollapsed('father', false);
assert.deepEqual(toArray(list), ['father', 'child']);
assert.deepStrictEqual(toArray(list), ['father', 'child']);
model.setChildren(null, data);
assert.deepEqual(toArray(list), ['father', 'child']);
assert.deepStrictEqual(toArray(list), ['father', 'child']);
const data2 = [{ element: 'father', children: [{ element: 'child' }] }, { element: 'uncle' }];
model.setChildren(null, data2);
assert.deepEqual(toArray(list), ['father', 'child', 'uncle']);
assert.deepStrictEqual(toArray(list), ['father', 'child', 'uncle']);
model.setChildren(null, [{ element: 'uncle' }]);
assert.deepEqual(toArray(list), ['uncle']);
assert.deepStrictEqual(toArray(list), ['uncle']);
model.setChildren(null, data2);
assert.deepEqual(toArray(list), ['father', 'uncle']);
assert.deepStrictEqual(toArray(list), ['father', 'uncle']);
model.setChildren(null, data);
assert.deepEqual(toArray(list), ['father']);
assert.deepStrictEqual(toArray(list), ['father']);
});
test('sorter', () => {
@@ -182,7 +182,7 @@ suite('ObjectTreeModel', function () {
];
model.setChildren(null, data);
assert.deepEqual(toArray(list), ['airplanes', 'jet', 'passenger', 'bicycles', 'dutch', 'electric', 'mountain', 'cars', 'compact', 'convertible', 'sedan']);
assert.deepStrictEqual(toArray(list), ['airplanes', 'jet', 'passenger', 'bicycles', 'dutch', 'electric', 'mountain', 'cars', 'compact', 'convertible', 'sedan']);
});
test('resort', () => {
@@ -197,29 +197,29 @@ suite('ObjectTreeModel', function () {
];
model.setChildren(null, data);
assert.deepEqual(toArray(list), ['cars', 'sedan', 'convertible', 'compact', 'airplanes', 'passenger', 'jet', 'bicycles', 'dutch', 'mountain', 'electric']);
assert.deepStrictEqual(toArray(list), ['cars', 'sedan', 'convertible', 'compact', 'airplanes', 'passenger', 'jet', 'bicycles', 'dutch', 'mountain', 'electric']);
// lexicographical
compare = (a, b) => a < b ? -1 : 1;
// non-recursive
model.resort(null, false);
assert.deepEqual(toArray(list), ['airplanes', 'passenger', 'jet', 'bicycles', 'dutch', 'mountain', 'electric', 'cars', 'sedan', 'convertible', 'compact']);
assert.deepStrictEqual(toArray(list), ['airplanes', 'passenger', 'jet', 'bicycles', 'dutch', 'mountain', 'electric', 'cars', 'sedan', 'convertible', 'compact']);
// recursive
model.resort();
assert.deepEqual(toArray(list), ['airplanes', 'jet', 'passenger', 'bicycles', 'dutch', 'electric', 'mountain', 'cars', 'compact', 'convertible', 'sedan']);
assert.deepStrictEqual(toArray(list), ['airplanes', 'jet', 'passenger', 'bicycles', 'dutch', 'electric', 'mountain', 'cars', 'compact', 'convertible', 'sedan']);
// reverse
compare = (a, b) => a < b ? 1 : -1;
// scoped
model.resort('cars');
assert.deepEqual(toArray(list), ['airplanes', 'jet', 'passenger', 'bicycles', 'dutch', 'electric', 'mountain', 'cars', 'sedan', 'convertible', 'compact']);
assert.deepStrictEqual(toArray(list), ['airplanes', 'jet', 'passenger', 'bicycles', 'dutch', 'electric', 'mountain', 'cars', 'sedan', 'convertible', 'compact']);
// recursive
model.resort();
assert.deepEqual(toArray(list), ['cars', 'sedan', 'convertible', 'compact', 'bicycles', 'mountain', 'electric', 'dutch', 'airplanes', 'passenger', 'jet']);
assert.deepStrictEqual(toArray(list), ['cars', 'sedan', 'convertible', 'compact', 'bicycles', 'mountain', 'electric', 'dutch', 'airplanes', 'passenger', 'jet']);
});
test('expandTo', () => {
@@ -238,9 +238,9 @@ suite('ObjectTreeModel', function () {
{ element: 2 }
]);
assert.deepEqual(toArray(list), [0, 1, 2]);
assert.deepStrictEqual(toArray(list), [0, 1, 2]);
model.expandTo(1000);
assert.deepEqual(toArray(list), [0, 10, 100, 1000, 11, 12, 1, 2]);
assert.deepStrictEqual(toArray(list), [0, 10, 100, 1000, 11, 12, 1, 2]);
});
test('issue #95641', () => {
@@ -258,19 +258,19 @@ suite('ObjectTreeModel', function () {
const model = new ObjectTreeModel<string>('test', toList(list), { filter });
model.setChildren(null, [{ element: 'file', children: [{ element: 'hello' }] }]);
assert.deepEqual(toArray(list), ['file', 'hello']);
assert.deepStrictEqual(toArray(list), ['file', 'hello']);
fn = (el: string) => el === 'world';
model.refilter();
assert.deepEqual(toArray(list), []);
assert.deepStrictEqual(toArray(list), []);
model.setChildren('file', [{ element: 'world' }]);
assert.deepEqual(toArray(list), ['file', 'world']);
assert.deepStrictEqual(toArray(list), ['file', 'world']);
model.setChildren('file', [{ element: 'hello' }]);
assert.deepEqual(toArray(list), []);
assert.deepStrictEqual(toArray(list), []);
model.setChildren('file', [{ element: 'world' }]);
assert.deepEqual(toArray(list), ['file', 'world']);
assert.deepStrictEqual(toArray(list), ['file', 'world']);
});
});

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

@@ -8,6 +8,7 @@ import * as async from 'vs/base/common/async';
import { isPromiseCanceledError } from 'vs/base/common/errors';
import { URI } from 'vs/base/common/uri';
import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';
import { Event } from 'vs/base/common/event';
suite('Async', () => {
@@ -484,13 +485,11 @@ suite('Async', () => {
});
});
test('Queue - events', function (done) {
test('Queue - events', function () {
let queue = new async.Queue();
let finished = false;
queue.onFinished(() => {
done();
});
const onFinished = Event.toPromise(queue.onFinished);
let res: number[] = [];
@@ -508,6 +507,8 @@ suite('Async', () => {
assert.ok(!finished);
});
});
return onFinished;
});
test('ResourceQueue - simple', function () {
@@ -529,7 +530,7 @@ suite('Async', () => {
return new Promise<void>(c => setTimeout(() => c(), 0)).then(() => {
const r1Queue2 = queue.queueFor(URI.file('/some/path'));
assert.notEqual(r1Queue, r1Queue2); // previous one got disposed after finishing
assert.notStrictEqual(r1Queue, r1Queue2); // previous one got disposed after finishing
});
});

32
lib/vscode/src/vs/base/test/common/cache.test.ts
View File

@@ -14,9 +14,9 @@ suite('Cache', () => {
const cache = new Cache(_ => Promise.resolve(counter++));
return cache.get().promise
.then(c => assert.equal(c, 0), () => assert.fail('Unexpected assertion error'))
.then(c => assert.strictEqual(c, 0), () => assert.fail('Unexpected assertion error'))
.then(() => cache.get().promise)
.then(c => assert.equal(c, 0), () => assert.fail('Unexpected assertion error'));
.then(c => assert.strictEqual(c, 0), () => assert.fail('Unexpected assertion error'));
});
test('simple error', () => {
@@ -24,9 +24,9 @@ suite('Cache', () => {
const cache = new Cache(_ => Promise.reject(new Error(String(counter++))));
return cache.get().promise
.then(() => assert.fail('Unexpected assertion error'), err => assert.equal(err.message, 0))
.then(() => assert.fail('Unexpected assertion error'), err => assert.strictEqual(err.message, '0'))
.then(() => cache.get().promise)
.then(() => assert.fail('Unexpected assertion error'), err => assert.equal(err.message, 0));
.then(() => assert.fail('Unexpected assertion error'), err => assert.strictEqual(err.message, '0'));
});
test('should retry cancellations', () => {
@@ -37,29 +37,29 @@ suite('Cache', () => {
return Promise.resolve(timeout(2, token).then(() => counter2++));
});
assert.equal(counter1, 0);
assert.equal(counter2, 0);
assert.strictEqual(counter1, 0);
assert.strictEqual(counter2, 0);
let result = cache.get();
assert.equal(counter1, 1);
assert.equal(counter2, 0);
assert.strictEqual(counter1, 1);
assert.strictEqual(counter2, 0);
result.promise.then(undefined, () => assert(true));
result.dispose();
assert.equal(counter1, 1);
assert.equal(counter2, 0);
assert.strictEqual(counter1, 1);
assert.strictEqual(counter2, 0);
result = cache.get();
assert.equal(counter1, 2);
assert.equal(counter2, 0);
assert.strictEqual(counter1, 2);
assert.strictEqual(counter2, 0);
return result.promise
.then(c => {
assert.equal(counter1, 2);
assert.equal(counter2, 1);
assert.strictEqual(counter1, 2);
assert.strictEqual(counter2, 1);
})
.then(() => cache.get().promise)
.then(c => {
assert.equal(counter1, 2);
assert.equal(counter2, 1);
assert.strictEqual(counter1, 2);
assert.strictEqual(counter2, 1);
});
});
});

7
lib/vscode/src/vs/base/test/common/cancellation.test.ts
View File

@@ -12,7 +12,7 @@ suite('CancellationToken', function () {
assert.strictEqual(typeof CancellationToken.None.onCancellationRequested, 'function');
});
test('cancel before token', function (done) {
test('cancel before token', function () {
const source = new CancellationTokenSource();
assert.strictEqual(source.token.isCancellationRequested, false);
@@ -20,9 +20,8 @@ suite('CancellationToken', function () {
assert.strictEqual(source.token.isCancellationRequested, true);
source.token.onCancellationRequested(function () {
assert.ok(true);
done();
return new Promise<void>(resolve => {
source.token.onCancellationRequested(() => resolve());
});
});

28
lib/vscode/src/vs/base/test/common/codicons.test.ts Normal file
View File

@@ -0,0 +1,28 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
import { getCodiconAriaLabel } from 'vs/base/common/codicons';
suite('Codicon', () => {
test('Can get proper aria labels', () => {
// note, the spaces in the results are important
const testCases = new Map<string, string>([
['', ''],
['asdf', 'asdf'],
['asdf$(squirrel)asdf', 'asdf squirrel asdf'],
['asdf $(squirrel) asdf', 'asdf squirrel asdf'],
['$(rocket)asdf', 'rocket asdf'],
['$(rocket) asdf', 'rocket asdf'],
['$(rocket)$(rocket)$(rocket)asdf', 'rocket rocket rocket asdf'],
['$(rocket) asdf $(rocket)', 'rocket asdf rocket'],
['$(rocket)asdf$(rocket)', 'rocket asdf rocket'],
]);
for (const [input, expected] of testCases) {
assert.strictEqual(getCodiconAriaLabel(input), expected);
}
});
});

38
lib/vscode/src/vs/base/test/common/collections.test.ts
View File

@@ -14,18 +14,18 @@ suite('Collections', () => {
let count = 0;
collections.forEach({ toString: 123 }, () => count++);
assert.equal(count, 1);
assert.strictEqual(count, 1);
count = 0;
let dict = Object.create(null);
dict['toString'] = 123;
collections.forEach(dict, () => count++);
assert.equal(count, 1);
assert.strictEqual(count, 1);
collections.forEach(dict, () => false);
collections.forEach(dict, (x, remove) => remove());
assert.equal(dict['toString'], null);
assert.strictEqual(dict['toString'], undefined);
// don't iterate over properties that are not on the object itself
let test = Object.create({ 'derived': true });
@@ -45,12 +45,34 @@ suite('Collections', () => {
let grouped = collections.groupBy(source, x => x.key);
// Group 1
assert.equal(grouped[group1].length, 2);
assert.equal(grouped[group1][0].value, value1);
assert.equal(grouped[group1][1].value, value2);
assert.strictEqual(grouped[group1].length, 2);
assert.strictEqual(grouped[group1][0].value, value1);
assert.strictEqual(grouped[group1][1].value, value2);
// Group 2
assert.equal(grouped[group2].length, 1);
assert.equal(grouped[group2][0].value, value3);
assert.strictEqual(grouped[group2].length, 1);
assert.strictEqual(grouped[group2][0].value, value3);
});
test('groupByNumber', () => {
const group1 = 1, group2 = 2;
const value1 = 'a', value2 = 'b', value3 = 'c';
let source = [
{ key: group1, value: value1 },
{ key: group1, value: value2 },
{ key: group2, value: value3 },
];
let grouped = collections.groupByNumber(source, x => x.key);
// Group 1
assert.strictEqual(grouped.get(group1)!.length, 2);
assert.strictEqual(grouped.get(group1)![0].value, value1);
assert.strictEqual(grouped.get(group1)![1].value, value2);
// Group 2
assert.strictEqual(grouped.get(group2)!.length, 1);
assert.strictEqual(grouped.get(group2)![0].value, value3);
});
});

290
lib/vscode/src/vs/base/test/common/color.test.ts
View File

@@ -20,11 +20,11 @@ suite('Color', () => {
test('getLighterColor', () => {
let color1 = new Color(new HSLA(60, 1, 0.5, 1)), color2 = new Color(new HSLA(0, 0, 0.753, 1));
assert.deepEqual(color1.hsla, Color.getLighterColor(color1, color2).hsla);
assert.deepEqual(new HSLA(0, 0, 0.916, 1), Color.getLighterColor(color2, color1).hsla);
assert.deepEqual(new HSLA(0, 0, 0.851, 1), Color.getLighterColor(color2, color1, 0.3).hsla);
assert.deepEqual(new HSLA(0, 0, 0.981, 1), Color.getLighterColor(color2, color1, 0.7).hsla);
assert.deepEqual(new HSLA(0, 0, 1, 1), Color.getLighterColor(color2, color1, 1).hsla);
assert.deepStrictEqual(color1.hsla, Color.getLighterColor(color1, color2).hsla);
assert.deepStrictEqual(new HSLA(0, 0, 0.916, 1), Color.getLighterColor(color2, color1).hsla);
assert.deepStrictEqual(new HSLA(0, 0, 0.851, 1), Color.getLighterColor(color2, color1, 0.3).hsla);
assert.deepStrictEqual(new HSLA(0, 0, 0.981, 1), Color.getLighterColor(color2, color1, 0.7).hsla);
assert.deepStrictEqual(new HSLA(0, 0, 1, 1), Color.getLighterColor(color2, color1, 1).hsla);
});
@@ -38,164 +38,164 @@ suite('Color', () => {
test('getDarkerColor', () => {
let color1 = new Color(new HSLA(60, 1, 0.5, 1)), color2 = new Color(new HSLA(0, 0, 0.753, 1));
assert.deepEqual(color2.hsla, Color.getDarkerColor(color2, color1).hsla);
assert.deepEqual(new HSLA(60, 1, 0.392, 1), Color.getDarkerColor(color1, color2).hsla);
assert.deepEqual(new HSLA(60, 1, 0.435, 1), Color.getDarkerColor(color1, color2, 0.3).hsla);
assert.deepEqual(new HSLA(60, 1, 0.349, 1), Color.getDarkerColor(color1, color2, 0.7).hsla);
assert.deepEqual(new HSLA(60, 1, 0.284, 1), Color.getDarkerColor(color1, color2, 1).hsla);
assert.deepStrictEqual(color2.hsla, Color.getDarkerColor(color2, color1).hsla);
assert.deepStrictEqual(new HSLA(60, 1, 0.392, 1), Color.getDarkerColor(color1, color2).hsla);
assert.deepStrictEqual(new HSLA(60, 1, 0.435, 1), Color.getDarkerColor(color1, color2, 0.3).hsla);
assert.deepStrictEqual(new HSLA(60, 1, 0.349, 1), Color.getDarkerColor(color1, color2, 0.7).hsla);
assert.deepStrictEqual(new HSLA(60, 1, 0.284, 1), Color.getDarkerColor(color1, color2, 1).hsla);
// Abyss theme
assert.deepEqual(new HSLA(355, 0.874, 0.157, 1), Color.getDarkerColor(Color.fromHex('#770811'), Color.fromHex('#000c18'), 0.4).hsla);
assert.deepStrictEqual(new HSLA(355, 0.874, 0.157, 1), Color.getDarkerColor(Color.fromHex('#770811'), Color.fromHex('#000c18'), 0.4).hsla);
});
test('luminance', () => {
assert.deepEqual(0, new Color(new RGBA(0, 0, 0, 1)).getRelativeLuminance());
assert.deepEqual(1, new Color(new RGBA(255, 255, 255, 1)).getRelativeLuminance());
assert.deepStrictEqual(0, new Color(new RGBA(0, 0, 0, 1)).getRelativeLuminance());
assert.deepStrictEqual(1, new Color(new RGBA(255, 255, 255, 1)).getRelativeLuminance());
assert.deepEqual(0.2126, new Color(new RGBA(255, 0, 0, 1)).getRelativeLuminance());
assert.deepEqual(0.7152, new Color(new RGBA(0, 255, 0, 1)).getRelativeLuminance());
assert.deepEqual(0.0722, new Color(new RGBA(0, 0, 255, 1)).getRelativeLuminance());
assert.deepStrictEqual(0.2126, new Color(new RGBA(255, 0, 0, 1)).getRelativeLuminance());
assert.deepStrictEqual(0.7152, new Color(new RGBA(0, 255, 0, 1)).getRelativeLuminance());
assert.deepStrictEqual(0.0722, new Color(new RGBA(0, 0, 255, 1)).getRelativeLuminance());
assert.deepEqual(0.9278, new Color(new RGBA(255, 255, 0, 1)).getRelativeLuminance());
assert.deepEqual(0.7874, new Color(new RGBA(0, 255, 255, 1)).getRelativeLuminance());
assert.deepEqual(0.2848, new Color(new RGBA(255, 0, 255, 1)).getRelativeLuminance());
assert.deepStrictEqual(0.9278, new Color(new RGBA(255, 255, 0, 1)).getRelativeLuminance());
assert.deepStrictEqual(0.7874, new Color(new RGBA(0, 255, 255, 1)).getRelativeLuminance());
assert.deepStrictEqual(0.2848, new Color(new RGBA(255, 0, 255, 1)).getRelativeLuminance());
assert.deepEqual(0.5271, new Color(new RGBA(192, 192, 192, 1)).getRelativeLuminance());
assert.deepStrictEqual(0.5271, new Color(new RGBA(192, 192, 192, 1)).getRelativeLuminance());
assert.deepEqual(0.2159, new Color(new RGBA(128, 128, 128, 1)).getRelativeLuminance());
assert.deepEqual(0.0459, new Color(new RGBA(128, 0, 0, 1)).getRelativeLuminance());
assert.deepEqual(0.2003, new Color(new RGBA(128, 128, 0, 1)).getRelativeLuminance());
assert.deepEqual(0.1544, new Color(new RGBA(0, 128, 0, 1)).getRelativeLuminance());
assert.deepEqual(0.0615, new Color(new RGBA(128, 0, 128, 1)).getRelativeLuminance());
assert.deepEqual(0.17, new Color(new RGBA(0, 128, 128, 1)).getRelativeLuminance());
assert.deepEqual(0.0156, new Color(new RGBA(0, 0, 128, 1)).getRelativeLuminance());
assert.deepStrictEqual(0.2159, new Color(new RGBA(128, 128, 128, 1)).getRelativeLuminance());
assert.deepStrictEqual(0.0459, new Color(new RGBA(128, 0, 0, 1)).getRelativeLuminance());
assert.deepStrictEqual(0.2003, new Color(new RGBA(128, 128, 0, 1)).getRelativeLuminance());
assert.deepStrictEqual(0.1544, new Color(new RGBA(0, 128, 0, 1)).getRelativeLuminance());
assert.deepStrictEqual(0.0615, new Color(new RGBA(128, 0, 128, 1)).getRelativeLuminance());
assert.deepStrictEqual(0.17, new Color(new RGBA(0, 128, 128, 1)).getRelativeLuminance());
assert.deepStrictEqual(0.0156, new Color(new RGBA(0, 0, 128, 1)).getRelativeLuminance());
});
test('blending', () => {
assert.deepEqual(new Color(new RGBA(0, 0, 0, 0)).blend(new Color(new RGBA(243, 34, 43))), new Color(new RGBA(243, 34, 43)));
assert.deepEqual(new Color(new RGBA(255, 255, 255)).blend(new Color(new RGBA(243, 34, 43))), new Color(new RGBA(255, 255, 255)));
assert.deepEqual(new Color(new RGBA(122, 122, 122, 0.7)).blend(new Color(new RGBA(243, 34, 43))), new Color(new RGBA(158, 95, 98)));
assert.deepEqual(new Color(new RGBA(0, 0, 0, 0.58)).blend(new Color(new RGBA(255, 255, 255, 0.33))), new Color(new RGBA(49, 49, 49, 0.719)));
assert.deepStrictEqual(new Color(new RGBA(0, 0, 0, 0)).blend(new Color(new RGBA(243, 34, 43))), new Color(new RGBA(243, 34, 43)));
assert.deepStrictEqual(new Color(new RGBA(255, 255, 255)).blend(new Color(new RGBA(243, 34, 43))), new Color(new RGBA(255, 255, 255)));
assert.deepStrictEqual(new Color(new RGBA(122, 122, 122, 0.7)).blend(new Color(new RGBA(243, 34, 43))), new Color(new RGBA(158, 95, 98)));
assert.deepStrictEqual(new Color(new RGBA(0, 0, 0, 0.58)).blend(new Color(new RGBA(255, 255, 255, 0.33))), new Color(new RGBA(49, 49, 49, 0.719)));
});
suite('HSLA', () => {
test('HSLA.toRGBA', () => {
assert.deepEqual(HSLA.toRGBA(new HSLA(0, 0, 0, 0)), new RGBA(0, 0, 0, 0));
assert.deepEqual(HSLA.toRGBA(new HSLA(0, 0, 0, 1)), new RGBA(0, 0, 0, 1));
assert.deepEqual(HSLA.toRGBA(new HSLA(0, 0, 1, 1)), new RGBA(255, 255, 255, 1));
assert.deepStrictEqual(HSLA.toRGBA(new HSLA(0, 0, 0, 0)), new RGBA(0, 0, 0, 0));
assert.deepStrictEqual(HSLA.toRGBA(new HSLA(0, 0, 0, 1)), new RGBA(0, 0, 0, 1));
assert.deepStrictEqual(HSLA.toRGBA(new HSLA(0, 0, 1, 1)), new RGBA(255, 255, 255, 1));
assert.deepEqual(HSLA.toRGBA(new HSLA(0, 1, 0.5, 1)), new RGBA(255, 0, 0, 1));
assert.deepEqual(HSLA.toRGBA(new HSLA(120, 1, 0.5, 1)), new RGBA(0, 255, 0, 1));
assert.deepEqual(HSLA.toRGBA(new HSLA(240, 1, 0.5, 1)), new RGBA(0, 0, 255, 1));
assert.deepStrictEqual(HSLA.toRGBA(new HSLA(0, 1, 0.5, 1)), new RGBA(255, 0, 0, 1));
assert.deepStrictEqual(HSLA.toRGBA(new HSLA(120, 1, 0.5, 1)), new RGBA(0, 255, 0, 1));
assert.deepStrictEqual(HSLA.toRGBA(new HSLA(240, 1, 0.5, 1)), new RGBA(0, 0, 255, 1));
assert.deepEqual(HSLA.toRGBA(new HSLA(60, 1, 0.5, 1)), new RGBA(255, 255, 0, 1));
assert.deepEqual(HSLA.toRGBA(new HSLA(180, 1, 0.5, 1)), new RGBA(0, 255, 255, 1));
assert.deepEqual(HSLA.toRGBA(new HSLA(300, 1, 0.5, 1)), new RGBA(255, 0, 255, 1));
assert.deepStrictEqual(HSLA.toRGBA(new HSLA(60, 1, 0.5, 1)), new RGBA(255, 255, 0, 1));
assert.deepStrictEqual(HSLA.toRGBA(new HSLA(180, 1, 0.5, 1)), new RGBA(0, 255, 255, 1));
assert.deepStrictEqual(HSLA.toRGBA(new HSLA(300, 1, 0.5, 1)), new RGBA(255, 0, 255, 1));
assert.deepEqual(HSLA.toRGBA(new HSLA(0, 0, 0.753, 1)), new RGBA(192, 192, 192, 1));
assert.deepStrictEqual(HSLA.toRGBA(new HSLA(0, 0, 0.753, 1)), new RGBA(192, 192, 192, 1));
assert.deepEqual(HSLA.toRGBA(new HSLA(0, 0, 0.502, 1)), new RGBA(128, 128, 128, 1));
assert.deepEqual(HSLA.toRGBA(new HSLA(0, 1, 0.251, 1)), new RGBA(128, 0, 0, 1));
assert.deepEqual(HSLA.toRGBA(new HSLA(60, 1, 0.251, 1)), new RGBA(128, 128, 0, 1));
assert.deepEqual(HSLA.toRGBA(new HSLA(120, 1, 0.251, 1)), new RGBA(0, 128, 0, 1));
assert.deepEqual(HSLA.toRGBA(new HSLA(300, 1, 0.251, 1)), new RGBA(128, 0, 128, 1));
assert.deepEqual(HSLA.toRGBA(new HSLA(180, 1, 0.251, 1)), new RGBA(0, 128, 128, 1));
assert.deepEqual(HSLA.toRGBA(new HSLA(240, 1, 0.251, 1)), new RGBA(0, 0, 128, 1));
assert.deepStrictEqual(HSLA.toRGBA(new HSLA(0, 0, 0.502, 1)), new RGBA(128, 128, 128, 1));
assert.deepStrictEqual(HSLA.toRGBA(new HSLA(0, 1, 0.251, 1)), new RGBA(128, 0, 0, 1));
assert.deepStrictEqual(HSLA.toRGBA(new HSLA(60, 1, 0.251, 1)), new RGBA(128, 128, 0, 1));
assert.deepStrictEqual(HSLA.toRGBA(new HSLA(120, 1, 0.251, 1)), new RGBA(0, 128, 0, 1));
assert.deepStrictEqual(HSLA.toRGBA(new HSLA(300, 1, 0.251, 1)), new RGBA(128, 0, 128, 1));
assert.deepStrictEqual(HSLA.toRGBA(new HSLA(180, 1, 0.251, 1)), new RGBA(0, 128, 128, 1));
assert.deepStrictEqual(HSLA.toRGBA(new HSLA(240, 1, 0.251, 1)), new RGBA(0, 0, 128, 1));
});
test('HSLA.fromRGBA', () => {
assert.deepEqual(HSLA.fromRGBA(new RGBA(0, 0, 0, 0)), new HSLA(0, 0, 0, 0));
assert.deepEqual(HSLA.fromRGBA(new RGBA(0, 0, 0, 1)), new HSLA(0, 0, 0, 1));
assert.deepEqual(HSLA.fromRGBA(new RGBA(255, 255, 255, 1)), new HSLA(0, 0, 1, 1));
assert.deepStrictEqual(HSLA.fromRGBA(new RGBA(0, 0, 0, 0)), new HSLA(0, 0, 0, 0));
assert.deepStrictEqual(HSLA.fromRGBA(new RGBA(0, 0, 0, 1)), new HSLA(0, 0, 0, 1));
assert.deepStrictEqual(HSLA.fromRGBA(new RGBA(255, 255, 255, 1)), new HSLA(0, 0, 1, 1));
assert.deepEqual(HSLA.fromRGBA(new RGBA(255, 0, 0, 1)), new HSLA(0, 1, 0.5, 1));
assert.deepEqual(HSLA.fromRGBA(new RGBA(0, 255, 0, 1)), new HSLA(120, 1, 0.5, 1));
assert.deepEqual(HSLA.fromRGBA(new RGBA(0, 0, 255, 1)), new HSLA(240, 1, 0.5, 1));
assert.deepStrictEqual(HSLA.fromRGBA(new RGBA(255, 0, 0, 1)), new HSLA(0, 1, 0.5, 1));
assert.deepStrictEqual(HSLA.fromRGBA(new RGBA(0, 255, 0, 1)), new HSLA(120, 1, 0.5, 1));
assert.deepStrictEqual(HSLA.fromRGBA(new RGBA(0, 0, 255, 1)), new HSLA(240, 1, 0.5, 1));
assert.deepEqual(HSLA.fromRGBA(new RGBA(255, 255, 0, 1)), new HSLA(60, 1, 0.5, 1));
assert.deepEqual(HSLA.fromRGBA(new RGBA(0, 255, 255, 1)), new HSLA(180, 1, 0.5, 1));
assert.deepEqual(HSLA.fromRGBA(new RGBA(255, 0, 255, 1)), new HSLA(300, 1, 0.5, 1));
assert.deepStrictEqual(HSLA.fromRGBA(new RGBA(255, 255, 0, 1)), new HSLA(60, 1, 0.5, 1));
assert.deepStrictEqual(HSLA.fromRGBA(new RGBA(0, 255, 255, 1)), new HSLA(180, 1, 0.5, 1));
assert.deepStrictEqual(HSLA.fromRGBA(new RGBA(255, 0, 255, 1)), new HSLA(300, 1, 0.5, 1));
assert.deepEqual(HSLA.fromRGBA(new RGBA(192, 192, 192, 1)), new HSLA(0, 0, 0.753, 1));
assert.deepStrictEqual(HSLA.fromRGBA(new RGBA(192, 192, 192, 1)), new HSLA(0, 0, 0.753, 1));
assert.deepEqual(HSLA.fromRGBA(new RGBA(128, 128, 128, 1)), new HSLA(0, 0, 0.502, 1));
assert.deepEqual(HSLA.fromRGBA(new RGBA(128, 0, 0, 1)), new HSLA(0, 1, 0.251, 1));
assert.deepEqual(HSLA.fromRGBA(new RGBA(128, 128, 0, 1)), new HSLA(60, 1, 0.251, 1));
assert.deepEqual(HSLA.fromRGBA(new RGBA(0, 128, 0, 1)), new HSLA(120, 1, 0.251, 1));
assert.deepEqual(HSLA.fromRGBA(new RGBA(128, 0, 128, 1)), new HSLA(300, 1, 0.251, 1));
assert.deepEqual(HSLA.fromRGBA(new RGBA(0, 128, 128, 1)), new HSLA(180, 1, 0.251, 1));
assert.deepEqual(HSLA.fromRGBA(new RGBA(0, 0, 128, 1)), new HSLA(240, 1, 0.251, 1));
assert.deepStrictEqual(HSLA.fromRGBA(new RGBA(128, 128, 128, 1)), new HSLA(0, 0, 0.502, 1));
assert.deepStrictEqual(HSLA.fromRGBA(new RGBA(128, 0, 0, 1)), new HSLA(0, 1, 0.251, 1));
assert.deepStrictEqual(HSLA.fromRGBA(new RGBA(128, 128, 0, 1)), new HSLA(60, 1, 0.251, 1));
assert.deepStrictEqual(HSLA.fromRGBA(new RGBA(0, 128, 0, 1)), new HSLA(120, 1, 0.251, 1));
assert.deepStrictEqual(HSLA.fromRGBA(new RGBA(128, 0, 128, 1)), new HSLA(300, 1, 0.251, 1));
assert.deepStrictEqual(HSLA.fromRGBA(new RGBA(0, 128, 128, 1)), new HSLA(180, 1, 0.251, 1));
assert.deepStrictEqual(HSLA.fromRGBA(new RGBA(0, 0, 128, 1)), new HSLA(240, 1, 0.251, 1));
});
});
suite('HSVA', () => {
test('HSVA.toRGBA', () => {
assert.deepEqual(HSVA.toRGBA(new HSVA(0, 0, 0, 0)), new RGBA(0, 0, 0, 0));
assert.deepEqual(HSVA.toRGBA(new HSVA(0, 0, 0, 1)), new RGBA(0, 0, 0, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(0, 0, 1, 1)), new RGBA(255, 255, 255, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(0, 0, 0, 0)), new RGBA(0, 0, 0, 0));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(0, 0, 0, 1)), new RGBA(0, 0, 0, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(0, 0, 1, 1)), new RGBA(255, 255, 255, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(0, 1, 1, 1)), new RGBA(255, 0, 0, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(120, 1, 1, 1)), new RGBA(0, 255, 0, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(240, 1, 1, 1)), new RGBA(0, 0, 255, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(0, 1, 1, 1)), new RGBA(255, 0, 0, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(120, 1, 1, 1)), new RGBA(0, 255, 0, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(240, 1, 1, 1)), new RGBA(0, 0, 255, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(60, 1, 1, 1)), new RGBA(255, 255, 0, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(180, 1, 1, 1)), new RGBA(0, 255, 255, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(300, 1, 1, 1)), new RGBA(255, 0, 255, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(60, 1, 1, 1)), new RGBA(255, 255, 0, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(180, 1, 1, 1)), new RGBA(0, 255, 255, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(300, 1, 1, 1)), new RGBA(255, 0, 255, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(0, 0, 0.753, 1)), new RGBA(192, 192, 192, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(0, 0, 0.753, 1)), new RGBA(192, 192, 192, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(0, 0, 0.502, 1)), new RGBA(128, 128, 128, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(0, 1, 0.502, 1)), new RGBA(128, 0, 0, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(60, 1, 0.502, 1)), new RGBA(128, 128, 0, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(120, 1, 0.502, 1)), new RGBA(0, 128, 0, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(300, 1, 0.502, 1)), new RGBA(128, 0, 128, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(180, 1, 0.502, 1)), new RGBA(0, 128, 128, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(240, 1, 0.502, 1)), new RGBA(0, 0, 128, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(0, 0, 0.502, 1)), new RGBA(128, 128, 128, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(0, 1, 0.502, 1)), new RGBA(128, 0, 0, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(60, 1, 0.502, 1)), new RGBA(128, 128, 0, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(120, 1, 0.502, 1)), new RGBA(0, 128, 0, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(300, 1, 0.502, 1)), new RGBA(128, 0, 128, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(180, 1, 0.502, 1)), new RGBA(0, 128, 128, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(240, 1, 0.502, 1)), new RGBA(0, 0, 128, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(360, 0, 0, 0)), new RGBA(0, 0, 0, 0));
assert.deepEqual(HSVA.toRGBA(new HSVA(360, 0, 0, 1)), new RGBA(0, 0, 0, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(360, 0, 1, 1)), new RGBA(255, 255, 255, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(360, 1, 1, 1)), new RGBA(255, 0, 0, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(360, 0, 0.753, 1)), new RGBA(192, 192, 192, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(360, 0, 0.502, 1)), new RGBA(128, 128, 128, 1));
assert.deepEqual(HSVA.toRGBA(new HSVA(360, 1, 0.502, 1)), new RGBA(128, 0, 0, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(360, 0, 0, 0)), new RGBA(0, 0, 0, 0));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(360, 0, 0, 1)), new RGBA(0, 0, 0, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(360, 0, 1, 1)), new RGBA(255, 255, 255, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(360, 1, 1, 1)), new RGBA(255, 0, 0, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(360, 0, 0.753, 1)), new RGBA(192, 192, 192, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(360, 0, 0.502, 1)), new RGBA(128, 128, 128, 1));
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(360, 1, 0.502, 1)), new RGBA(128, 0, 0, 1));
});
test('HSVA.fromRGBA', () => {
assert.deepEqual(HSVA.fromRGBA(new RGBA(0, 0, 0, 0)), new HSVA(0, 0, 0, 0));
assert.deepEqual(HSVA.fromRGBA(new RGBA(0, 0, 0, 1)), new HSVA(0, 0, 0, 1));
assert.deepEqual(HSVA.fromRGBA(new RGBA(255, 255, 255, 1)), new HSVA(0, 0, 1, 1));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(0, 0, 0, 0)), new HSVA(0, 0, 0, 0));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(0, 0, 0, 1)), new HSVA(0, 0, 0, 1));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(255, 255, 255, 1)), new HSVA(0, 0, 1, 1));
assert.deepEqual(HSVA.fromRGBA(new RGBA(255, 0, 0, 1)), new HSVA(0, 1, 1, 1));
assert.deepEqual(HSVA.fromRGBA(new RGBA(0, 255, 0, 1)), new HSVA(120, 1, 1, 1));
assert.deepEqual(HSVA.fromRGBA(new RGBA(0, 0, 255, 1)), new HSVA(240, 1, 1, 1));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(255, 0, 0, 1)), new HSVA(0, 1, 1, 1));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(0, 255, 0, 1)), new HSVA(120, 1, 1, 1));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(0, 0, 255, 1)), new HSVA(240, 1, 1, 1));
assert.deepEqual(HSVA.fromRGBA(new RGBA(255, 255, 0, 1)), new HSVA(60, 1, 1, 1));
assert.deepEqual(HSVA.fromRGBA(new RGBA(0, 255, 255, 1)), new HSVA(180, 1, 1, 1));
assert.deepEqual(HSVA.fromRGBA(new RGBA(255, 0, 255, 1)), new HSVA(300, 1, 1, 1));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(255, 255, 0, 1)), new HSVA(60, 1, 1, 1));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(0, 255, 255, 1)), new HSVA(180, 1, 1, 1));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(255, 0, 255, 1)), new HSVA(300, 1, 1, 1));
assert.deepEqual(HSVA.fromRGBA(new RGBA(192, 192, 192, 1)), new HSVA(0, 0, 0.753, 1));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(192, 192, 192, 1)), new HSVA(0, 0, 0.753, 1));
assert.deepEqual(HSVA.fromRGBA(new RGBA(128, 128, 128, 1)), new HSVA(0, 0, 0.502, 1));
assert.deepEqual(HSVA.fromRGBA(new RGBA(128, 0, 0, 1)), new HSVA(0, 1, 0.502, 1));
assert.deepEqual(HSVA.fromRGBA(new RGBA(128, 128, 0, 1)), new HSVA(60, 1, 0.502, 1));
assert.deepEqual(HSVA.fromRGBA(new RGBA(0, 128, 0, 1)), new HSVA(120, 1, 0.502, 1));
assert.deepEqual(HSVA.fromRGBA(new RGBA(128, 0, 128, 1)), new HSVA(300, 1, 0.502, 1));
assert.deepEqual(HSVA.fromRGBA(new RGBA(0, 128, 128, 1)), new HSVA(180, 1, 0.502, 1));
assert.deepEqual(HSVA.fromRGBA(new RGBA(0, 0, 128, 1)), new HSVA(240, 1, 0.502, 1));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(128, 128, 128, 1)), new HSVA(0, 0, 0.502, 1));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(128, 0, 0, 1)), new HSVA(0, 1, 0.502, 1));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(128, 128, 0, 1)), new HSVA(60, 1, 0.502, 1));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(0, 128, 0, 1)), new HSVA(120, 1, 0.502, 1));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(128, 0, 128, 1)), new HSVA(300, 1, 0.502, 1));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(0, 128, 128, 1)), new HSVA(180, 1, 0.502, 1));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(0, 0, 128, 1)), new HSVA(240, 1, 0.502, 1));
});
test('Keep hue value when saturation is 0', () => {
assert.deepEqual(HSVA.toRGBA(new HSVA(10, 0, 0, 0)), HSVA.toRGBA(new HSVA(20, 0, 0, 0)));
assert.deepEqual(new Color(new HSVA(10, 0, 0, 0)).rgba, new Color(new HSVA(20, 0, 0, 0)).rgba);
assert.notDeepEqual(new Color(new HSVA(10, 0, 0, 0)).hsva, new Color(new HSVA(20, 0, 0, 0)).hsva);
assert.deepStrictEqual(HSVA.toRGBA(new HSVA(10, 0, 0, 0)), HSVA.toRGBA(new HSVA(20, 0, 0, 0)));
assert.deepStrictEqual(new Color(new HSVA(10, 0, 0, 0)).rgba, new Color(new HSVA(20, 0, 0, 0)).rgba);
assert.notDeepStrictEqual(new Color(new HSVA(10, 0, 0, 0)).hsva, new Color(new HSVA(20, 0, 0, 0)).hsva);
});
test('bug#36240', () => {
assert.deepEqual(HSVA.fromRGBA(new RGBA(92, 106, 196, 1)), new HSVA(232, 0.531, 0.769, 1));
assert.deepEqual(HSVA.toRGBA(HSVA.fromRGBA(new RGBA(92, 106, 196, 1))), new RGBA(92, 106, 196, 1));
assert.deepStrictEqual(HSVA.fromRGBA(new RGBA(92, 106, 196, 1)), new HSVA(232, 0.531, 0.769, 1));
assert.deepStrictEqual(HSVA.toRGBA(HSVA.fromRGBA(new RGBA(92, 106, 196, 1))), new RGBA(92, 106, 196, 1));
});
});
@@ -204,49 +204,49 @@ suite('Color', () => {
test('parseHex', () => {
// invalid
assert.deepEqual(Color.Format.CSS.parseHex(''), null);
assert.deepEqual(Color.Format.CSS.parseHex('#'), null);
assert.deepEqual(Color.Format.CSS.parseHex('#0102030'), null);
assert.deepStrictEqual(Color.Format.CSS.parseHex(''), null);
assert.deepStrictEqual(Color.Format.CSS.parseHex('#'), null);
assert.deepStrictEqual(Color.Format.CSS.parseHex('#0102030'), null);
// somewhat valid
assert.deepEqual(Color.Format.CSS.parseHex('#FFFFG0')!.rgba, new RGBA(255, 255, 0, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#FFFFg0')!.rgba, new RGBA(255, 255, 0, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#-FFF00')!.rgba, new RGBA(15, 255, 0, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#FFFFG0')!.rgba, new RGBA(255, 255, 0, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#FFFFg0')!.rgba, new RGBA(255, 255, 0, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#-FFF00')!.rgba, new RGBA(15, 255, 0, 1));
// valid
assert.deepEqual(Color.Format.CSS.parseHex('#000000')!.rgba, new RGBA(0, 0, 0, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#FFFFFF')!.rgba, new RGBA(255, 255, 255, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#000000')!.rgba, new RGBA(0, 0, 0, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#FFFFFF')!.rgba, new RGBA(255, 255, 255, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#FF0000')!.rgba, new RGBA(255, 0, 0, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#00FF00')!.rgba, new RGBA(0, 255, 0, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#0000FF')!.rgba, new RGBA(0, 0, 255, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#FF0000')!.rgba, new RGBA(255, 0, 0, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#00FF00')!.rgba, new RGBA(0, 255, 0, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#0000FF')!.rgba, new RGBA(0, 0, 255, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#FFFF00')!.rgba, new RGBA(255, 255, 0, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#00FFFF')!.rgba, new RGBA(0, 255, 255, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#FF00FF')!.rgba, new RGBA(255, 0, 255, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#FFFF00')!.rgba, new RGBA(255, 255, 0, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#00FFFF')!.rgba, new RGBA(0, 255, 255, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#FF00FF')!.rgba, new RGBA(255, 0, 255, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#C0C0C0')!.rgba, new RGBA(192, 192, 192, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#C0C0C0')!.rgba, new RGBA(192, 192, 192, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#808080')!.rgba, new RGBA(128, 128, 128, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#800000')!.rgba, new RGBA(128, 0, 0, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#808000')!.rgba, new RGBA(128, 128, 0, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#008000')!.rgba, new RGBA(0, 128, 0, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#800080')!.rgba, new RGBA(128, 0, 128, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#008080')!.rgba, new RGBA(0, 128, 128, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#000080')!.rgba, new RGBA(0, 0, 128, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#808080')!.rgba, new RGBA(128, 128, 128, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#800000')!.rgba, new RGBA(128, 0, 0, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#808000')!.rgba, new RGBA(128, 128, 0, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#008000')!.rgba, new RGBA(0, 128, 0, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#800080')!.rgba, new RGBA(128, 0, 128, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#008080')!.rgba, new RGBA(0, 128, 128, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#000080')!.rgba, new RGBA(0, 0, 128, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#010203')!.rgba, new RGBA(1, 2, 3, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#040506')!.rgba, new RGBA(4, 5, 6, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#070809')!.rgba, new RGBA(7, 8, 9, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#0a0A0a')!.rgba, new RGBA(10, 10, 10, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#0b0B0b')!.rgba, new RGBA(11, 11, 11, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#0c0C0c')!.rgba, new RGBA(12, 12, 12, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#0d0D0d')!.rgba, new RGBA(13, 13, 13, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#0e0E0e')!.rgba, new RGBA(14, 14, 14, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#0f0F0f')!.rgba, new RGBA(15, 15, 15, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#a0A0a0')!.rgba, new RGBA(160, 160, 160, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#CFA')!.rgba, new RGBA(204, 255, 170, 1));
assert.deepEqual(Color.Format.CSS.parseHex('#CFA8')!.rgba, new RGBA(204, 255, 170, 0.533));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#010203')!.rgba, new RGBA(1, 2, 3, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#040506')!.rgba, new RGBA(4, 5, 6, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#070809')!.rgba, new RGBA(7, 8, 9, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#0a0A0a')!.rgba, new RGBA(10, 10, 10, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#0b0B0b')!.rgba, new RGBA(11, 11, 11, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#0c0C0c')!.rgba, new RGBA(12, 12, 12, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#0d0D0d')!.rgba, new RGBA(13, 13, 13, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#0e0E0e')!.rgba, new RGBA(14, 14, 14, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#0f0F0f')!.rgba, new RGBA(15, 15, 15, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#a0A0a0')!.rgba, new RGBA(160, 160, 160, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#CFA')!.rgba, new RGBA(204, 255, 170, 1));
assert.deepStrictEqual(Color.Format.CSS.parseHex('#CFA8')!.rgba, new RGBA(204, 255, 170, 0.533));
});
});
});

30
lib/vscode/src/vs/base/test/common/console.test.ts
View File

@@ -13,36 +13,36 @@ suite('Console', () => {
let stack = 'at vscode.commands.registerCommand (/Users/someone/Desktop/test-ts/out/src/extension.js:18:17)';
let frame = getFirstFrame(stack)!;
assert.equal(frame.uri.fsPath, normalize('/Users/someone/Desktop/test-ts/out/src/extension.js'));
assert.equal(frame.line, 18);
assert.equal(frame.column, 17);
assert.strictEqual(frame.uri.fsPath, normalize('/Users/someone/Desktop/test-ts/out/src/extension.js'));
assert.strictEqual(frame.line, 18);
assert.strictEqual(frame.column, 17);
stack = 'at /Users/someone/Desktop/test-ts/out/src/extension.js:18:17';
frame = getFirstFrame(stack)!;
assert.equal(frame.uri.fsPath, normalize('/Users/someone/Desktop/test-ts/out/src/extension.js'));
assert.equal(frame.line, 18);
assert.equal(frame.column, 17);
assert.strictEqual(frame.uri.fsPath, normalize('/Users/someone/Desktop/test-ts/out/src/extension.js'));
assert.strictEqual(frame.line, 18);
assert.strictEqual(frame.column, 17);
stack = 'at c:\\Users\\someone\\Desktop\\end-js\\extension.js:18:17';
frame = getFirstFrame(stack)!;
assert.equal(frame.uri.fsPath, 'c:\\Users\\someone\\Desktop\\end-js\\extension.js');
assert.equal(frame.line, 18);
assert.equal(frame.column, 17);
assert.strictEqual(frame.uri.fsPath, 'c:\\Users\\someone\\Desktop\\end-js\\extension.js');
assert.strictEqual(frame.line, 18);
assert.strictEqual(frame.column, 17);
stack = 'at e.$executeContributedCommand(c:\\Users\\someone\\Desktop\\end-js\\extension.js:18:17)';
frame = getFirstFrame(stack)!;
assert.equal(frame.uri.fsPath, 'c:\\Users\\someone\\Desktop\\end-js\\extension.js');
assert.equal(frame.line, 18);
assert.equal(frame.column, 17);
assert.strictEqual(frame.uri.fsPath, 'c:\\Users\\someone\\Desktop\\end-js\\extension.js');
assert.strictEqual(frame.line, 18);
assert.strictEqual(frame.column, 17);
stack = 'at /Users/someone/Desktop/test-ts/out/src/extension.js:18:17\nat /Users/someone/Desktop/test-ts/out/src/other.js:28:27\nat /Users/someone/Desktop/test-ts/out/src/more.js:38:37';
frame = getFirstFrame(stack)!;
assert.equal(frame.uri.fsPath, normalize('/Users/someone/Desktop/test-ts/out/src/extension.js'));
assert.equal(frame.line, 18);
assert.equal(frame.column, 17);
assert.strictEqual(frame.uri.fsPath, normalize('/Users/someone/Desktop/test-ts/out/src/extension.js'));
assert.strictEqual(frame.line, 18);
assert.strictEqual(frame.column, 17);
});
});

116
lib/vscode/src/vs/base/test/common/decorators.test.ts
View File

@@ -22,35 +22,35 @@ suite('Decorators', () => {
}
const foo = new Foo(42);
assert.equal(foo.count, 0);
assert.equal(foo.answer(), 42);
assert.equal(foo.count, 1);
assert.equal(foo.answer(), 42);
assert.equal(foo.count, 1);
assert.strictEqual(foo.count, 0);
assert.strictEqual(foo.answer(), 42);
assert.strictEqual(foo.count, 1);
assert.strictEqual(foo.answer(), 42);
assert.strictEqual(foo.count, 1);
const foo2 = new Foo(1337);
assert.equal(foo2.count, 0);
assert.equal(foo2.answer(), 1337);
assert.equal(foo2.count, 1);
assert.equal(foo2.answer(), 1337);
assert.equal(foo2.count, 1);
assert.strictEqual(foo2.count, 0);
assert.strictEqual(foo2.answer(), 1337);
assert.strictEqual(foo2.count, 1);
assert.strictEqual(foo2.answer(), 1337);
assert.strictEqual(foo2.count, 1);
assert.equal(foo.answer(), 42);
assert.equal(foo.count, 1);
assert.strictEqual(foo.answer(), 42);
assert.strictEqual(foo.count, 1);
const foo3 = new Foo(null);
assert.equal(foo3.count, 0);
assert.equal(foo3.answer(), null);
assert.equal(foo3.count, 1);
assert.equal(foo3.answer(), null);
assert.equal(foo3.count, 1);
assert.strictEqual(foo3.count, 0);
assert.strictEqual(foo3.answer(), null);
assert.strictEqual(foo3.count, 1);
assert.strictEqual(foo3.answer(), null);
assert.strictEqual(foo3.count, 1);
const foo4 = new Foo(undefined);
assert.equal(foo4.count, 0);
assert.equal(foo4.answer(), undefined);
assert.equal(foo4.count, 1);
assert.equal(foo4.answer(), undefined);
assert.equal(foo4.count, 1);
assert.strictEqual(foo4.count, 0);
assert.strictEqual(foo4.answer(), undefined);
assert.strictEqual(foo4.count, 1);
assert.strictEqual(foo4.answer(), undefined);
assert.strictEqual(foo4.count, 1);
});
test('memoize should memoize getters', () => {
@@ -67,35 +67,35 @@ suite('Decorators', () => {
}
const foo = new Foo(42);
assert.equal(foo.count, 0);
assert.equal(foo.answer, 42);
assert.equal(foo.count, 1);
assert.equal(foo.answer, 42);
assert.equal(foo.count, 1);
assert.strictEqual(foo.count, 0);
assert.strictEqual(foo.answer, 42);
assert.strictEqual(foo.count, 1);
assert.strictEqual(foo.answer, 42);
assert.strictEqual(foo.count, 1);
const foo2 = new Foo(1337);
assert.equal(foo2.count, 0);
assert.equal(foo2.answer, 1337);
assert.equal(foo2.count, 1);
assert.equal(foo2.answer, 1337);
assert.equal(foo2.count, 1);
assert.strictEqual(foo2.count, 0);
assert.strictEqual(foo2.answer, 1337);
assert.strictEqual(foo2.count, 1);
assert.strictEqual(foo2.answer, 1337);
assert.strictEqual(foo2.count, 1);
assert.equal(foo.answer, 42);
assert.equal(foo.count, 1);
assert.strictEqual(foo.answer, 42);
assert.strictEqual(foo.count, 1);
const foo3 = new Foo(null);
assert.equal(foo3.count, 0);
assert.equal(foo3.answer, null);
assert.equal(foo3.count, 1);
assert.equal(foo3.answer, null);
assert.equal(foo3.count, 1);
assert.strictEqual(foo3.count, 0);
assert.strictEqual(foo3.answer, null);
assert.strictEqual(foo3.count, 1);
assert.strictEqual(foo3.answer, null);
assert.strictEqual(foo3.count, 1);
const foo4 = new Foo(undefined);
assert.equal(foo4.count, 0);
assert.equal(foo4.answer, undefined);
assert.equal(foo4.count, 1);
assert.equal(foo4.answer, undefined);
assert.equal(foo4.count, 1);
assert.strictEqual(foo4.count, 0);
assert.strictEqual(foo4.answer, undefined);
assert.strictEqual(foo4.count, 1);
assert.strictEqual(foo4.answer, undefined);
assert.strictEqual(foo4.count, 1);
});
test('memoized property should not be enumerable', () => {
@@ -107,7 +107,7 @@ suite('Decorators', () => {
}
const foo = new Foo();
assert.equal(foo.answer, 42);
assert.strictEqual(foo.answer, 42);
assert(!Object.keys(foo).some(k => /\$memoize\$/.test(k)));
});
@@ -121,13 +121,13 @@ suite('Decorators', () => {
}
const foo = new Foo();
assert.equal(foo.answer, 42);
assert.strictEqual(foo.answer, 42);
try {
(foo as any)['$memoize$answer'] = 1337;
assert(false);
} catch (e) {
assert.equal(foo.answer, 42);
assert.strictEqual(foo.answer, 42);
}
});
@@ -142,15 +142,15 @@ suite('Decorators', () => {
}
const foo = new Foo();
assert.equal(foo.answer, 1);
assert.equal(foo.answer, 1);
assert.strictEqual(foo.answer, 1);
assert.strictEqual(foo.answer, 1);
memoizer.clear();
assert.equal(foo.answer, 2);
assert.equal(foo.answer, 2);
assert.strictEqual(foo.answer, 2);
assert.strictEqual(foo.answer, 2);
memoizer.clear();
assert.equal(foo.answer, 3);
assert.equal(foo.answer, 3);
assert.equal(foo.answer, 3);
assert.strictEqual(foo.answer, 3);
assert.strictEqual(foo.answer, 3);
assert.strictEqual(foo.answer, 3);
});
test('throttle', () => {
@@ -179,10 +179,10 @@ suite('Decorators', () => {
t.report(1);
t.report(2);
t.report(3);
assert.deepEqual(spy.args, [[1]]);
assert.deepStrictEqual(spy.args, [[1]]);
clock.tick(200);
assert.deepEqual(spy.args, [[1], [5]]);
assert.deepStrictEqual(spy.args, [[1], [5]]);
spy.reset();
t.report(4);
@@ -190,9 +190,9 @@ suite('Decorators', () => {
clock.tick(50);
t.report(6);
assert.deepEqual(spy.args, [[4]]);
assert.deepStrictEqual(spy.args, [[4]]);
clock.tick(60);
assert.deepEqual(spy.args, [[4], [11]]);
assert.deepStrictEqual(spy.args, [[4], [11]]);
} finally {
clock.restore();
}

6
lib/vscode/src/vs/base/test/common/event.test.ts
View File

@@ -644,7 +644,7 @@ suite('Event utils', () => {
emitter.fire(1);
emitter.fire(2);
emitter.fire(3);
assert.deepEqual(result, []);
assert.deepStrictEqual(result, [] as number[]);
const listener = bufferedEvent(num => result.push(num));
assert.deepStrictEqual(result, [1, 2, 3]);
@@ -666,7 +666,7 @@ suite('Event utils', () => {
emitter.fire(1);
emitter.fire(2);
emitter.fire(3);
assert.deepEqual(result, []);
assert.deepStrictEqual(result, [] as number[]);
const listener = bufferedEvent(num => result.push(num));
assert.deepStrictEqual(result, []);
@@ -688,7 +688,7 @@ suite('Event utils', () => {
emitter.fire(1);
emitter.fire(2);
emitter.fire(3);
assert.deepEqual(result, []);
assert.deepStrictEqual(result, [] as number[]);
bufferedEvent(num => result.push(num));
assert.deepStrictEqual(result, [-2, -1, 0, 1, 2, 3]);

14
lib/vscode/src/vs/base/test/common/filters.test.ts
View File

@@ -28,22 +28,22 @@ suite('Filters', () => {
counters = [0, 0];
filter = or(newFilter(0, false), newFilter(1, false));
filterNotOk(filter, 'anything', 'anything');
assert.deepEqual(counters, [1, 1]);
assert.deepStrictEqual(counters, [1, 1]);
counters = [0, 0];
filter = or(newFilter(0, true), newFilter(1, false));
filterOk(filter, 'anything', 'anything');
assert.deepEqual(counters, [1, 0]);
assert.deepStrictEqual(counters, [1, 0]);
counters = [0, 0];
filter = or(newFilter(0, true), newFilter(1, true));
filterOk(filter, 'anything', 'anything');
assert.deepEqual(counters, [1, 0]);
assert.deepStrictEqual(counters, [1, 0]);
counters = [0, 0];
filter = or(newFilter(0, false), newFilter(1, true));
filterOk(filter, 'anything', 'anything');
assert.deepEqual(counters, [1, 1]);
assert.deepStrictEqual(counters, [1, 1]);
});
test('PrefixFilter - case sensitive', function () {
@@ -201,7 +201,7 @@ suite('Filters', () => {
filterOk(matchesWords, 'öäk', 'Öhm: Älles Klar', [{ start: 0, end: 1 }, { start: 5, end: 6 }, { start: 11, end: 12 }]);
// assert.ok(matchesWords('gipu', 'Category: Git: Pull', true) === null);
// assert.deepEqual(matchesWords('pu', 'Category: Git: Pull', true), [{ start: 15, end: 17 }]);
// assert.deepStrictEqual(matchesWords('pu', 'Category: Git: Pull', true), [{ start: 15, end: 17 }]);
filterOk(matchesWords, 'bar', 'foo-bar');
filterOk(matchesWords, 'bar test', 'foo-bar test');
@@ -476,9 +476,9 @@ suite('Filters', () => {
// assertTopScore(fuzzyScore, 'Editor.r', 0, 'diffEditor.renderSideBySide', 'editor.overviewRulerlanes', 'editor.renderControlCharacter', 'editor.renderWhitespace');
assertTopScore(fuzzyScore, '-mo', 1, '-ms-ime-mode', '-moz-columns');
// // dupe, issue #14861
// dupe, issue #14861
assertTopScore(fuzzyScore, 'convertModelPosition', 0, 'convertModelPositionToViewPosition', 'convertViewToModelPosition');
// // dupe, issue #14942
// dupe, issue #14942
assertTopScore(fuzzyScore, 'is', 0, 'isValidViewletId', 'import statement');
assertTopScore(fuzzyScore, 'title', 1, 'files.trimTrailingWhitespace', 'window.title');

16
lib/vscode/src/vs/base/test/common/glob.test.ts
View File

@@ -661,15 +661,15 @@ suite('Glob', () => {
});
test('split glob aware', function () {
assert.deepEqual(glob.splitGlobAware('foo,bar', ','), ['foo', 'bar']);
assert.deepEqual(glob.splitGlobAware('foo', ','), ['foo']);
assert.deepEqual(glob.splitGlobAware('{foo,bar}', ','), ['{foo,bar}']);
assert.deepEqual(glob.splitGlobAware('foo,bar,{foo,bar}', ','), ['foo', 'bar', '{foo,bar}']);
assert.deepEqual(glob.splitGlobAware('{foo,bar},foo,bar,{foo,bar}', ','), ['{foo,bar}', 'foo', 'bar', '{foo,bar}']);
assert.deepStrictEqual(glob.splitGlobAware('foo,bar', ','), ['foo', 'bar']);
assert.deepStrictEqual(glob.splitGlobAware('foo', ','), ['foo']);
assert.deepStrictEqual(glob.splitGlobAware('{foo,bar}', ','), ['{foo,bar}']);
assert.deepStrictEqual(glob.splitGlobAware('foo,bar,{foo,bar}', ','), ['foo', 'bar', '{foo,bar}']);
assert.deepStrictEqual(glob.splitGlobAware('{foo,bar},foo,bar,{foo,bar}', ','), ['{foo,bar}', 'foo', 'bar', '{foo,bar}']);
assert.deepEqual(glob.splitGlobAware('[foo,bar]', ','), ['[foo,bar]']);
assert.deepEqual(glob.splitGlobAware('foo,bar,[foo,bar]', ','), ['foo', 'bar', '[foo,bar]']);
assert.deepEqual(glob.splitGlobAware('[foo,bar],foo,bar,[foo,bar]', ','), ['[foo,bar]', 'foo', 'bar', '[foo,bar]']);
assert.deepStrictEqual(glob.splitGlobAware('[foo,bar]', ','), ['[foo,bar]']);
assert.deepStrictEqual(glob.splitGlobAware('foo,bar,[foo,bar]', ','), ['foo', 'bar', '[foo,bar]']);
assert.deepStrictEqual(glob.splitGlobAware('[foo,bar],foo,bar,[foo,bar]', ','), ['[foo,bar]', 'foo', 'bar', '[foo,bar]']);
});
test('expression with disabled glob', function () {

58
lib/vscode/src/vs/base/test/common/history.test.ts
View File

@@ -10,28 +10,28 @@ suite('History Navigator', () => {
test('create reduces the input to limit', () => {
const testObject = new HistoryNavigator(['1', '2', '3', '4'], 2);
assert.deepEqual(['3', '4'], toArray(testObject));
assert.deepStrictEqual(['3', '4'], toArray(testObject));
});
test('create sets the position to last', () => {
const testObject = new HistoryNavigator(['1', '2', '3', '4'], 100);
assert.equal(testObject.current(), null);
assert.equal(testObject.next(), null);
assert.equal(testObject.previous(), '4');
assert.strictEqual(testObject.current(), null);
assert.strictEqual(testObject.next(), null);
assert.strictEqual(testObject.previous(), '4');
});
test('last returns last element', () => {
const testObject = new HistoryNavigator(['1', '2', '3', '4'], 100);
assert.equal(testObject.first(), '1');
assert.equal(testObject.last(), '4');
assert.strictEqual(testObject.first(), '1');
assert.strictEqual(testObject.last(), '4');
});
test('first returns first element', () => {
const testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
assert.equal('2', testObject.first());
assert.strictEqual('2', testObject.first());
});
test('next returns next element', () => {
@@ -39,18 +39,18 @@ suite('History Navigator', () => {
testObject.first();
assert.equal(testObject.next(), '3');
assert.equal(testObject.next(), '4');
assert.equal(testObject.next(), null);
assert.strictEqual(testObject.next(), '3');
assert.strictEqual(testObject.next(), '4');
assert.strictEqual(testObject.next(), null);
});
test('previous returns previous element', () => {
const testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
assert.equal(testObject.previous(), '4');
assert.equal(testObject.previous(), '3');
assert.equal(testObject.previous(), '2');
assert.equal(testObject.previous(), null);
assert.strictEqual(testObject.previous(), '4');
assert.strictEqual(testObject.previous(), '3');
assert.strictEqual(testObject.previous(), '2');
assert.strictEqual(testObject.previous(), null);
});
test('next on last element returs null and remains on last', () => {
@@ -59,8 +59,8 @@ suite('History Navigator', () => {
testObject.first();
testObject.last();
assert.equal(testObject.current(), '4');
assert.equal(testObject.next(), null);
assert.strictEqual(testObject.current(), '4');
assert.strictEqual(testObject.next(), null);
});
test('previous on first element returs null and remains on first', () => {
@@ -68,8 +68,8 @@ suite('History Navigator', () => {
testObject.first();
assert.equal(testObject.current(), '2');
assert.equal(testObject.previous(), null);
assert.strictEqual(testObject.current(), '2');
assert.strictEqual(testObject.previous(), null);
});
test('add reduces the input to limit', () => {
@@ -77,7 +77,7 @@ suite('History Navigator', () => {
testObject.add('5');
assert.deepEqual(toArray(testObject), ['4', '5']);
assert.deepStrictEqual(toArray(testObject), ['4', '5']);
});
test('adding existing element changes the position', () => {
@@ -85,7 +85,7 @@ suite('History Navigator', () => {
testObject.add('2');
assert.deepEqual(toArray(testObject), ['1', '3', '4', '2']);
assert.deepStrictEqual(toArray(testObject), ['1', '3', '4', '2']);
});
test('add resets the navigator to last', () => {
@@ -94,8 +94,8 @@ suite('History Navigator', () => {
testObject.first();
testObject.add('5');
assert.equal(testObject.previous(), '5');
assert.equal(testObject.next(), null);
assert.strictEqual(testObject.previous(), '5');
assert.strictEqual(testObject.next(), null);
});
test('adding an existing item changes the order', () => {
@@ -103,7 +103,7 @@ suite('History Navigator', () => {
testObject.add('1');
assert.deepEqual(['2', '3', '1'], toArray(testObject));
assert.deepStrictEqual(['2', '3', '1'], toArray(testObject));
});
test('previous returns null if the current position is the first one', () => {
@@ -111,7 +111,7 @@ suite('History Navigator', () => {
testObject.first();
assert.deepEqual(testObject.previous(), null);
assert.deepStrictEqual(testObject.previous(), null);
});
test('previous returns object if the current position is not the first one', () => {
@@ -120,7 +120,7 @@ suite('History Navigator', () => {
testObject.first();
testObject.next();
assert.deepEqual(testObject.previous(), '1');
assert.deepStrictEqual(testObject.previous(), '1');
});
test('next returns null if the current position is the last one', () => {
@@ -128,7 +128,7 @@ suite('History Navigator', () => {
testObject.last();
assert.deepEqual(testObject.next(), null);
assert.deepStrictEqual(testObject.next(), null);
});
test('next returns object if the current position is not the last one', () => {
@@ -137,14 +137,14 @@ suite('History Navigator', () => {
testObject.last();
testObject.previous();
assert.deepEqual(testObject.next(), '3');
assert.deepStrictEqual(testObject.next(), '3');
});
test('clear', () => {
const testObject = new HistoryNavigator(['a', 'b', 'c']);
assert.equal(testObject.previous(), 'c');
assert.strictEqual(testObject.previous(), 'c');
testObject.clear();
assert.equal(testObject.current(), undefined);
assert.strictEqual(testObject.current(), null);
});
function toArray(historyNavigator: HistoryNavigator<string>): Array<string | null> {

2
lib/vscode/src/vs/base/test/common/iconLabels.test.ts
View File

@@ -16,7 +16,7 @@ function filterOk(filter: IIconFilter, word: string, target: IParsedLabelWithIco
let r = filter(word, target);
assert(r);
if (highlights) {
assert.deepEqual(r, highlights);
assert.deepStrictEqual(r, highlights);
}
}

8
lib/vscode/src/vs/base/test/common/iterator.test.ts
View File

@@ -19,10 +19,10 @@ suite('Iterable', function () {
test('first', function () {
assert.equal(Iterable.first([]), undefined);
assert.equal(Iterable.first([1]), 1);
assert.equal(Iterable.first(customIterable), 'one');
assert.equal(Iterable.first(customIterable), 'one'); // fresh
assert.strictEqual(Iterable.first([]), undefined);
assert.strictEqual(Iterable.first([1]), 1);
assert.strictEqual(Iterable.first(customIterable), 'one');
assert.strictEqual(Iterable.first(customIterable), 'one'); // fresh
});
test('equals', () => {

18
lib/vscode/src/vs/base/test/common/json.test.ts
View File

@@ -12,15 +12,15 @@ function assertKinds(text: string, ...kinds: SyntaxKind[]): void {
let scanner = createScanner(text);
let kind: SyntaxKind;
while ((kind = scanner.scan()) !== SyntaxKind.EOF) {
assert.equal(kind, kinds.shift());
assert.strictEqual(kind, kinds.shift());
}
assert.equal(kinds.length, 0);
assert.strictEqual(kinds.length, 0);
}
function assertScanError(text: string, expectedKind: SyntaxKind, scanError: ScanError): void {
let scanner = createScanner(text);
scanner.scan();
assert.equal(scanner.getToken(), expectedKind);
assert.equal(scanner.getTokenError(), scanError);
assert.strictEqual(scanner.getToken(), expectedKind);
assert.strictEqual(scanner.getTokenError(), scanError);
}
function assertValidParse(input: string, expected: any, options?: ParseOptions): void {
@@ -30,7 +30,7 @@ function assertValidParse(input: string, expected: any, options?: ParseOptions):
if (errors.length !== 0) {
assert(false, getParseErrorMessage(errors[0].error));
}
assert.deepEqual(actual, expected);
assert.deepStrictEqual(actual, expected);
}
function assertInvalidParse(input: string, expected: any, options?: ParseOptions): void {
@@ -38,18 +38,18 @@ function assertInvalidParse(input: string, expected: any, options?: ParseOptions
let actual = parse(input, errors, options);
assert(errors.length > 0);
assert.deepEqual(actual, expected);
assert.deepStrictEqual(actual, expected);
}
function assertTree(input: string, expected: any, expectedErrors: number[] = [], options?: ParseOptions): void {
let errors: ParseError[] = [];
let actual = parseTree(input, errors, options);
assert.deepEqual(errors.map(e => e.error, expected), expectedErrors);
assert.deepStrictEqual(errors.map(e => e.error, expected), expectedErrors);
let checkParent = (node: Node) => {
if (node.children) {
for (let child of node.children) {
assert.equal(node, child.parent);
assert.strictEqual(node, child.parent);
delete (<any>child).parent; // delete to avoid recursion in deep equal
checkParent(child);
}
@@ -57,7 +57,7 @@ function assertTree(input: string, expected: any, expectedErrors: number[] = [],
};
checkParent(actual);
assert.deepEqual(actual, expected);
assert.deepStrictEqual(actual, expected);
}
suite('JSON', () => {

2
lib/vscode/src/vs/base/test/common/jsonEdit.test.ts
View File

@@ -19,7 +19,7 @@ suite('JSON - edits', () => {
lastEditOffset = edit.offset;
content = content.substring(0, edit.offset) + edit.content + content.substring(edit.offset + edit.length);
}
assert.equal(content, expected);
assert.strictEqual(content, expected);
}
let formatterOptions: FormattingOptions = {

4
lib/vscode/src/vs/base/test/common/jsonFormatter.test.ts
View File

@@ -28,7 +28,7 @@ suite('JSON - formatter', () => {
content = content.substring(0, edit.offset) + edit.content + content.substring(edit.offset + edit.length);
}
assert.equal(content, expected);
assert.strictEqual(content, expected);
}
test('object - single property', () => {
@@ -438,4 +438,4 @@ suite('JSON - formatter', () => {
format(content, expected);
});
});
});

4
lib/vscode/src/vs/base/test/common/labels.test.ts
View File

@@ -118,13 +118,13 @@ suite('Labels', () => {
assert.strictEqual(labels.template('${separator}Foo${separator}Bar', { value: 'something', separator: { label: ' - ' } }), 'Foo - Bar');
assert.strictEqual(labels.template('${value} Foo${separator}Bar', { value: 'something', separator: { label: ' - ' } }), 'something Foo - Bar');
// // real world example (macOS)
// real world example (macOS)
let t = '${activeEditorShort}${separator}${rootName}';
assert.strictEqual(labels.template(t, { activeEditorShort: '', rootName: '', separator: { label: ' - ' } }), '');
assert.strictEqual(labels.template(t, { activeEditorShort: '', rootName: 'root', separator: { label: ' - ' } }), 'root');
assert.strictEqual(labels.template(t, { activeEditorShort: 'markdown.txt', rootName: 'root', separator: { label: ' - ' } }), 'markdown.txt - root');
// // real world example (other)
// real world example (other)
t = '${dirty}${activeEditorShort}${separator}${rootName}${separator}${appName}';
assert.strictEqual(labels.template(t, { dirty: '', activeEditorShort: '', rootName: '', appName: '', separator: { label: ' - ' } }), '');
assert.strictEqual(labels.template(t, { dirty: '', activeEditorShort: '', rootName: '', appName: 'Visual Studio Code', separator: { label: ' - ' } }), 'Visual Studio Code');

4
lib/vscode/src/vs/base/test/common/lazy.test.ts
View File

@@ -37,14 +37,14 @@ suite('Lazy', () => {
assert.strictEqual(outerLazy.hasValue(), false);
assert.strictEqual(innerLazy.hasValue(), false);
assert.deepEqual(innerLazy.getValue(), [1, 11]);
assert.deepStrictEqual(innerLazy.getValue(), [1, 11]);
assert.strictEqual(outerLazy.hasValue(), true);
assert.strictEqual(innerLazy.hasValue(), true);
assert.strictEqual(outerLazy.getValue(), 1);
// make sure we did not evaluate again
assert.strictEqual(outerLazy.getValue(), 1);
assert.deepEqual(innerLazy.getValue(), [1, 11]);
assert.deepStrictEqual(innerLazy.getValue(), [1, 11]);
});
test('map should handle error values', () => {

22
lib/vscode/src/vs/base/test/common/marshalling.test.ts
View File

@@ -13,10 +13,10 @@ suite('Marshalling', () => {
let raw = stringify(value);
let clone = <RegExp>parse(raw);
assert.equal(value.source, clone.source);
assert.equal(value.global, clone.global);
assert.equal(value.ignoreCase, clone.ignoreCase);
assert.equal(value.multiline, clone.multiline);
assert.strictEqual(value.source, clone.source);
assert.strictEqual(value.global, clone.global);
assert.strictEqual(value.ignoreCase, clone.ignoreCase);
assert.strictEqual(value.multiline, clone.multiline);
});
test('URI', () => {
@@ -24,15 +24,15 @@ suite('Marshalling', () => {
const raw = stringify(value);
const clone = <URI>parse(raw);
assert.equal(value.scheme, clone.scheme);
assert.equal(value.authority, clone.authority);
assert.equal(value.path, clone.path);
assert.equal(value.query, clone.query);
assert.equal(value.fragment, clone.fragment);
assert.strictEqual(value.scheme, clone.scheme);
assert.strictEqual(value.authority, clone.authority);
assert.strictEqual(value.path, clone.path);
assert.strictEqual(value.query, clone.query);
assert.strictEqual(value.fragment, clone.fragment);
});
test('Bug 16793:# in folder name => mirror models get out of sync', () => {
const uri1 = URI.file('C:\\C#\\file.txt');
assert.equal(parse(stringify(uri1)).toString(), uri1.toString());
assert.strictEqual(parse(stringify(uri1)).toString(), uri1.toString());
});
});
});

88
lib/vscode/src/vs/base/test/common/normalization.test.ts
View File

@@ -9,57 +9,57 @@ import { removeAccents } from 'vs/base/common/normalization';
suite('Normalization', () => {
test('removeAccents', function () {
assert.equal(removeAccents('joào'), 'joao');
assert.equal(removeAccents('joáo'), 'joao');
assert.equal(removeAccents('joâo'), 'joao');
assert.equal(removeAccents('joäo'), 'joao');
// assert.equal(strings.removeAccents('joæo'), 'joao'); // not an accent
assert.equal(removeAccents('joão'), 'joao');
assert.equal(removeAccents('joåo'), 'joao');
assert.equal(removeAccents('joåo'), 'joao');
assert.equal(removeAccents('joāo'), 'joao');
assert.strictEqual(removeAccents('joào'), 'joao');
assert.strictEqual(removeAccents('joáo'), 'joao');
assert.strictEqual(removeAccents('joâo'), 'joao');
assert.strictEqual(removeAccents('joäo'), 'joao');
// assert.strictEqual(strings.removeAccents('joæo'), 'joao'); // not an accent
assert.strictEqual(removeAccents('joão'), 'joao');
assert.strictEqual(removeAccents('joåo'), 'joao');
assert.strictEqual(removeAccents('joåo'), 'joao');
assert.strictEqual(removeAccents('joāo'), 'joao');
assert.equal(removeAccents('fôo'), 'foo');
assert.equal(removeAccents('föo'), 'foo');
assert.equal(removeAccents('fòo'), 'foo');
assert.equal(removeAccents('fóo'), 'foo');
// assert.equal(strings.removeAccents('fœo'), 'foo');
// assert.equal(strings.removeAccents('føo'), 'foo');
assert.equal(removeAccents('fōo'), 'foo');
assert.equal(removeAccents('fõo'), 'foo');
assert.strictEqual(removeAccents('fôo'), 'foo');
assert.strictEqual(removeAccents('föo'), 'foo');
assert.strictEqual(removeAccents('fòo'), 'foo');
assert.strictEqual(removeAccents('fóo'), 'foo');
// assert.strictEqual(strings.removeAccents('fœo'), 'foo');
// assert.strictEqual(strings.removeAccents('føo'), 'foo');
assert.strictEqual(removeAccents('fōo'), 'foo');
assert.strictEqual(removeAccents('fõo'), 'foo');
assert.equal(removeAccents('andrè'), 'andre');
assert.equal(removeAccents('andré'), 'andre');
assert.equal(removeAccents('andrê'), 'andre');
assert.equal(removeAccents('andrë'), 'andre');
assert.equal(removeAccents('andrē'), 'andre');
assert.equal(removeAccents('andrė'), 'andre');
assert.equal(removeAccents('andrę'), 'andre');
assert.strictEqual(removeAccents('andrè'), 'andre');
assert.strictEqual(removeAccents('andré'), 'andre');
assert.strictEqual(removeAccents('andrê'), 'andre');
assert.strictEqual(removeAccents('andrë'), 'andre');
assert.strictEqual(removeAccents('andrē'), 'andre');
assert.strictEqual(removeAccents('andrė'), 'andre');
assert.strictEqual(removeAccents('andrę'), 'andre');
assert.equal(removeAccents('hvîc'), 'hvic');
assert.equal(removeAccents('hvïc'), 'hvic');
assert.equal(removeAccents('hvíc'), 'hvic');
assert.equal(removeAccents('hvīc'), 'hvic');
assert.equal(removeAccents('hvįc'), 'hvic');
assert.equal(removeAccents('hvìc'), 'hvic');
assert.strictEqual(removeAccents('hvîc'), 'hvic');
assert.strictEqual(removeAccents('hvïc'), 'hvic');
assert.strictEqual(removeAccents('hvíc'), 'hvic');
assert.strictEqual(removeAccents('hvīc'), 'hvic');
assert.strictEqual(removeAccents('hvįc'), 'hvic');
assert.strictEqual(removeAccents('hvìc'), 'hvic');
assert.equal(removeAccents('ûdo'), 'udo');
assert.equal(removeAccents('üdo'), 'udo');
assert.equal(removeAccents('ùdo'), 'udo');
assert.equal(removeAccents('údo'), 'udo');
assert.equal(removeAccents('ūdo'), 'udo');
assert.strictEqual(removeAccents('ûdo'), 'udo');
assert.strictEqual(removeAccents('üdo'), 'udo');
assert.strictEqual(removeAccents('ùdo'), 'udo');
assert.strictEqual(removeAccents('údo'), 'udo');
assert.strictEqual(removeAccents('ūdo'), 'udo');
assert.equal(removeAccents('heÿ'), 'hey');
assert.strictEqual(removeAccents('heÿ'), 'hey');
// assert.equal(strings.removeAccents('gruß'), 'grus');
assert.equal(removeAccents('gruś'), 'grus');
assert.equal(removeAccents('gruš'), 'grus');
// assert.strictEqual(strings.removeAccents('gruß'), 'grus');
assert.strictEqual(removeAccents('gruś'), 'grus');
assert.strictEqual(removeAccents('gruš'), 'grus');
assert.equal(removeAccents('çool'), 'cool');
assert.equal(removeAccents('ćool'), 'cool');
assert.equal(removeAccents('čool'), 'cool');
assert.strictEqual(removeAccents('çool'), 'cool');
assert.strictEqual(removeAccents('ćool'), 'cool');
assert.strictEqual(removeAccents('čool'), 'cool');
assert.equal(removeAccents('ñice'), 'nice');
assert.equal(removeAccents('ńice'), 'nice');
assert.strictEqual(removeAccents('ñice'), 'nice');
assert.strictEqual(removeAccents('ńice'), 'nice');
});
});

50
lib/vscode/src/vs/base/test/common/objects.test.ts
View File

@@ -60,10 +60,10 @@ suite('Objects', () => {
assert(foo.bar);
assert(Array.isArray(foo.bar));
assert.equal(foo.bar.length, 3);
assert.equal(foo.bar[0], 1);
assert.equal(foo.bar[1], 2);
assert.equal(foo.bar[2], 3);
assert.strictEqual(foo.bar.length, 3);
assert.strictEqual(foo.bar[0], 1);
assert.strictEqual(foo.bar[1], 2);
assert.strictEqual(foo.bar[2], 3);
});
test('mixin - no overwrite', function () {
@@ -77,7 +77,7 @@ suite('Objects', () => {
objects.mixin(foo, bar, false);
assert.equal(foo.bar, '123');
assert.strictEqual(foo.bar, '123');
});
test('cloneAndChange', () => {
@@ -86,7 +86,7 @@ suite('Objects', () => {
o1: o1,
o2: o1
};
assert.deepEqual(objects.cloneAndChange(o, () => { }), o);
assert.deepStrictEqual(objects.cloneAndChange(o, () => { }), o);
});
test('safeStringify', () => {
@@ -121,7 +121,7 @@ suite('Objects', () => {
let result = objects.safeStringify(circular);
assert.deepEqual(JSON.parse(result), {
assert.deepStrictEqual(JSON.parse(result), {
a: 42,
b: '[Circular]',
c: [
@@ -147,12 +147,12 @@ suite('Objects', () => {
};
let diff = objects.distinct(base, base);
assert.deepEqual(diff, {});
assert.strictEqual(Object.keys(diff).length, 0);
let obj = {};
diff = objects.distinct(base, obj);
assert.deepEqual(diff, {});
assert.strictEqual(Object.keys(diff).length, 0);
obj = {
one: 'one',
@@ -160,7 +160,7 @@ suite('Objects', () => {
};
diff = objects.distinct(base, obj);
assert.deepEqual(diff, {});
assert.strictEqual(Object.keys(diff).length, 0);
obj = {
three: {
@@ -170,7 +170,7 @@ suite('Objects', () => {
};
diff = objects.distinct(base, obj);
assert.deepEqual(diff, {});
assert.strictEqual(Object.keys(diff).length, 0);
obj = {
one: 'two',
@@ -182,10 +182,9 @@ suite('Objects', () => {
};
diff = objects.distinct(base, obj);
assert.deepEqual(diff, {
one: 'two',
four: true
});
assert.strictEqual(Object.keys(diff).length, 2);
assert.strictEqual(diff.one, 'two');
assert.strictEqual(diff.four, true);
obj = {
one: null,
@@ -197,10 +196,9 @@ suite('Objects', () => {
};
diff = objects.distinct(base, obj);
assert.deepEqual(diff, {
one: null,
four: undefined
});
assert.strictEqual(Object.keys(diff).length, 2);
assert.strictEqual(diff.one, null);
assert.strictEqual(diff.four, undefined);
obj = {
one: 'two',
@@ -210,7 +208,11 @@ suite('Objects', () => {
};
diff = objects.distinct(base, obj);
assert.deepEqual(diff, obj);
assert.strictEqual(Object.keys(diff).length, 4);
assert.strictEqual(diff.one, 'two');
assert.strictEqual(diff.two, 3);
assert.strictEqual(diff.three?.['3'], false);
assert.strictEqual(diff.four, true);
});
test('getCaseInsensitive', () => {
@@ -219,10 +221,10 @@ suite('Objects', () => {
mIxEdCaSe: 456
};
assert.equal(obj1.lowercase, objects.getCaseInsensitive(obj1, 'lowercase'));
assert.equal(obj1.lowercase, objects.getCaseInsensitive(obj1, 'lOwErCaSe'));
assert.strictEqual(obj1.lowercase, objects.getCaseInsensitive(obj1, 'lowercase'));
assert.strictEqual(obj1.lowercase, objects.getCaseInsensitive(obj1, 'lOwErCaSe'));
assert.equal(obj1.mIxEdCaSe, objects.getCaseInsensitive(obj1, 'MIXEDCASE'));
assert.equal(obj1.mIxEdCaSe, objects.getCaseInsensitive(obj1, 'mixedcase'));
assert.strictEqual(obj1.mIxEdCaSe, objects.getCaseInsensitive(obj1, 'MIXEDCASE'));
assert.strictEqual(obj1.mIxEdCaSe, objects.getCaseInsensitive(obj1, 'mixedcase'));
});
});

14
lib/vscode/src/vs/base/test/common/paging.test.ts
View File

@@ -148,7 +148,7 @@ suite('PagedModel', () => {
const model = new PagedModel(pager);
assert.equal(state, 'idle');
assert.strictEqual(state, 'idle');
const tokenSource1 = new CancellationTokenSource();
const promise1 = model.resolve(5, tokenSource1.token).then(
@@ -156,7 +156,7 @@ suite('PagedModel', () => {
err => assert(isPromiseCanceledError(err))
);
assert.equal(state, 'resolving');
assert.strictEqual(state, 'resolving');
const tokenSource2 = new CancellationTokenSource();
const promise2 = model.resolve(6, tokenSource2.token).then(
@@ -164,17 +164,17 @@ suite('PagedModel', () => {
err => assert(isPromiseCanceledError(err))
);
assert.equal(state, 'resolving');
assert.strictEqual(state, 'resolving');
setTimeout(() => {
assert.equal(state, 'resolving');
assert.strictEqual(state, 'resolving');
tokenSource1.cancel();
assert.equal(state, 'resolving');
assert.strictEqual(state, 'resolving');
setTimeout(() => {
assert.equal(state, 'resolving');
assert.strictEqual(state, 'resolving');
tokenSource2.cancel();
assert.equal(state, 'idle');
assert.strictEqual(state, 'idle');
}, 10);
}, 10);

48
lib/vscode/src/vs/base/test/common/path.test.ts
View File

@@ -353,11 +353,11 @@ suite('Paths (Node Implementation)', () => {
assert.strictEqual(path.posix.extname('file.\\\\'), '.\\\\');
// Tests from VSCode
assert.equal(path.extname('far.boo'), '.boo');
assert.equal(path.extname('far.b'), '.b');
assert.equal(path.extname('far.'), '.');
assert.equal(path.extname('far.boo/boo.far'), '.far');
assert.equal(path.extname('far.boo/boo'), '');
assert.strictEqual(path.extname('far.boo'), '.boo');
assert.strictEqual(path.extname('far.b'), '.b');
assert.strictEqual(path.extname('far.'), '.');
assert.strictEqual(path.extname('far.boo/boo.far'), '.far');
assert.strictEqual(path.extname('far.boo/boo'), '');
});
(isWeb && isWindows ? test.skip : test)('resolve', () => { // TODO@sbatten fails on windows & browser only
@@ -501,25 +501,25 @@ suite('Paths (Node Implementation)', () => {
controlCharFilename);
// Tests from VSCode
assert.equal(path.basename('foo/bar'), 'bar');
assert.equal(path.posix.basename('foo\\bar'), 'foo\\bar');
assert.equal(path.win32.basename('foo\\bar'), 'bar');
assert.equal(path.basename('/foo/bar'), 'bar');
assert.equal(path.posix.basename('\\foo\\bar'), '\\foo\\bar');
assert.equal(path.win32.basename('\\foo\\bar'), 'bar');
assert.equal(path.basename('./bar'), 'bar');
assert.equal(path.posix.basename('.\\bar'), '.\\bar');
assert.equal(path.win32.basename('.\\bar'), 'bar');
assert.equal(path.basename('/bar'), 'bar');
assert.equal(path.posix.basename('\\bar'), '\\bar');
assert.equal(path.win32.basename('\\bar'), 'bar');
assert.equal(path.basename('bar/'), 'bar');
assert.equal(path.posix.basename('bar\\'), 'bar\\');
assert.equal(path.win32.basename('bar\\'), 'bar');
assert.equal(path.basename('bar'), 'bar');
assert.equal(path.basename('////////'), '');
assert.equal(path.posix.basename('\\\\\\\\'), '\\\\\\\\');
assert.equal(path.win32.basename('\\\\\\\\'), '');
assert.strictEqual(path.basename('foo/bar'), 'bar');
assert.strictEqual(path.posix.basename('foo\\bar'), 'foo\\bar');
assert.strictEqual(path.win32.basename('foo\\bar'), 'bar');
assert.strictEqual(path.basename('/foo/bar'), 'bar');
assert.strictEqual(path.posix.basename('\\foo\\bar'), '\\foo\\bar');
assert.strictEqual(path.win32.basename('\\foo\\bar'), 'bar');
assert.strictEqual(path.basename('./bar'), 'bar');
assert.strictEqual(path.posix.basename('.\\bar'), '.\\bar');
assert.strictEqual(path.win32.basename('.\\bar'), 'bar');
assert.strictEqual(path.basename('/bar'), 'bar');
assert.strictEqual(path.posix.basename('\\bar'), '\\bar');
assert.strictEqual(path.win32.basename('\\bar'), 'bar');
assert.strictEqual(path.basename('bar/'), 'bar');
assert.strictEqual(path.posix.basename('bar\\'), 'bar\\');
assert.strictEqual(path.win32.basename('bar\\'), 'bar');
assert.strictEqual(path.basename('bar'), 'bar');
assert.strictEqual(path.basename('////////'), '');
assert.strictEqual(path.posix.basename('\\\\\\\\'), '\\\\\\\\');
assert.strictEqual(path.win32.basename('\\\\\\\\'), '');
});
test('relative', () => {

4
lib/vscode/src/vs/base/test/common/processes.test.ts
View File

@@ -27,7 +27,7 @@ suite('Processes', () => {
GDK_PIXBUF_MODULEDIR: 'x',
};
processes.sanitizeProcessEnvironment(env);
assert.equal(env['FOO'], 'bar');
assert.equal(Object.keys(env).length, 1);
assert.strictEqual(env['FOO'], 'bar');
assert.strictEqual(Object.keys(env).length, 1);
});
});

40
lib/vscode/src/vs/base/test/common/resourceTree.test.ts
View File

@@ -10,63 +10,63 @@ import { URI } from 'vs/base/common/uri';
suite('ResourceTree', function () {
test('ctor', function () {
const tree = new ResourceTree<string, null>(null);
assert.equal(tree.root.childrenCount, 0);
assert.strictEqual(tree.root.childrenCount, 0);
});
test('simple', function () {
const tree = new ResourceTree<string, null>(null);
tree.add(URI.file('/foo/bar.txt'), 'bar contents');
assert.equal(tree.root.childrenCount, 1);
assert.strictEqual(tree.root.childrenCount, 1);
let foo = tree.root.get('foo')!;
assert(foo);
assert.equal(foo.childrenCount, 1);
assert.strictEqual(foo.childrenCount, 1);
let bar = foo.get('bar.txt')!;
assert(bar);
assert.equal(bar.element, 'bar contents');
assert.strictEqual(bar.element, 'bar contents');
tree.add(URI.file('/hello.txt'), 'hello contents');
assert.equal(tree.root.childrenCount, 2);
assert.strictEqual(tree.root.childrenCount, 2);
let hello = tree.root.get('hello.txt')!;
assert(hello);
assert.equal(hello.element, 'hello contents');
assert.strictEqual(hello.element, 'hello contents');
tree.delete(URI.file('/foo/bar.txt'));
assert.equal(tree.root.childrenCount, 1);
assert.strictEqual(tree.root.childrenCount, 1);
hello = tree.root.get('hello.txt')!;
assert(hello);
assert.equal(hello.element, 'hello contents');
assert.strictEqual(hello.element, 'hello contents');
});
test('folders with data', function () {
const tree = new ResourceTree<string, null>(null);
assert.equal(tree.root.childrenCount, 0);
assert.strictEqual(tree.root.childrenCount, 0);
tree.add(URI.file('/foo'), 'foo');
assert.equal(tree.root.childrenCount, 1);
assert.equal(tree.root.get('foo')!.element, 'foo');
assert.strictEqual(tree.root.childrenCount, 1);
assert.strictEqual(tree.root.get('foo')!.element, 'foo');
tree.add(URI.file('/bar'), 'bar');
assert.equal(tree.root.childrenCount, 2);
assert.equal(tree.root.get('bar')!.element, 'bar');
assert.strictEqual(tree.root.childrenCount, 2);
assert.strictEqual(tree.root.get('bar')!.element, 'bar');
tree.add(URI.file('/foo/file.txt'), 'file');
assert.equal(tree.root.childrenCount, 2);
assert.equal(tree.root.get('foo')!.element, 'foo');
assert.equal(tree.root.get('bar')!.element, 'bar');
assert.equal(tree.root.get('foo')!.get('file.txt')!.element, 'file');
assert.strictEqual(tree.root.childrenCount, 2);
assert.strictEqual(tree.root.get('foo')!.element, 'foo');
assert.strictEqual(tree.root.get('bar')!.element, 'bar');
assert.strictEqual(tree.root.get('foo')!.get('file.txt')!.element, 'file');
tree.delete(URI.file('/foo'));
assert.equal(tree.root.childrenCount, 1);
assert.strictEqual(tree.root.childrenCount, 1);
assert(!tree.root.get('foo'));
assert.equal(tree.root.get('bar')!.element, 'bar');
assert.strictEqual(tree.root.get('bar')!.element, 'bar');
tree.delete(URI.file('/bar'));
assert.equal(tree.root.childrenCount, 0);
assert.strictEqual(tree.root.childrenCount, 0);
assert(!tree.root.get('foo'));
assert(!tree.root.get('bar'));
});

49
lib/vscode/src/vs/base/test/common/stream.test.ts
View File

@@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
import { isReadableStream, newWriteableStream, Readable, consumeReadable, peekReadable, consumeStream, ReadableStream, toStream, toReadable, transform, peekStream, isReadableBufferedStream, listenStream } from 'vs/base/common/stream';
import { isReadableStream, newWriteableStream, Readable, consumeReadable, peekReadable, consumeStream, ReadableStream, toStream, toReadable, transform, peekStream, isReadableBufferedStream, listenStream, prefixedReadable, prefixedStream } from 'vs/base/common/stream';
import { timeout } from 'vs/base/common/async';
suite('Stream', () => {
@@ -386,7 +386,7 @@ suite('Stream', () => {
test('toReadable', async () => {
const readable = toReadable('1,2,3,4,5');
const consumed = await consumeReadable(readable, strings => strings.join());
const consumed = consumeReadable(readable, strings => strings.join());
assert.strictEqual(consumed, '1,2,3,4,5');
});
@@ -424,4 +424,49 @@ suite('Stream', () => {
assert.strictEqual(listener1Called, true);
assert.strictEqual(listener2Called, true);
});
test('prefixedReadable', () => {
// Basic
let readable = prefixedReadable('1,2', arrayToReadable(['3', '4', '5']), val => val.join(','));
assert.strictEqual(consumeReadable(readable, val => val.join(',')), '1,2,3,4,5');
// Empty
readable = prefixedReadable('empty', arrayToReadable<string>([]), val => val.join(','));
assert.strictEqual(consumeReadable(readable, val => val.join(',')), 'empty');
});
test('prefixedStream', async () => {
// Basic
let stream = newWriteableStream<string>(strings => strings.join());
stream.write('3');
stream.write('4');
stream.write('5');
stream.end();
let prefixStream = prefixedStream<string>('1,2', stream, val => val.join(','));
assert.strictEqual(await consumeStream(prefixStream, val => val.join(',')), '1,2,3,4,5');
// Empty
stream = newWriteableStream<string>(strings => strings.join());
stream.end();
prefixStream = prefixedStream<string>('1,2', stream, val => val.join(','));
assert.strictEqual(await consumeStream(prefixStream, val => val.join(',')), '1,2');
// Error
stream = newWriteableStream<string>(strings => strings.join());
stream.error(new Error('fail'));
prefixStream = prefixedStream<string>('error', stream, val => val.join(','));
let error;
try {
await consumeStream(prefixStream, val => val.join(','));
} catch (e) {
error = e;
}
assert.ok(error);
});
});

6
lib/vscode/src/vs/base/test/node/processes/processes.test.ts
View File

@@ -46,11 +46,11 @@ suite('Processes', () => {
counter++;
if (counter === 1) {
assert.equal(msgFromChild, msg1);
assert.strictEqual(msgFromChild, msg1);
} else if (counter === 2) {
assert.equal(msgFromChild, msg2);
assert.strictEqual(msgFromChild, msg2);
} else if (counter === 3) {
assert.equal(msgFromChild, msg3);
assert.strictEqual(msgFromChild, msg3);
child.kill();
done();