tree: initial tests

src/vs/base/browser/ui/list/splice.ts

@@ -9,6 +9,10 @@ export interface ISpliceable<T> {
 	splice(start: number, deleteCount: number, elements: T[]): void;
 }
 
+export interface ISpreadSpliceable<T> {
+	splice(start: number, deleteCount: number, ...elements: T[]): void;
+}
+
 export class CombinedSpliceable<T> implements ISpliceable<T> {
 
 	constructor(private spliceables: ISpliceable<T>[]) { }

src/vs/base/browser/ui/list/test/treeModel.test.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { TreeModel, ITreeNode } from '../treeModel';
+
+suite('TreeModel2', () => {
+
+	test('ctor', () => {
+		const list = [] as ITreeNode<number>[];
+		const model = new TreeModel<number>(list);
+		assert(model);
+		assert.equal(list.length, 0);
+	});
+
+	test('insert', () => {
+		const list = [] as ITreeNode<number>[];
+		const model = new TreeModel<number>(list);
+
+		model.splice([0], 0, [
+			{ element: 0, children: [] },
+			{ element: 1, children: [] },
+			{ element: 2, children: [] }
+		]);
+
+		assert.deepEqual(list.length, 3);
+		assert.deepEqual(list[0].element, 0);
+		assert.deepEqual(list[0].children, []);
+		assert.deepEqual(list[0].depth, 1);
+		assert.deepEqual(list[1].element, 1);
+		assert.deepEqual(list[1].children, []);
+		assert.deepEqual(list[1].depth, 1);
+		assert.deepEqual(list[2].element, 2);
+		assert.deepEqual(list[2].children, []);
+		assert.deepEqual(list[2].depth, 1);
+	});
+
+	test('delete', () => {
+		const list = [] as ITreeNode<number>[];
+		const model = new TreeModel<number>(list);
+
+		model.splice([0], 0, [
+			{ element: 0, children: [] },
+			{ element: 1, children: [] },
+			{ element: 2, children: [] }
+		]);
+
+		model.splice([0], 3, []);
+
+		assert.equal(list.length, 0);
+	});
+});
\ No newline at end of file

src/vs/base/browser/ui/list/treeModel.ts

@@ -5,7 +5,7 @@
 
 'use strict';
 
-import { ISpliceable } from './splice';
+import { ISpreadSpliceable } from './splice';
 
 export interface ITreeElement<T> {
 	element: T;
@@ -14,7 +14,13 @@ export interface ITreeElement<T> {
 
 export type TreeLocation = number[];
 
-export class TreeNode<T> {
+export interface ITreeNode<T> {
+	readonly element: T;
+	readonly children: ITreeNode<T>[];
+	readonly depth: number;
+}
+
+export class TreeNode<T> implements ITreeNode<T> {
 
 	static createRoot<T>(): TreeNode<T> {
 		return new TreeNode<T>({ children: [], element: null }, 0);
@@ -77,7 +83,7 @@ export class TreeModel<T> {
 
 	private root = TreeNode.createRoot<T>();
 
-	constructor(private spliceable: ISpliceable<TreeNode<T>>) { }
+	constructor(private spliceable: ISpreadSpliceable<ITreeNode<T>>) { }
 
 	splice(start: TreeLocation, deleteCount: number, elements: ITreeElement<T>[]): void {
 		if (start.length === 0) {
@@ -87,7 +93,7 @@ export class TreeModel<T> {
 		const {node, listIndex} = this.findNode(start, this.root, 0);
 		const {listDeleteCount, listElements} = node.splice(start[start.length - 1], deleteCount, elements);
 
-		this.spliceable.splice(listIndex, listDeleteCount, listElements);
+		this.spliceable.splice(listIndex, listDeleteCount, ...listElements);
 	}
 
 	private findNode(location: TreeLocation, node: TreeNode<T>, listIndex: number): { node: TreeNode<T>; listIndex: number } {