Merge from vscode e1d3dd53d17fb1529a002e4d6fb066db0a0bd385 (#6460)

* Merge from vscode e1d3dd53d17fb1529a002e4d6fb066db0a0bd385

* fix servers icon

* fix tests

src/vs/base/test/browser/ui/grid/gridview.test.ts

@@ -107,19 +107,19 @@ suite('Gridview', function () {
 	test('simple layout', function () {
 		gridview.layout(800, 600);
 
-		const view1 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
+		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 });
 
-		const view2 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
+		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 });
 
-		const view3 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
+		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 });
@@ -128,7 +128,7 @@ suite('Gridview', function () {
 		assert.deepEqual(view3.size, [200, 400]);
 		assert.deepEqual(gridview.getViewSize([1, 1]), { width: 200, height: 400 });
 
-		const view4 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
+		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 });
@@ -139,7 +139,7 @@ suite('Gridview', function () {
 		assert.deepEqual(view4.size, [200, 200]);
 		assert.deepEqual(gridview.getViewSize([0, 0]), { width: 200, height: 200 });
 
-		const view5 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
+		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 });
@@ -156,30 +156,30 @@ suite('Gridview', function () {
 	test('simple layout with automatic size distribution', function () {
 		gridview.layout(800, 600);
 
-		const view1 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
+		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 });
 
-		const view2 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
+		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]);
 
-		const view3 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
+		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]);
 
-		const view4 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
+		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]);
 
