chore(vscode): update to 1.53.2

These conflicts will be resolved in the following commits. We do it this way so
that PR review is possible.

lib/vscode/src/vs/base/test/browser/actionbar.test.ts

@@ -33,28 +33,28 @@ suite('Actionbar', () => {
 		let a2 = new Action('a2');
 
 		actionbar.push(a1);
-		assert.equal(actionbar.hasAction(a1), true);
-		assert.equal(actionbar.hasAction(a2), false);
+		assert.strictEqual(actionbar.hasAction(a1), true);
+		assert.strictEqual(actionbar.hasAction(a2), false);
 
 		actionbar.pull(0);
-		assert.equal(actionbar.hasAction(a1), false);
+		assert.strictEqual(actionbar.hasAction(a1), false);
 
 		actionbar.push(a1, { index: 1 });
 		actionbar.push(a2, { index: 0 });
-		assert.equal(actionbar.hasAction(a1), true);
-		assert.equal(actionbar.hasAction(a2), true);
+		assert.strictEqual(actionbar.hasAction(a1), true);
+		assert.strictEqual(actionbar.hasAction(a2), true);
 
 		actionbar.pull(0);
-		assert.equal(actionbar.hasAction(a1), true);
-		assert.equal(actionbar.hasAction(a2), false);
+		assert.strictEqual(actionbar.hasAction(a1), true);
+		assert.strictEqual(actionbar.hasAction(a2), false);
 
 		actionbar.pull(0);
-		assert.equal(actionbar.hasAction(a1), false);
-		assert.equal(actionbar.hasAction(a2), false);
+		assert.strictEqual(actionbar.hasAction(a1), false);
+		assert.strictEqual(actionbar.hasAction(a2), false);
 
 		actionbar.push(a1);
-		assert.equal(actionbar.hasAction(a1), true);
+		assert.strictEqual(actionbar.hasAction(a1), true);
 		actionbar.clear();
-		assert.equal(actionbar.hasAction(a1), false);
+		assert.strictEqual(actionbar.hasAction(a1), false);
 	});
 });

lib/vscode/src/vs/base/test/browser/comparers.test.ts

