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']);
});
});