-		const view5 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
+		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]);
@@ -190,13 +190,13 @@ suite('Gridview', function () {
 
 	test('addviews before layout call 1', function () {
 
-		const view1 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
+		const view1 = new TestView(50, Number.POSITIVE_INFINITY, 50, Number.POSITIVE_INFINITY);
 		gridview.addView(view1, 200, [0]);
 
-		const view2 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
+		const view2 = new TestView(50, Number.POSITIVE_INFINITY, 50, Number.POSITIVE_INFINITY);
 		gridview.addView(view2, 200, [0]);
 
-		const view3 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
+		const view3 = new TestView(50, Number.POSITIVE_INFINITY, 50, Number.POSITIVE_INFINITY);
 		gridview.addView(view3, 200, [1, 1]);
 
 		gridview.layout(800, 600);
@@ -207,14 +207,13 @@ suite('Gridview', function () {
 	});
 
 	test('addviews before layout call 2', function () {
-
-		const view1 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
+		const view1 = new TestView(50, Number.POSITIVE_INFINITY, 50, Number.POSITIVE_INFINITY);
 		gridview.addView(view1, 200, [0]);
 
-		const view2 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
+		const view2 = new TestView(50, Number.POSITIVE_INFINITY, 50, Number.POSITIVE_INFINITY);
 		gridview.addView(view2, 200, [0]);
 
-		const view3 = new TestView(50, Number.MAX_VALUE, 50, Number.MAX_VALUE);
+		const view3 = new TestView(50, Number.POSITIVE_INFINITY, 50, Number.POSITIVE_INFINITY);
 		gridview.addView(view3, 200, [0, 0]);
 
 		gridview.layout(800, 600);

src/vs/base/test/browser/ui/splitview/splitview.test.ts

@@ -196,8 +196,8 @@ suite('Splitview', () => {
 		splitview.resizeView(0, 70);
 
 		assert.equal(view1.size, 70, 'view1 is collapsed');
-		assert.equal(view2.size, 110, 'view2 is expanded');
-		assert.equal(view3.size, 20, 'view3 stays the same');
+		assert.equal(view2.size, 40, 'view2 stays the same');
+		assert.equal(view3.size, 90, 'view3 is stretched');
 
 		splitview.resizeView(2, 40);
 
@@ -474,10 +474,10 @@ 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, 66, 68]);
+		assert.deepEqual([view1.size, view2.size, view3.size], [66, 68, 66]);
 
 		splitview.layout(180);
-		assert.deepEqual([view1.size, view2.size, view3.size], [66, 46, 68]);
+		assert.deepEqual([view1.size, view2.size, view3.size], [66, 48, 66]);
 
 		splitview.layout(124);
 		assert.deepEqual([view1.size, view2.size, view3.size], [66, 20, 38]);
@@ -504,13 +504,13 @@ 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, 66, 68]);
+		assert.deepEqual([view1.size, view2.size, view3.size], [66, 68, 66]);
 
 		splitview.layout(180);
-		assert.deepEqual([view1.size, view2.size, view3.size], [66, 46, 68]);
+		assert.deepEqual([view1.size, view2.size, view3.size], [66, 48, 66]);
 
 		splitview.layout(132);
-		assert.deepEqual([view1.size, view2.size, view3.size], [44, 20, 68]);
+		assert.deepEqual([view1.size, view2.size, view3.size], [46, 20, 66]);
 
 		splitview.layout(60);
 		assert.deepEqual([view1.size, view2.size, view3.size], [20, 20, 20]);

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

@@ -0,0 +1,430 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { compress, ICompressedTreeElement, ICompressedTreeNode, decompress, CompressedObjectTreeModel } from 'vs/base/browser/ui/tree/compressedObjectTreeModel';
+import { Iterator } from 'vs/base/common/iterator';
+import { ITreeNode } from 'vs/base/browser/ui/tree/tree';
+import { ISpliceable } from 'vs/base/common/sequence';
+
+interface IResolvedCompressedTreeElement<T> extends ICompressedTreeElement<T> {
+	readonly element: T;
+	readonly children?: ICompressedTreeElement<T>[];
+}
+
+function resolve<T>(treeElement: ICompressedTreeElement<T>): IResolvedCompressedTreeElement<T> {
+	const result: any = { element: treeElement.element };
+	const children = Iterator.collect(Iterator.map(Iterator.from(treeElement.children), resolve));
+
+	if (treeElement.incompressible) {
+		result.incompressible = true;
+	}
+
+	if (children.length > 0) {
+		result.children = children;
+	}
+
+	return result;
+}
+
+suite('CompressedObjectTree', function () {
+
+	suite('compress & decompress', function () {
+
+		test('small', function () {
+			const decompressed: ICompressedTreeElement<number> = { element: 1 };
+			const compressed: IResolvedCompressedTreeElement<ICompressedTreeNode<number>> =
+				{ element: { elements: [1], incompressible: false } };
+
+			assert.deepEqual(resolve(compress(decompressed)), compressed);
+			assert.deepEqual(resolve(decompress(compressed)), decompressed);
+		});
+
+		test('no compression', function () {
+			const decompressed: ICompressedTreeElement<number> = {
+				element: 1, children: [
+					{ element: 11 },
+					{ element: 12 },
+					{ element: 13 }
+				]
+			};
+
+			const compressed: IResolvedCompressedTreeElement<ICompressedTreeNode<number>> = {
+				element: { elements: [1], incompressible: false },
+				children: [
+					{ element: { elements: [11], incompressible: false } },
+					{ element: { elements: [12], incompressible: false } },
+					{ element: { elements: [13], incompressible: false } }
+				]
+			};
+
+			assert.deepEqual(resolve(compress(decompressed)), compressed);
+			assert.deepEqual(resolve(decompress(compressed)), decompressed);
+		});
+
+		test('single hierarchy', function () {
+			const decompressed: ICompressedTreeElement<number> = {
+				element: 1, children: [
+					{
+						element: 11, children: [
+							{
+								element: 111, children: [
+									{ element: 1111 }
+								]
+							}
+						]
+					}
+				]
+			};
+
+			const compressed: IResolvedCompressedTreeElement<ICompressedTreeNode<number>> = {
+				element: { elements: [1, 11, 111, 1111], incompressible: false }
+			};
+
+			assert.deepEqual(resolve(compress(decompressed)), compressed);
+			assert.deepEqual(resolve(decompress(compressed)), decompressed);
+		});
+
+		test('deep compression', function () {
+			const decompressed: ICompressedTreeElement<number> = {
+				element: 1, children: [
+					{
+						element: 11, children: [
+							{
+								element: 111, children: [
+									{ element: 1111 },
+									{ element: 1112 },
+									{ element: 1113 },
+									{ element: 1114 },
+								]
+							}
+						]
+					}
+				]
+			};
+
+			const compressed: IResolvedCompressedTreeElement<ICompressedTreeNode<number>> = {
+				element: { elements: [1, 11, 111], incompressible: false },
+				children: [
+					{ element: { elements: [1111], incompressible: false } },
+					{ element: { elements: [1112], incompressible: false } },
+					{ element: { elements: [1113], incompressible: false } },
+					{ element: { elements: [1114], incompressible: false } },
+				]
+			};
+
+			assert.deepEqual(resolve(compress(decompressed)), compressed);
+			assert.deepEqual(resolve(decompress(compressed)), decompressed);
+		});
+
+		test('double deep compression', function () {
+			const decompressed: ICompressedTreeElement<number> = {
+				element: 1, children: [
+					{
+						element: 11, children: [
+							{
+								element: 111, children: [
+									{ element: 1112 },
+									{ element: 1113 },
+								]
+							}
+						]
+					},
+					{
+						element: 12, children: [
+							{
+								element: 121, children: [
+									{ element: 1212 },
+									{ element: 1213 },
+								]
+							}
+						]
+					}
+				]
+			};
+
+			const compressed: IResolvedCompressedTreeElement<ICompressedTreeNode<number>> = {
+				element: { elements: [1], incompressible: false },
+				children: [
+					{
+						element: { elements: [11, 111], incompressible: false },
+						children: [
+							{ element: { elements: [1112], incompressible: false } },
+							{ element: { elements: [1113], incompressible: false } },
+						]
+					},
+					{
+						element: { elements: [12, 121], incompressible: false },
+						children: [
+							{ element: { elements: [1212], incompressible: false } },
+							{ element: { elements: [1213], incompressible: false } },
+						]
+					}
+				]
+			};
+
+			assert.deepEqual(resolve(compress(decompressed)), compressed);
+			assert.deepEqual(resolve(decompress(compressed)), decompressed);
+		});
+
+		test('incompressible leaf', function () {
+			const decompressed: ICompressedTreeElement<number> = {
+				element: 1, children: [
+					{
+						element: 11, children: [
+							{
+								element: 111, children: [
+									{ element: 1111, incompressible: true }
+								]
+							}
+						]
+					}
+				]
+			};
+
+			const compressed: IResolvedCompressedTreeElement<ICompressedTreeNode<number>> = {
+				element: { elements: [1, 11, 111], incompressible: false },
+				children: [
+					{ element: { elements: [1111], incompressible: true } }
+				]
+			};
+
+			assert.deepEqual(resolve(compress(decompressed)), compressed);
+			assert.deepEqual(resolve(decompress(compressed)), decompressed);
+		});
+
+		test('incompressible branch', function () {
+			const decompressed: ICompressedTreeElement<number> = {
+				element: 1, children: [
+					{
+						element: 11, children: [
+							{
+								element: 111, incompressible: true, children: [
+									{ element: 1111 }
+								]
+							}
+						]
+					}
+				]
+			};
+
+			const compressed: IResolvedCompressedTreeElement<ICompressedTreeNode<number>> = {
+				element: { elements: [1, 11], incompressible: false },
+				children: [
+					{ element: { elements: [111, 1111], incompressible: true } }
+				]
+			};
+
+			assert.deepEqual(resolve(compress(decompressed)), compressed);
+			assert.deepEqual(resolve(decompress(compressed)), decompressed);
+		});
+
+		test('incompressible chain', function () {
+			const decompressed: ICompressedTreeElement<number> = {
+				element: 1, children: [
+					{
+						element: 11, children: [
+							{
+								element: 111, incompressible: true, children: [
+									{ element: 1111, incompressible: true }
+								]
+							}
+						]
+					}
+				]
+			};
+
+			const compressed: IResolvedCompressedTreeElement<ICompressedTreeNode<number>> = {
+				element: { elements: [1, 11], incompressible: false },
+				children: [
+					{
+						element: { elements: [111], incompressible: true },
+						children: [
+							{ element: { elements: [1111], incompressible: true } }
+						]
+					}
+				]
+			};
+
+			assert.deepEqual(resolve(compress(decompressed)), compressed);
+			assert.deepEqual(resolve(decompress(compressed)), decompressed);
+		});
+
+		test('incompressible tree', function () {
+			const decompressed: ICompressedTreeElement<number> = {
+				element: 1, children: [
+					{
+						element: 11, incompressible: true, children: [
+							{
+								element: 111, incompressible: true, children: [
+									{ element: 1111, incompressible: true }
+								]
+							}
+						]
+					}
+				]
+			};
+
+			const compressed: IResolvedCompressedTreeElement<ICompressedTreeNode<number>> = {
+				element: { elements: [1], incompressible: false },
+				children: [
+					{
+						element: { elements: [11], incompressible: true },
+						children: [
+							{
+								element: { elements: [111], incompressible: true },
+								children: [
+									{ element: { elements: [1111], incompressible: true } }
+								]
+							}
+						]
+					}
+				]
+			};
+
+			assert.deepEqual(resolve(compress(decompressed)), compressed);
+			assert.deepEqual(resolve(decompress(compressed)), decompressed);
+		});
+	});
+
+	function toSpliceable<T>(arr: T[]): ISpliceable<T> {
+		return {
+			splice(start: number, deleteCount: number, elements: T[]): void {
+				arr.splice(start, deleteCount, ...elements);
+			}
+		};
+	}
+
+	function toArray<T>(list: ITreeNode<ICompressedTreeNode<T>>[]): T[][] {
+		return list.map(i => i.element.elements);
+	}
+
+	suite('CompressedObjectTreeModel', function () {
+
+		test('ctor', () => {
+			const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
+			const model = new CompressedObjectTreeModel<number>(toSpliceable(list));
+			assert(model);
+			assert.equal(list.length, 0);
+			assert.equal(model.size, 0);
+		});
+
+		test('flat', () => {
+			const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
+			const model = new CompressedObjectTreeModel<number>(toSpliceable(list));
+
+			model.setChildren(null, Iterator.fromArray([
+				{ element: 0 },
+				{ element: 1 },
+				{ element: 2 }
+			]));
+
+			assert.deepEqual(toArray(list), [[0], [1], [2]]);
+			assert.equal(model.size, 3);
+
+			model.setChildren(null, Iterator.fromArray([
+				{ element: 3 },
+				{ element: 4 },
+				{ element: 5 },
+			]));
+
+			assert.deepEqual(toArray(list), [[3], [4], [5]]);
+			assert.equal(model.size, 3);
+
+			model.setChildren(null, Iterator.empty());
+			assert.deepEqual(toArray(list), []);
+			assert.equal(model.size, 0);
+		});
+
+		test('nested', () => {
+			const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
+			const model = new CompressedObjectTreeModel<number>(toSpliceable(list));
+
+			model.setChildren(null, Iterator.fromArray([
+				{
+					element: 0, children: Iterator.fromArray([
+						{ element: 10 },
+						{ element: 11 },
+						{ element: 12 },
+					])
+				},
+				{ element: 1 },
+				{ element: 2 }
+			]));
+
+			assert.deepEqual(toArray(list), [[0], [10], [11], [12], [1], [2]]);
+			assert.equal(model.size, 6);
+
+			model.setChildren(12, Iterator.fromArray([
+				{ element: 120 },
+				{ element: 121 }
+			]));
+
+			assert.deepEqual(toArray(list), [[0], [10], [11], [12], [120], [121], [1], [2]]);
+			assert.equal(model.size, 8);
+
+			model.setChildren(0, Iterator.empty());
+			assert.deepEqual(toArray(list), [[0], [1], [2]]);
+			assert.equal(model.size, 3);
+
+			model.setChildren(null, Iterator.empty());
+			assert.deepEqual(toArray(list), []);
+			assert.equal(model.size, 0);
+		});
+
+		test('compressed', () => {
+			const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
+			const model = new CompressedObjectTreeModel<number>(toSpliceable(list));
+
+			model.setChildren(null, Iterator.fromArray([
+				{
+					element: 1, children: Iterator.fromArray([{
+						element: 11, children: Iterator.fromArray([{
+							element: 111, children: Iterator.fromArray([
+								{ element: 1111 },
+								{ element: 1112 },
+								{ element: 1113 },
+							])
+						}])
+					}])
+				}
+			]));
+
+			assert.deepEqual(toArray(list), [[1, 11, 111], [1111], [1112], [1113]]);
+			assert.equal(model.size, 6);
+
+			model.setChildren(11, Iterator.fromArray([
+				{ element: 111 },
+				{ element: 112 },
+				{ element: 113 },
+			]));
+
+			assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113]]);
+			assert.equal(model.size, 5);
+
+			model.setChildren(113, Iterator.fromArray([
+				{ element: 1131 }
+			]));
+
+			assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113, 1131]]);
+			assert.equal(model.size, 6);
+
+			model.setChildren(1131, Iterator.fromArray([
+				{ element: 1132 }
+			]));
+
+			assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113, 1131, 1132]]);
+			assert.equal(model.size, 7);
+
+			model.setChildren(1131, Iterator.fromArray([
+				{ element: 1132 },
+				{ element: 1133 },
+			]));
+
+			assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113, 1131], [1132], [1133]]);
+			assert.equal(model.size, 8);
+		});
+	});
+});

src/vs/base/test/common/iterator.test.ts

@@ -0,0 +1,19 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { Iterator } from 'vs/base/common/iterator';
+
+suite('Iterator', () => {
+	test('concat', () => {
+		const first = Iterator.fromArray([1, 2, 3]);
+		const second = Iterator.fromArray([4, 5, 6]);
+		const third = Iterator.fromArray([7, 8, 9]);
+		const actualIterator = Iterator.concat(first, second, third);
+		const actual = Iterator.collect(actualIterator);
+
+		assert.deepEqual(actual, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
+	});
+});