@@ -123,8 +123,8 @@ suite('Comparers', () => {
 		// name-only comparisions
 		assert(compareFileExtensions('a', 'A') !== compareLocale('a', 'A'), 'the same letter of different case does not sort by locale');
 		assert(compareFileExtensions('â', 'Â') !== compareLocale('â', 'Â'), 'the same accented letter of different case does not sort by locale');
-		assert.notDeepEqual(['artichoke', 'Artichoke', 'art', 'Art'].sort(compareFileExtensions), ['artichoke', 'Artichoke', 'art', 'Art'].sort(compareLocale), 'words with the same root and different cases do not sort in locale order');
-		assert.notDeepEqual(['email', 'Email', 'émail', 'Émail'].sort(compareFileExtensions), ['email', 'Email', 'émail', 'Émail'].sort((a, b) => a.localeCompare(b)), 'the same base characters with different case or accents do not sort in locale order');
+		assert.notDeepStrictEqual(['artichoke', 'Artichoke', 'art', 'Art'].sort(compareFileExtensions), ['artichoke', 'Artichoke', 'art', 'Art'].sort(compareLocale), 'words with the same root and different cases do not sort in locale order');
+		assert.notDeepStrictEqual(['email', 'Email', 'émail', 'Émail'].sort(compareFileExtensions), ['email', 'Email', 'émail', 'Émail'].sort((a, b) => a.localeCompare(b)), 'the same base characters with different case or accents do not sort in locale order');
 
 		// name plus extension comparisons
 		assert(compareFileExtensions('a.MD', 'a.md') !== compareLocale('MD', 'md'), 'case differences in extensions do not sort by locale');
@@ -197,8 +197,7 @@ suite('Comparers', () => {
 		// name-only comparisons
 		assert(compareFileNamesDefault('a', 'A') === compareLocale('a', 'A'), 'the same letter sorts by locale');
 		assert(compareFileNamesDefault('â', 'Â') === compareLocale('â', 'Â'), 'the same accented letter sorts by locale');
-		// assert.deepEqual(['artichoke', 'Artichoke', 'art', 'Art'].sort(compareFileNamesDefault), ['artichoke', 'Artichoke', 'art', 'Art'].sort(compareLocale), 'words with the same root and different cases sort in locale order');
-		assert.deepEqual(['email', 'Email', 'émail', 'Émail'].sort(compareFileNamesDefault), ['email', 'Email', 'émail', 'Émail'].sort(compareLocale), 'the same base characters with different case or accents sort in locale order');
+		assert.deepStrictEqual(['email', 'Email', 'émail', 'Émail'].sort(compareFileNamesDefault), ['email', 'Email', 'émail', 'Émail'].sort(compareLocale), 'the same base characters with different case or accents sort in locale order');
 
 		// numeric comparisons
 		assert(compareFileNamesDefault('abc02.txt', 'abc002.txt') < 0, 'filenames with equivalent numbers and leading zeros sort shortest number first');
@@ -259,8 +258,7 @@ suite('Comparers', () => {
 		// name-only comparisons
 		assert(compareFileExtensionsDefault('a', 'A') === compareLocale('a', 'A'), 'the same letter of different case sorts by locale');
 		assert(compareFileExtensionsDefault('â', 'Â') === compareLocale('â', 'Â'), 'the same accented letter of different case sorts by locale');
-		// assert.deepEqual(['artichoke', 'Artichoke', 'art', 'Art'].sort(compareFileExtensionsDefault), ['artichoke', 'Artichoke', 'art', 'Art'].sort(compareLocale), 'words with the same root and different cases sort in locale order');
-		assert.deepEqual(['email', 'Email', 'émail', 'Émail'].sort(compareFileExtensionsDefault), ['email', 'Email', 'émail', 'Émail'].sort((a, b) => a.localeCompare(b)), 'the same base characters with different case or accents sort in locale order');
+		assert.deepStrictEqual(['email', 'Email', 'émail', 'Émail'].sort(compareFileExtensionsDefault), ['email', 'Email', 'émail', 'Émail'].sort((a, b) => a.localeCompare(b)), 'the same base characters with different case or accents sort in locale order');
 
 		// name plus extension comparisons
 		assert(compareFileExtensionsDefault('a.MD', 'a.md') === compareLocale('MD', 'md'), 'case differences in extensions sort by locale');

lib/vscode/src/vs/base/test/browser/dom.test.ts

@@ -73,8 +73,9 @@ suite('dom', () => {
 	});
 
 	test('multibyteAwareBtoa', () => {
-		assert.equal(dom.multibyteAwareBtoa('hello world'), dom.multibyteAwareBtoa('hello world'));
-		assert.ok(dom.multibyteAwareBtoa('平仮名'));
+		assert.ok(dom.multibyteAwareBtoa('hello world').length > 0);
+		assert.ok(dom.multibyteAwareBtoa('平仮名').length > 0);
+		assert.ok(dom.multibyteAwareBtoa(new Array(100000).fill('vs').join('')).length > 0); // https://github.com/microsoft/vscode/issues/112013
 	});
 
 	suite('$', () => {

lib/vscode/src/vs/base/test/browser/iconLabels.test.ts

@@ -3,45 +3,45 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { renderCodicons } from 'vs/base/browser/codicons';
+import { renderLabelWithIcons } from 'vs/base/browser/ui/iconLabel/iconLabels';
 import * as assert from 'assert';
 
-suite('renderCodicons', () => {
+suite('renderLabelWithIcons', () => {
 
-	test('no codicons', () => {
-		const result = renderCodicons(' hello World .');
+	test('no icons', () => {
+		const result = renderLabelWithIcons(' hello World .');
 
 		assert.equal(elementsToString(result), ' hello World .');
 	});
 
-	test('codicon only', () => {
-		const result = renderCodicons('$(alert)');
+	test('icons only', () => {
+		const result = renderLabelWithIcons('$(alert)');
 
 		assert.equal(elementsToString(result), '<span class="codicon codicon-alert"></span>');
 	});
 
-	test('codicon and non-codicon strings', () => {
-		const result = renderCodicons(` $(alert) Unresponsive`);
+	test('icon and non-icon strings', () => {
+		const result = renderLabelWithIcons(` $(alert) Unresponsive`);
 
 		assert.equal(elementsToString(result), ' <span class="codicon codicon-alert"></span> Unresponsive');
 	});
 
-	test('multiple codicons', () => {
-		const result = renderCodicons('$(check)$(error)');
+	test('multiple icons', () => {
+		const result = renderLabelWithIcons('$(check)$(error)');
 
 		assert.equal(elementsToString(result), '<span class="codicon codicon-check"></span><span class="codicon codicon-error"></span>');
 	});
 
-	test('escaped codicon', () => {
-		const result = renderCodicons('\\$(escaped)');
+	test('escaped icons', () => {
+		const result = renderLabelWithIcons('\\$(escaped)');
 
 		assert.equal(elementsToString(result), '$(escaped)');
 	});
 
-	test('codicon with animation', () => {
-		const result = renderCodicons('$(zip~anim)');
+	test('icon with animation', () => {
+		const result = renderLabelWithIcons('$(zip~anim)');
 
-		assert.equal(elementsToString(result), '<span class="codicon codicon-zip codicon-animation-anim"></span>');
+		assert.equal(elementsToString(result), '<span class="codicon codicon-zip codicon-modifier-anim"></span>');
 	});
 
 	const elementsToString = (elements: Array<HTMLElement | string>): string => {

lib/vscode/src/vs/base/test/browser/ui/scrollbar/scrollableElement.test.ts

@@ -53,7 +53,7 @@ suite('MouseWheelClassifier', () => {
 			classifier.accept(timestamp, deltaX, deltaY);
 
 			const actual = classifier.isPhysicalMouseWheel();
-			assert.equal(actual, false);
+			assert.strictEqual(actual, false);
 		}
 	});
 
@@ -142,7 +142,7 @@ suite('MouseWheelClassifier', () => {
 			classifier.accept(timestamp, deltaX, deltaY);
 
 			const actual = classifier.isPhysicalMouseWheel();
-			assert.equal(actual, false);
+			assert.strictEqual(actual, false);
 		}
 	});
 
@@ -202,7 +202,7 @@ suite('MouseWheelClassifier', () => {
 			classifier.accept(timestamp, deltaX, deltaY);
 
 			const actual = classifier.isPhysicalMouseWheel();
-			assert.equal(actual, true);
+			assert.strictEqual(actual, true);
 		}
 	});
 
@@ -241,7 +241,7 @@ suite('MouseWheelClassifier', () => {
 			classifier.accept(timestamp, deltaX, deltaY);
 
 			const actual = classifier.isPhysicalMouseWheel();
-			assert.equal(actual, true);
+			assert.strictEqual(actual, true);
 		}
 	});
 
@@ -285,7 +285,7 @@ suite('MouseWheelClassifier', () => {
 			classifier.accept(timestamp, deltaX, deltaY);
 
 			const actual = classifier.isPhysicalMouseWheel();
-			assert.equal(actual, false);
+			assert.strictEqual(actual, false);
 		}
 	});
 
@@ -374,7 +374,7 @@ suite('MouseWheelClassifier', () => {
 			classifier.accept(timestamp, deltaX, deltaY);
 
 			const actual = classifier.isPhysicalMouseWheel();
-			assert.equal(actual, true);
+			assert.strictEqual(actual, true);
 		}
 	});
 
@@ -464,7 +464,7 @@ suite('MouseWheelClassifier', () => {
 			classifier.accept(timestamp, deltaX, deltaY);
 
 			const actual = classifier.isPhysicalMouseWheel();
-			assert.equal(actual, true);
+			assert.strictEqual(actual, true);
 		}
 	});
 
@@ -518,7 +518,7 @@ suite('MouseWheelClassifier', () => {
 			classifier.accept(timestamp, deltaX, deltaY);
 
 			const actual = classifier.isPhysicalMouseWheel();
-			assert.equal(actual, true);
+			assert.strictEqual(actual, true);
 		}
 	});
 });

lib/vscode/src/vs/base/test/browser/ui/scrollbar/scrollbarState.test.ts

@@ -10,52 +10,52 @@ suite('ScrollbarState', () => {
 	test('inflates slider size', () => {
 		let actual = new ScrollbarState(0, 14, 0, 339, 42423, 32787);
 
-		assert.equal(actual.getArrowSize(), 0);
-		assert.equal(actual.getScrollPosition(), 32787);
-		assert.equal(actual.getRectangleLargeSize(), 339);
-		assert.equal(actual.getRectangleSmallSize(), 14);
-		assert.equal(actual.isNeeded(), true);
-		assert.equal(actual.getSliderSize(), 20);
-		assert.equal(actual.getSliderPosition(), 249);
+		assert.strictEqual(actual.getArrowSize(), 0);
+		assert.strictEqual(actual.getScrollPosition(), 32787);
+		assert.strictEqual(actual.getRectangleLargeSize(), 339);
+		assert.strictEqual(actual.getRectangleSmallSize(), 14);
+		assert.strictEqual(actual.isNeeded(), true);
+		assert.strictEqual(actual.getSliderSize(), 20);
+		assert.strictEqual(actual.getSliderPosition(), 249);
 
-		assert.equal(actual.getDesiredScrollPositionFromOffset(259), 32849);
+		assert.strictEqual(actual.getDesiredScrollPositionFromOffset(259), 32849);
 
 		// 259 is greater than 230 so page down, 32787 + 339 =  33126
-		assert.equal(actual.getDesiredScrollPositionFromOffsetPaged(259), 33126);
+		assert.strictEqual(actual.getDesiredScrollPositionFromOffsetPaged(259), 33126);
 
 		actual.setScrollPosition(32849);
-		assert.equal(actual.getArrowSize(), 0);
-		assert.equal(actual.getScrollPosition(), 32849);
-		assert.equal(actual.getRectangleLargeSize(), 339);
-		assert.equal(actual.getRectangleSmallSize(), 14);
-		assert.equal(actual.isNeeded(), true);
-		assert.equal(actual.getSliderSize(), 20);
-		assert.equal(actual.getSliderPosition(), 249);
+		assert.strictEqual(actual.getArrowSize(), 0);
+		assert.strictEqual(actual.getScrollPosition(), 32849);
+		assert.strictEqual(actual.getRectangleLargeSize(), 339);
+		assert.strictEqual(actual.getRectangleSmallSize(), 14);
+		assert.strictEqual(actual.isNeeded(), true);
+		assert.strictEqual(actual.getSliderSize(), 20);
+		assert.strictEqual(actual.getSliderPosition(), 249);
 	});
 
 	test('inflates slider size with arrows', () => {
 		let actual = new ScrollbarState(12, 14, 0, 339, 42423, 32787);
 
-		assert.equal(actual.getArrowSize(), 12);
-		assert.equal(actual.getScrollPosition(), 32787);
-		assert.equal(actual.getRectangleLargeSize(), 339);
-		assert.equal(actual.getRectangleSmallSize(), 14);
-		assert.equal(actual.isNeeded(), true);
-		assert.equal(actual.getSliderSize(), 20);
-		assert.equal(actual.getSliderPosition(), 230);
+		assert.strictEqual(actual.getArrowSize(), 12);
+		assert.strictEqual(actual.getScrollPosition(), 32787);
+		assert.strictEqual(actual.getRectangleLargeSize(), 339);
+		assert.strictEqual(actual.getRectangleSmallSize(), 14);
+		assert.strictEqual(actual.isNeeded(), true);
+		assert.strictEqual(actual.getSliderSize(), 20);
+		assert.strictEqual(actual.getSliderPosition(), 230);
 
-		assert.equal(actual.getDesiredScrollPositionFromOffset(240 + 12), 32811);
+		assert.strictEqual(actual.getDesiredScrollPositionFromOffset(240 + 12), 32811);
 
 		// 240 + 12 = 252; greater than 230 so page down, 32787 + 339 =  33126
-		assert.equal(actual.getDesiredScrollPositionFromOffsetPaged(240 + 12), 33126);
+		assert.strictEqual(actual.getDesiredScrollPositionFromOffsetPaged(240 + 12), 33126);
 
 		actual.setScrollPosition(32811);
-		assert.equal(actual.getArrowSize(), 12);
-		assert.equal(actual.getScrollPosition(), 32811);
-		assert.equal(actual.getRectangleLargeSize(), 339);
-		assert.equal(actual.getRectangleSmallSize(), 14);
-		assert.equal(actual.isNeeded(), true);
-		assert.equal(actual.getSliderSize(), 20);
-		assert.equal(actual.getSliderPosition(), 230);
+		assert.strictEqual(actual.getArrowSize(), 12);
+		assert.strictEqual(actual.getScrollPosition(), 32811);
+		assert.strictEqual(actual.getRectangleLargeSize(), 339);
+		assert.strictEqual(actual.getRectangleSmallSize(), 14);
+		assert.strictEqual(actual.isNeeded(), true);
+		assert.strictEqual(actual.getSliderSize(), 20);
+		assert.strictEqual(actual.getSliderPosition(), 230);
 	});
 });

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

@@ -8,6 +8,7 @@ import { compress, ICompressedTreeElement, ICompressedTreeNode, decompress, Comp
 import { Iterable } from 'vs/base/common/iterator';
 import { ITreeNode } from 'vs/base/browser/ui/tree/tree';
 import { IList } from 'vs/base/browser/ui/tree/indexTreeModel';
+import { IObjectTreeModelSetChildrenOptions } from 'vs/base/browser/ui/tree/objectTreeModel';
 
 interface IResolvedCompressedTreeElement<T> extends ICompressedTreeElement<T> {
 	readonly element: T;
@@ -304,6 +305,16 @@ suite('CompressedObjectTree', function () {
 
 	suite('CompressedObjectTreeModel', function () {
 
+		/**
+		 * Calls that test function twice, once with an empty options and
+		 * once with `diffIdentityProvider`.
+		 */
+		function withSmartSplice(fn: (options: IObjectTreeModelSetChildrenOptions<number, any>) => void) {
+			fn({});
+			fn({ diffIdentityProvider: { getId: n => String(n) } });
+		}
+
+
 		test('ctor', () => {
 			const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
 			const model = new CompressedObjectTreeModel<number>('test', toList(list));
@@ -312,7 +323,7 @@ suite('CompressedObjectTree', function () {
 			assert.equal(model.size, 0);
 		});
 
-		test('flat', () => {
+		test('flat', () => withSmartSplice(options => {
 			const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
 			const model = new CompressedObjectTreeModel<number>('test', toList(list));
 
@@ -320,7 +331,7 @@ suite('CompressedObjectTree', function () {
 				{ element: 0 },
 				{ element: 1 },
 				{ element: 2 }
-			]);
+			], options);
 
 			assert.deepEqual(toArray(list), [[0], [1], [2]]);
 			assert.equal(model.size, 3);
@@ -329,17 +340,17 @@ suite('CompressedObjectTree', function () {
 				{ element: 3 },
 				{ element: 4 },
 				{ element: 5 },
-			]);
+			], options);
 
 			assert.deepEqual(toArray(list), [[3], [4], [5]]);
 			assert.equal(model.size, 3);
 
-			model.setChildren(null);
+			model.setChildren(null, [], options);
 			assert.deepEqual(toArray(list), []);
 			assert.equal(model.size, 0);
-		});
+		}));
 
-		test('nested', () => {
+		test('nested', () => withSmartSplice(options => {
 			const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
 			const model = new CompressedObjectTreeModel<number>('test', toList(list));
 
@@ -353,7 +364,7 @@ suite('CompressedObjectTree', function () {
 				},
 				{ element: 1 },
 				{ element: 2 }
-			]);
+			], options);
 
 			assert.deepEqual(toArray(list), [[0], [10], [11], [12], [1], [2]]);
 			assert.equal(model.size, 6);
@@ -361,21 +372,21 @@ suite('CompressedObjectTree', function () {
 			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);
 
-			model.setChildren(0);
+			model.setChildren(0, [], options);
 			assert.deepEqual(toArray(list), [[0], [1], [2]]);
 			assert.equal(model.size, 3);
 
-			model.setChildren(null);
+			model.setChildren(null, [], options);
 			assert.deepEqual(toArray(list), []);
 			assert.equal(model.size, 0);
-		});
+		}));
 
-		test('compressed', () => {
+		test('compressed', () => withSmartSplice(options => {
 			const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
 			const model = new CompressedObjectTreeModel<number>('test', toList(list));
 
@@ -391,7 +402,7 @@ suite('CompressedObjectTree', function () {
 						}]
 					}]
 				}
-			]);
+			], options);
 
 			assert.deepEqual(toArray(list), [[1, 11, 111], [1111], [1112], [1113]]);
 			assert.equal(model.size, 6);
@@ -400,21 +411,21 @@ suite('CompressedObjectTree', function () {
 				{ element: 111 },
 				{ element: 112 },
 				{ element: 113 },
-			]);
+			], options);
 
 			assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113]]);
 			assert.equal(model.size, 5);
 
 			model.setChildren(113, [
 				{ element: 1131 }
-			]);
+			], options);
 
 			assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113, 1131]]);
 			assert.equal(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);
@@ -422,10 +433,10 @@ suite('CompressedObjectTree', function () {
 			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);
-		});
+		}));
 	});
 });

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

@@ -4,8 +4,8 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as assert from 'assert';
-import { ITreeNode, ITreeFilter, TreeVisibility } from 'vs/base/browser/ui/tree/tree';
-import { IndexTreeModel, IIndexTreeNode, IList } from 'vs/base/browser/ui/tree/indexTreeModel';
+import { ITreeNode, ITreeFilter, TreeVisibility, ITreeElement } from 'vs/base/browser/ui/tree/tree';
+import { IndexTreeModel, IIndexTreeNode, IList, IIndexTreeModelSpliceOptions } from 'vs/base/browser/ui/tree/indexTreeModel';
 
 function toList<T>(arr: T[]): IList<T> {
 	return {
@@ -20,7 +20,23 @@ function toArray<T>(list: ITreeNode<T>[]): T[] {
 	return list.map(i => i.element);
 }
 
-suite('IndexTreeModel', function () {
+
+function toElements<T>(node: ITreeNode<T>): any {
+	return node.children?.length ? { e: node.element, children: node.children.map(toElements) } : node.element;
+}
+
+const diffIdentityProvider = { getId: (n: number) => String(n) };
+
+/**
+ * Calls that test function twice, once with an empty options and
+ * once with `diffIdentityProvider`.
+ */
+function withSmartSplice(fn: (options: IIndexTreeModelSpliceOptions<number, any>) => void) {
+	fn({});
+	fn({ diffIdentityProvider });
+}
+
+suite('IndexTreeModel', () => {
 
 	test('ctor', () => {
 		const list: ITreeNode<number>[] = [];
@@ -29,7 +45,7 @@ suite('IndexTreeModel', function () {
 		assert.equal(list.length, 0);
 	});
 
-	test('insert', () => {
+	test('insert', () => withSmartSplice(options => {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toList(list), -1);
 
@@ -37,7 +53,7 @@ suite('IndexTreeModel', function () {
 			{ element: 0 },
 			{ element: 1 },
 			{ element: 2 }
-		]);
+		], options);
 
 		assert.deepEqual(list.length, 3);
 		assert.deepEqual(list[0].element, 0);
@@ -49,9 +65,9 @@ suite('IndexTreeModel', function () {
 		assert.deepEqual(list[2].element, 2);
 		assert.deepEqual(list[2].collapsed, false);
 		assert.deepEqual(list[2].depth, 1);
-	});
+	}));
 
-	test('deep insert', function () {
+	test('deep insert', () => withSmartSplice(options => {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toList(list), -1);
 
@@ -86,9 +102,9 @@ suite('IndexTreeModel', function () {
 		assert.deepEqual(list[5].element, 2);
 		assert.deepEqual(list[5].collapsed, false);
 		assert.deepEqual(list[5].depth, 1);
-	});
+	}));
 
-	test('deep insert collapsed', function () {
+	test('deep insert collapsed', () => withSmartSplice(options => {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toList(list), -1);
 
@@ -102,7 +118,7 @@ suite('IndexTreeModel', function () {
 			},
 			{ element: 1 },
 			{ element: 2 }
-		]);
+		], options);
 
 		assert.deepEqual(list.length, 3);
 		assert.deepEqual(list[0].element, 0);
@@ -114,9 +130,9 @@ suite('IndexTreeModel', function () {
 		assert.deepEqual(list[2].element, 2);
 		assert.deepEqual(list[2].collapsed, false);
 		assert.deepEqual(list[2].depth, 1);
-	});
+	}));
 
-	test('delete', () => {
+	test('delete', () => withSmartSplice(options => {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toList(list), -1);
 
@@ -124,11 +140,11 @@ suite('IndexTreeModel', function () {
 			{ element: 0 },
 			{ element: 1 },
 			{ element: 2 }
-		]);
+		], options);
 
 		assert.deepEqual(list.length, 3);
 
-		model.splice([1], 1);
+		model.splice([1], 1, undefined, options);
 		assert.deepEqual(list.length, 2);
 		assert.deepEqual(list[0].element, 0);
 		assert.deepEqual(list[0].collapsed, false);
@@ -137,11 +153,11 @@ suite('IndexTreeModel', function () {
 		assert.deepEqual(list[1].collapsed, false);
 		assert.deepEqual(list[1].depth, 1);
 
-		model.splice([0], 2);
+		model.splice([0], 2, undefined, options);
 		assert.deepEqual(list.length, 0);
-	});
+	}));
 
-	test('nested delete', function () {
+	test('nested delete', () => withSmartSplice(options => {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toList(list), -1);
 
@@ -155,11 +171,11 @@ suite('IndexTreeModel', function () {
 			},
 			{ element: 1 },
 			{ element: 2 }
-		]);
+		], options);
 
 		assert.deepEqual(list.length, 6);
 
-		model.splice([1], 2);
+		model.splice([1], 2, undefined, options);
 		assert.deepEqual(list.length, 4);
 		assert.deepEqual(list[0].element, 0);
 		assert.deepEqual(list[0].collapsed, false);
@@ -173,9 +189,9 @@ suite('IndexTreeModel', function () {
 		assert.deepEqual(list[3].element, 12);
 		assert.deepEqual(list[3].collapsed, false);
 		assert.deepEqual(list[3].depth, 2);
-	});
+	}));
 
-	test('deep delete', function () {
+	test('deep delete', () => withSmartSplice(options => {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toList(list), -1);
 
@@ -189,11 +205,11 @@ suite('IndexTreeModel', function () {
 			},
 			{ element: 1 },
 			{ element: 2 }
-		]);
+		], options);
 
 		assert.deepEqual(list.length, 6);
 
-		model.splice([0], 1);
+		model.splice([0], 1, undefined, options);
 		assert.deepEqual(list.length, 2);
 		assert.deepEqual(list[0].element, 1);
 		assert.deepEqual(list[0].collapsed, false);
@@ -201,9 +217,43 @@ suite('IndexTreeModel', function () {
 		assert.deepEqual(list[1].element, 2);
 		assert.deepEqual(list[1].collapsed, false);
 		assert.deepEqual(list[1].depth, 1);
+	}));
+
+	test('smart splice deep', () => {
+		const list: ITreeNode<number>[] = [];
+		const model = new IndexTreeModel<number>('test', toList(list), -1);
+
+		model.splice([0], 0, [
+			{ element: 0 },
+			{ element: 1 },
+			{ element: 2 },
+			{ element: 3 },
+		], { diffIdentityProvider });
+
+		assert.deepStrictEqual(list.filter(l => l.depth === 1).map(toElements), [
+			0,
+			1,
+			2,
+			3,
+		]);
+
+		model.splice([0], 3, [
+			{ element: -0.5 },
+			{ element: 0, children: [{ element: 0.1 }] },
+			{ element: 1 },
+			{ element: 2, children: [{ element: 2.1 }, { element: 2.2, children: [{ element: 2.21 }] }] },
+		], { diffIdentityProvider, diffDepth: Infinity });
+
+		assert.deepStrictEqual(list.filter(l => l.depth === 1).map(toElements), [
+			-0.5,
+			{ e: 0, children: [0.1] },
+			1,
+			{ e: 2, children: [2.1, { e: 2.2, children: [2.21] }] },
+			3,
+		]);
 	});
 
-	test('hidden delete', function () {
+	test('hidden delete', () => withSmartSplice(options => {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toList(list), -1);
 
@@ -217,18 +267,18 @@ suite('IndexTreeModel', function () {
 			},
 			{ element: 1 },
 			{ element: 2 }
-		]);
+		], options);
 
 		assert.deepEqual(list.length, 3);
 
-		model.splice([0, 1], 1);
+		model.splice([0, 1], 1, undefined, options);
 		assert.deepEqual(list.length, 3);
 
-		model.splice([0, 0], 2);
+		model.splice([0, 0], 2, undefined, options);
 		assert.deepEqual(list.length, 3);
-	});
+	}));
 
-	test('collapse', () => {
+	test('collapse', () => withSmartSplice(options => {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toList(list), -1);
 
@@ -242,7 +292,7 @@ suite('IndexTreeModel', function () {
 			},
 			{ element: 1 },
 			{ element: 2 }
-		]);
+		], options);
 
 		assert.deepEqual(list.length, 6);
 
@@ -257,9 +307,33 @@ suite('IndexTreeModel', function () {
 		assert.deepEqual(list[2].element, 2);
 		assert.deepEqual(list[2].collapsed, false);
 		assert.deepEqual(list[2].depth, 1);
-	});
+	}));
 
-	test('expand', () => {
+	test('updates collapsible', () => withSmartSplice(options => {
+		const list: ITreeNode<number>[] = [];
+		const model = new IndexTreeModel<number>('test', toList(list), -1);
+
+		model.splice([0], 0, [
+			{
+				element: 0, children: [
+					{ element: 1 },
+				]
+			},
+		], options);
+
+		assert.strictEqual(list[0].collapsible, true);
+		assert.strictEqual(list[1].collapsible, false);
+
+		model.splice([0, 0], 1, [], options);
+		assert.strictEqual(list[0].collapsible, false);
+		assert.strictEqual(list[1], undefined);
+
+		model.splice([0, 0], 0, [{ element: 1 }], options);
+		assert.strictEqual(list[0].collapsible, true);
+		assert.strictEqual(list[1].collapsible, false);
+	}));
+
+	test('expand', () => withSmartSplice(options => {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toList(list), -1);
 
@@ -273,7 +347,7 @@ suite('IndexTreeModel', function () {
 			},
 			{ element: 1 },
 			{ element: 2 }
-		]);
+		], options);
 
 		assert.deepEqual(list.length, 3);
 
@@ -297,9 +371,52 @@ suite('IndexTreeModel', function () {
 		assert.deepEqual(list[5].element, 2);
 		assert.deepEqual(list[5].collapsed, false);
 		assert.deepEqual(list[5].depth, 1);
+	}));
+
+	test('smart diff consistency', () => {
+		const times = 500;
+		const minEdits = 1;
+		const maxEdits = 10;
+		const maxInserts = 5;
+
+		for (let i = 0; i < times; i++) {
+			const list: ITreeNode<number>[] = [];
+			const options = { diffIdentityProvider: { getId: (n: number) => String(n) } };
+			const model = new IndexTreeModel<number>('test', toList(list), -1);
+
+			const changes = [];
+			const expected: number[] = [];
+			let elementCounter = 0;
+
+			for (let edits = Math.random() * (maxEdits - minEdits) + minEdits; edits > 0; edits--) {
+				const spliceIndex = Math.floor(Math.random() * list.length);
+				const deleteCount = Math.ceil(Math.random() * (list.length - spliceIndex));
+				const insertCount = Math.floor(Math.random() * maxInserts + 1);
+
+				let inserts: ITreeElement<number>[] = [];
+				for (let i = 0; i < insertCount; i++) {
+					const element = elementCounter++;
+					inserts.push({ element, children: [] });
+				}
+
+				// move existing items
+				if (Math.random() < 0.5) {
+					const elements = list.slice(spliceIndex, spliceIndex + Math.floor(deleteCount / 2));
+					inserts.push(...elements.map(({ element }) => ({ element, children: [] })));
+				}
+
+				model.splice([spliceIndex], deleteCount, inserts, options);
+				expected.splice(spliceIndex, deleteCount, ...inserts.map(i => i.element));
+
+				const listElements = list.map(l => l.element);
+				changes.push(`splice(${spliceIndex}, ${deleteCount}, [${inserts.map(e => e.element).join(', ')}]) -> ${listElements.join(', ')}`);
+
+				assert.deepStrictEqual(expected, listElements, `Expected ${listElements.join(', ')} to equal ${expected.join(', ')}. Steps:\n\n${changes.join('\n')}`);
+			}
+		}
 	});
 
-	test('collapse should recursively adjust visible count', function () {
+	test('collapse should recursively adjust visible count', () => {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toList(list), -1);
 
@@ -395,7 +512,7 @@ suite('IndexTreeModel', function () {
 		assert.deepEqual(list[1].collapsed, false);
 	});
 
-	test('simple filter', function () {
+	test('simple filter', () => {
 		const list: ITreeNode<number>[] = [];
 		const filter = new class implements ITreeFilter<number> {
 			filter(element: number): TreeVisibility {
@@ -429,7 +546,7 @@ suite('IndexTreeModel', function () {
 		assert.deepEqual(toArray(list), [0, 2, 4, 6]);
 	});
 
-	test('recursive filter on initial model', function () {
+	test('recursive filter on initial model', () => {
 		const list: ITreeNode<number>[] = [];
 		const filter = new class implements ITreeFilter<number> {
 			filter(element: number): TreeVisibility {
@@ -451,7 +568,7 @@ suite('IndexTreeModel', function () {
 		assert.deepEqual(toArray(list), []);
 	});
 
-	test('refilter', function () {
+	test('refilter', () => {
 		const list: ITreeNode<number>[] = [];
 		let shouldFilter = false;
 		const filter = new class implements ITreeFilter<number> {
@@ -490,7 +607,7 @@ suite('IndexTreeModel', function () {
 		assert.deepEqual(toArray(list), [0, 1, 2, 3, 4, 5, 6, 7]);
 	});
 
-	test('recursive filter', function () {
+	test('recursive filter', () => {
 		const list: ITreeNode<string>[] = [];
 		let query = new RegExp('');
 		const filter = new class implements ITreeFilter<string> {
@@ -536,7 +653,7 @@ suite('IndexTreeModel', function () {
 		assert.deepEqual(toArray(list), ['vscode', '.build', 'github', 'build.js', 'build']);
 	});
 
-	test('recursive filter with collapse', function () {
+	test('recursive filter with collapse', () => {
 		const list: ITreeNode<string>[] = [];
 		let query = new RegExp('');
 		const filter = new class implements ITreeFilter<string> {
@@ -582,7 +699,7 @@ suite('IndexTreeModel', function () {
 		assert.deepEqual(toArray(list), ['vscode']);
 	});
 
-	test('recursive filter while collapsed', function () {
+	test('recursive filter while collapsed', () => {
 		const list: ITreeNode<string>[] = [];
 		let query = new RegExp('');
 		const filter = new class implements ITreeFilter<string> {
@@ -635,9 +752,9 @@ suite('IndexTreeModel', function () {
 		assert.deepEqual(list.length, 10);
 	});
 
-	suite('getNodeLocation', function () {
+	suite('getNodeLocation', () => {
 
-		test('simple', function () {
+		test('simple', () => {
 			const list: IIndexTreeNode<number>[] = [];
 			const model = new IndexTreeModel<number>('test', toList(list), -1);
 
@@ -661,7 +778,7 @@ suite('IndexTreeModel', function () {
 			assert.deepEqual(model.getNodeLocation(list[5]), [2]);
 		});
 
-		test('with filter', function () {
+		test('with filter', () => {
 			const list: IIndexTreeNode<number>[] = [];
 			const filter = new class implements ITreeFilter<number> {
 				filter(element: number): TreeVisibility {
@@ -692,7 +809,7 @@ suite('IndexTreeModel', function () {
 		});
 	});
 
-	test('refilter with filtered out nodes', function () {
+	test('refilter with filtered out nodes', () => {
 		const list: ITreeNode<string>[] = [];
 		let query = new RegExp('');
 		const filter = new class implements ITreeFilter<string> {
@@ -726,7 +843,7 @@ suite('IndexTreeModel', function () {
 		assert.deepEqual(toArray(list), ['platinum']);
 	});
 
-	test('explicit hidden nodes should have renderNodeCount == 0, issue #83211', function () {
+	test('explicit hidden nodes should have renderNodeCount == 0, issue #83211', () => {
 		const list: ITreeNode<string>[] = [];
 		let query = new RegExp('');
 		const filter = new class implements ITreeFilter<string> {

lib/vscode/src/vs/base/test/browser/ui/tree/objectTree.test.ts

@@ -59,30 +59,30 @@ suite('ObjectTree', function () {
 
 			const navigator = tree.navigate();
 
-			assert.equal(navigator.current(), null);
-			assert.equal(navigator.next(), 0);
-			assert.equal(navigator.current(), 0);
-			assert.equal(navigator.next(), 10);
-			assert.equal(navigator.current(), 10);
-			assert.equal(navigator.next(), 11);
-			assert.equal(navigator.current(), 11);
-			assert.equal(navigator.next(), 12);
-			assert.equal(navigator.current(), 12);
-			assert.equal(navigator.next(), 1);
-			assert.equal(navigator.current(), 1);
-			assert.equal(navigator.next(), 2);
-			assert.equal(navigator.current(), 2);
-			assert.equal(navigator.previous(), 1);
-			assert.equal(navigator.current(), 1);
-			assert.equal(navigator.previous(), 12);
-			assert.equal(navigator.previous(), 11);
-			assert.equal(navigator.previous(), 10);
-			assert.equal(navigator.previous(), 0);
-			assert.equal(navigator.previous(), null);
-			assert.equal(navigator.next(), 0);
-			assert.equal(navigator.next(), 10);
-			assert.equal(navigator.first(), 0);
-			assert.equal(navigator.last(), 2);
+			assert.strictEqual(navigator.current(), null);
+			assert.strictEqual(navigator.next(), 0);
+			assert.strictEqual(navigator.current(), 0);
+			assert.strictEqual(navigator.next(), 10);
+			assert.strictEqual(navigator.current(), 10);
+			assert.strictEqual(navigator.next(), 11);
+			assert.strictEqual(navigator.current(), 11);
+			assert.strictEqual(navigator.next(), 12);
+			assert.strictEqual(navigator.current(), 12);
+			assert.strictEqual(navigator.next(), 1);
+			assert.strictEqual(navigator.current(), 1);
+			assert.strictEqual(navigator.next(), 2);
+			assert.strictEqual(navigator.current(), 2);
+			assert.strictEqual(navigator.previous(), 1);
+			assert.strictEqual(navigator.current(), 1);
+			assert.strictEqual(navigator.previous(), 12);
+			assert.strictEqual(navigator.previous(), 11);
+			assert.strictEqual(navigator.previous(), 10);
+			assert.strictEqual(navigator.previous(), 0);
+			assert.strictEqual(navigator.previous(), null);
+			assert.strictEqual(navigator.next(), 0);
+			assert.strictEqual(navigator.next(), 10);
+			assert.strictEqual(navigator.first(), 0);
+			assert.strictEqual(navigator.last(), 2);
 		});
 
 		test('should skip collapsed nodes', () => {
@@ -100,18 +100,18 @@ suite('ObjectTree', function () {
 
 			const navigator = tree.navigate();
 
-			assert.equal(navigator.current(), null);
-			assert.equal(navigator.next(), 0);
-			assert.equal(navigator.next(), 1);
-			assert.equal(navigator.next(), 2);
-			assert.equal(navigator.next(), null);
-			assert.equal(navigator.previous(), 2);
-			assert.equal(navigator.previous(), 1);
-			assert.equal(navigator.previous(), 0);
-			assert.equal(navigator.previous(), null);
-			assert.equal(navigator.next(), 0);
-			assert.equal(navigator.first(), 0);
-			assert.equal(navigator.last(), 2);
+			assert.strictEqual(navigator.current(), null);
+			assert.strictEqual(navigator.next(), 0);
+			assert.strictEqual(navigator.next(), 1);
+			assert.strictEqual(navigator.next(), 2);
+			assert.strictEqual(navigator.next(), null);
+			assert.strictEqual(navigator.previous(), 2);
+			assert.strictEqual(navigator.previous(), 1);
+			assert.strictEqual(navigator.previous(), 0);
+			assert.strictEqual(navigator.previous(), null);
+			assert.strictEqual(navigator.next(), 0);
+			assert.strictEqual(navigator.first(), 0);
+			assert.strictEqual(navigator.last(), 2);
 		});
 
 		test('should skip filtered elements', () => {
@@ -131,21 +131,21 @@ suite('ObjectTree', function () {
 
 			const navigator = tree.navigate();
 
-			assert.equal(navigator.current(), null);
-			assert.equal(navigator.next(), 0);
-			assert.equal(navigator.next(), 10);
-			assert.equal(navigator.next(), 12);
-			assert.equal(navigator.next(), 2);
-			assert.equal(navigator.next(), null);
-			assert.equal(navigator.previous(), 2);
-			assert.equal(navigator.previous(), 12);
-			assert.equal(navigator.previous(), 10);
-			assert.equal(navigator.previous(), 0);
-			assert.equal(navigator.previous(), null);
-			assert.equal(navigator.next(), 0);
-			assert.equal(navigator.next(), 10);
-			assert.equal(navigator.first(), 0);
-			assert.equal(navigator.last(), 2);
+			assert.strictEqual(navigator.current(), null);
+			assert.strictEqual(navigator.next(), 0);
+			assert.strictEqual(navigator.next(), 10);
+			assert.strictEqual(navigator.next(), 12);
+			assert.strictEqual(navigator.next(), 2);
+			assert.strictEqual(navigator.next(), null);
+			assert.strictEqual(navigator.previous(), 2);
+			assert.strictEqual(navigator.previous(), 12);
+			assert.strictEqual(navigator.previous(), 10);
+			assert.strictEqual(navigator.previous(), 0);
+			assert.strictEqual(navigator.previous(), null);
+			assert.strictEqual(navigator.next(), 0);
+			assert.strictEqual(navigator.next(), 10);
+			assert.strictEqual(navigator.first(), 0);
+			assert.strictEqual(navigator.last(), 2);
 		});
 
 		test('should be able to start from node', () => {
@@ -163,20 +163,20 @@ suite('ObjectTree', function () {
 
 			const navigator = tree.navigate(1);
 
-			assert.equal(navigator.current(), 1);
-			assert.equal(navigator.next(), 2);
-			assert.equal(navigator.current(), 2);
-			assert.equal(navigator.previous(), 1);
-			assert.equal(navigator.current(), 1);
-			assert.equal(navigator.previous(), 12);
-			assert.equal(navigator.previous(), 11);
-			assert.equal(navigator.previous(), 10);
-			assert.equal(navigator.previous(), 0);
-			assert.equal(navigator.previous(), null);
-			assert.equal(navigator.next(), 0);
-			assert.equal(navigator.next(), 10);
-			assert.equal(navigator.first(), 0);
-			assert.equal(navigator.last(), 2);
+			assert.strictEqual(navigator.current(), 1);
+			assert.strictEqual(navigator.next(), 2);
+			assert.strictEqual(navigator.current(), 2);
+			assert.strictEqual(navigator.previous(), 1);
+			assert.strictEqual(navigator.current(), 1);
+			assert.strictEqual(navigator.previous(), 12);
+			assert.strictEqual(navigator.previous(), 11);
+			assert.strictEqual(navigator.previous(), 10);
+			assert.strictEqual(navigator.previous(), 0);
+			assert.strictEqual(navigator.previous(), null);
+			assert.strictEqual(navigator.next(), 0);
+			assert.strictEqual(navigator.next(), 10);
+			assert.strictEqual(navigator.first(), 0);
+			assert.strictEqual(navigator.last(), 2);
 		});
 	});
 
@@ -219,10 +219,10 @@ suite('ObjectTree', function () {
 	});
 });
 
-function toArray(list: NodeList): Node[] {
-	const result: Node[] = [];
-	list.forEach(node => result.push(node));
-	return result;
+function getRowsTextContent(container: HTMLElement): string[] {
+	const rows = [...container.querySelectorAll('.monaco-list-row')];
+	rows.sort((a, b) => parseInt(a.getAttribute('data-index')!) - parseInt(b.getAttribute('data-index')!));
+	return rows.map(row => row.querySelector('.monaco-tl-contents')!.textContent!);
 }
 
 suite('CompressibleObjectTree', function () {
@@ -254,8 +254,7 @@ suite('CompressibleObjectTree', function () {
 		const tree = new CompressibleObjectTree<number>('test', container, new Delegate(), [new Renderer()]);
 		tree.layout(200);
 
-		const rows = toArray(container.querySelectorAll('.monaco-tl-contents'));
-		assert.equal(rows.length, 0);
+		assert.strictEqual(getRowsTextContent(container).length, 0);
 	});
 
 	test('simple', function () {
@@ -278,8 +277,7 @@ suite('CompressibleObjectTree', function () {
 			{ element: 2 }
 		]);
 
-		const rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
-		assert.deepEqual(rows, ['0', '10', '11', '12', '1', '2']);
+		assert.deepStrictEqual(getRowsTextContent(container), ['0', '10', '11', '12', '1', '2']);
 	});
 
 	test('compressed', () => {
@@ -304,8 +302,7 @@ suite('CompressibleObjectTree', function () {
 			}
 		]);
 
-		let rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
-		assert.deepEqual(rows, ['1/11/111', '1111', '1112', '1113']);
+		assert.deepStrictEqual(getRowsTextContent(container), ['1/11/111', '1111', '1112', '1113']);
 
 		tree.setChildren(11, [
 			{ element: 111 },
@@ -313,30 +310,26 @@ suite('CompressibleObjectTree', function () {
 			{ element: 113 },
 		]);
 
-		rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
-		assert.deepEqual(rows, ['1/11', '111', '112', '113']);
+		assert.deepStrictEqual(getRowsTextContent(container), ['1/11', '111', '112', '113']);
 
 		tree.setChildren(113, [
 			{ element: 1131 }
 		]);
 
-		rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
-		assert.deepEqual(rows, ['1/11', '111', '112', '113/1131']);
+		assert.deepStrictEqual(getRowsTextContent(container), ['1/11', '111', '112', '113/1131']);
 
 		tree.setChildren(1131, [
 			{ element: 1132 }
 		]);
 
-		rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
-		assert.deepEqual(rows, ['1/11', '111', '112', '113/1131/1132']);
+		assert.deepStrictEqual(getRowsTextContent(container), ['1/11', '111', '112', '113/1131/1132']);
 
 		tree.setChildren(1131, [
 			{ element: 1132 },
 			{ element: 1133 },
 		]);
 
-		rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
-		assert.deepEqual(rows, ['1/11', '111', '112', '113/1131', '1132', '1133']);
+		assert.deepStrictEqual(getRowsTextContent(container), ['1/11', '111', '112', '113/1131', '1132', '1133']);
 	});
 
 	test('enableCompression', () => {
@@ -361,15 +354,12 @@ suite('CompressibleObjectTree', function () {
 			}
 		]);
 
-		let rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
-		assert.deepEqual(rows, ['1/11/111', '1111', '1112', '1113']);
+		assert.deepStrictEqual(getRowsTextContent(container), ['1/11/111', '1111', '1112', '1113']);
 
 		tree.updateOptions({ compressionEnabled: false });
-		rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
-		assert.deepEqual(rows, ['1', '11', '111', '1111', '1112', '1113']);
+		assert.deepStrictEqual(getRowsTextContent(container), ['1', '11', '111', '1111', '1112', '1113']);
 
 		tree.updateOptions({ compressionEnabled: true });
-		rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
-		assert.deepEqual(rows, ['1/11/111', '1111', '1112', '1113']);
+		assert.deepStrictEqual(getRowsTextContent(container), ['1/11/111', '1111', '1112', '1113']);
 	});
 });