Initial VS Code 1.19 source merge (#571)

* Initial 1.19 xcopy

* Fix yarn build

* Fix numerous build breaks

* Next batch of build break fixes

* More build break fixes

* Runtime breaks

* Additional post merge fixes

* Fix windows setup file

* Fix test failures.

* Update license header blocks to refer to source eula

src/vs/base/test/browser/builder.test.ts

@@ -5,7 +5,7 @@
 'use strict';
 
 import * as assert from 'assert';
-import { Build, Builder, MultiBuilder, Binding, Dimension, Position, Box, $ } from 'vs/base/browser/builder';
+import { Build, Builder, MultiBuilder, $, bindElement, withElement, setPropertyOnElement, getPropertyFromElement } from 'vs/base/browser/builder';
 import * as Types from 'vs/base/common/types';
 import * as DomUtils from 'vs/base/browser/dom';
 import { TPromise } from 'vs/base/common/winjs.base';
@@ -22,7 +22,7 @@ let withElementsBySelector = function (selector: string, offdom: boolean = false
 	return new MultiBuilder(builders);
 };
 
-let withBuilder = function (builder, offdom) {
+let withBuilder = function (builder: Builder, offdom: boolean) {
 	if (builder instanceof MultiBuilder) {
 		return new MultiBuilder(builder);
 	}
@@ -30,24 +30,20 @@ let withBuilder = function (builder, offdom) {
 	return new Builder(builder.getHTMLElement(), offdom);
 };
 
+function select(builder: Builder, selector: string, offdom?: boolean): MultiBuilder {
+	let elements = builder.getHTMLElement().querySelectorAll(selector);
+
+	let builders: Builder[] = [];
+	for (let i = 0; i < elements.length; i++) {
+		builders.push(withElement(<HTMLElement>elements.item(i), offdom));
+	}
+
+	return new MultiBuilder(builders);
+}
+
 suite('Builder', () => {
-	let fixture: HTMLElement;
-	let fixtureId = 'builder-fixture';
 
-	setup(() => {
-		fixture = document.createElement('div');
-		fixture.id = fixtureId;
-		document.body.appendChild(fixture);
+	test('Binding', function () {
 	});
 
-	teardown(() => {
-		document.body.removeChild(fixture);
-	});
-
-	test('Dimension.substract()', function () {
-		// let d1 = new Dimension(200, 100);
-		// let d2 = new Box(10, 20, 30, 40);
-
-		// assert.deepEqual(d1.substract(d2), new Dimension(140, 60));
-	});
-});
+});

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

@@ -10,15 +10,5 @@ const $ = dom.$;
 
 suite('dom', () => {
 	test('hasClass', () => {
-
-		// let element = document.createElement('div');
-		// element.className = 'foobar boo far';
-
-		// assert(dom.hasClass(element, 'foobar'));
-		// assert(dom.hasClass(element, 'boo'));
-		// assert(dom.hasClass(element, 'far'));
-		// assert(!dom.hasClass(element, 'bar'));
-		// assert(!dom.hasClass(element, 'foo'));
-		// assert(!dom.hasClass(element, ''));
 	});
 });

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

@@ -18,11 +18,11 @@ suite('RangeMap', () => {
 	});
 
 	test('intersection', () => {
-		assert.deepEqual(intersect({ start: 0, end: 0 }, { start: 0, end: 0 }), null);
-		assert.deepEqual(intersect({ start: 0, end: 0 }, { start: 5, end: 5 }), null);
-		assert.deepEqual(intersect({ start: 0, end: 1 }, { start: 5, end: 6 }), null);
-		assert.deepEqual(intersect({ start: 5, end: 6 }, { start: 0, end: 1 }), null);
-		assert.deepEqual(intersect({ start: 0, end: 5 }, { start: 2, end: 2 }), null);
+		assert.deepEqual(intersect({ start: 0, end: 0 }, { start: 0, end: 0 }), { start: 0, end: 0 });
+		assert.deepEqual(intersect({ start: 0, end: 0 }, { start: 5, end: 5 }), { start: 0, end: 0 });
+		assert.deepEqual(intersect({ start: 0, end: 1 }, { start: 5, end: 6 }), { start: 0, end: 0 });
+		assert.deepEqual(intersect({ start: 5, end: 6 }, { start: 0, end: 1 }), { start: 0, end: 0 });
+		assert.deepEqual(intersect({ start: 0, end: 5 }, { start: 2, end: 2 }), { start: 0, end: 0 });
 		assert.deepEqual(intersect({ start: 0, end: 1 }, { start: 0, end: 1 }), { start: 0, end: 1 });
 		assert.deepEqual(intersect({ start: 0, end: 10 }, { start: 0, end: 5 }), { start: 0, end: 5 });
 		assert.deepEqual(intersect({ start: 0, end: 5 }, { start: 0, end: 10 }), { start: 0, end: 5 });

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

@@ -21,7 +21,6 @@ suite('ScrollbarState', () => {
 		assert.equal(actual.isNeeded(), true);
 		assert.equal(actual.getSliderSize(), 20);
 		assert.equal(actual.getSliderPosition(), 249);
-		assert.equal(actual.getSliderCenter(), 259);
 
 
 		assert.equal(actual.getDesiredScrollPositionFromOffset(259), 32849);
@@ -33,7 +32,6 @@ suite('ScrollbarState', () => {
 		assert.equal(actual.isNeeded(), true);
 		assert.equal(actual.getSliderSize(), 20);
 		assert.equal(actual.getSliderPosition(), 249);
-		assert.equal(actual.getSliderCenter(), 259);
 	});
 
 	test('inflates slider size with arrows', () => {
@@ -49,7 +47,6 @@ suite('ScrollbarState', () => {
 		assert.equal(actual.isNeeded(), true);
 		assert.equal(actual.getSliderSize(), 20);
 		assert.equal(actual.getSliderPosition(), 230);
-		assert.equal(actual.getSliderCenter(), 240);
 
 
 		assert.equal(actual.getDesiredScrollPositionFromOffset(240 + 12), 32811);
@@ -61,6 +58,5 @@ suite('ScrollbarState', () => {
 		assert.equal(actual.isNeeded(), true);
 		assert.equal(actual.getSliderSize(), 20);
 		assert.equal(actual.getSliderPosition(), 230);
-		assert.equal(actual.getSliderCenter(), 240);
 	});
 });

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

@@ -78,4 +78,217 @@ suite('Splitview', () => {
 
 	test('empty splitview has empty DOM', () => {
 	});
+
+	test('calls view methods on addView and removeView', () => {
+		const view = new TestView(20, 20);
+		const splitview = new SplitView(container);
+
+		let didLayout = false;
+		const layoutDisposable = view.onDidLayout(() => didLayout = true);
+
+		let didRender = false;
+		const renderDisposable = view.onDidRender(() => didRender = true);
+
+		splitview.addView(view, 20);
+
+		assert.equal(view.size, 20, 'view has right size');
+		assert(didLayout, 'layout is called');
+		assert(didLayout, 'render is called');
+
+		splitview.dispose();
+		layoutDisposable.dispose();
+		renderDisposable.dispose();
+		view.dispose();
+	});
+
+	test('stretches view to viewport', () => {
+		const view = new TestView(20, Number.POSITIVE_INFINITY);
+		const splitview = new SplitView(container);
+		splitview.layout(200);
+
+		splitview.addView(view, 20);
+		assert.equal(view.size, 200, 'view is stretched');
+
+		splitview.layout(200);
+		assert.equal(view.size, 200, 'view stayed the same');
+
+		splitview.layout(100);
+		assert.equal(view.size, 100, 'view is collapsed');
+
+		splitview.layout(20);
+		assert.equal(view.size, 20, 'view is collapsed');
+
+		splitview.layout(10);
+		assert.equal(view.size, 20, 'view is clamped');
+
+		splitview.layout(200);
+		assert.equal(view.size, 200, 'view is stretched');
+
+		splitview.dispose();
+		view.dispose();
+	});
+
+	test('can resize views', () => {
+		const view1 = new TestView(20, Number.POSITIVE_INFINITY);
+		const view2 = new TestView(20, Number.POSITIVE_INFINITY);
+		const view3 = new TestView(20, Number.POSITIVE_INFINITY);
+		const splitview = new SplitView(container);
+		splitview.layout(200);
+
+		splitview.addView(view1, 20);
+		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');
+
+		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');
+
+		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');
+
+		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');
+
+		splitview.dispose();
+		view3.dispose();
+		view2.dispose();
+		view1.dispose();
+	});
+
+	test('reacts to view changes', () => {
+		const view1 = new TestView(20, Number.POSITIVE_INFINITY);
+		const view2 = new TestView(20, Number.POSITIVE_INFINITY);
+		const view3 = new TestView(20, Number.POSITIVE_INFINITY);
+		const splitview = new SplitView(container);
+		splitview.layout(200);
+
+		splitview.addView(view1, 20);
+		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');
+
+		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');
+
+		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');
+
+		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');
+
+		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');
+
+		splitview.dispose();
+		view3.dispose();
+		view2.dispose();
+		view1.dispose();
+	});
+
+	test('sashes are properly enabled/disabled', () => {
+		const view1 = new TestView(20, Number.POSITIVE_INFINITY);
+		const view2 = new TestView(20, Number.POSITIVE_INFINITY);
+		const view3 = new TestView(20, Number.POSITIVE_INFINITY);
+		const splitview = new SplitView(container);
+		splitview.layout(200);
+
+		splitview.addView(view1, 20);
+		splitview.addView(view2, 20);
+		splitview.addView(view3, 20);
+
+		let sashes = getSashes(splitview);
+		assert.equal(sashes.length, 2, 'there are two sashes');
+		assert.equal(sashes[0].enabled, true, 'first sash is enabled');
+		assert.equal(sashes[1].enabled, true, 'second sash is enabled');
+
+		splitview.layout(60);
+		assert.equal(sashes[0].enabled, false, 'first sash is disabled');
+		assert.equal(sashes[1].enabled, false, 'second sash is disabled');
+
+		splitview.layout(20);
+		assert.equal(sashes[0].enabled, false, 'first sash is disabled');
+		assert.equal(sashes[1].enabled, false, 'second sash is disabled');
+
+		splitview.layout(200);
+		assert.equal(sashes[0].enabled, true, 'first sash is enabled');
+		assert.equal(sashes[1].enabled, true, 'second sash is enabled');
+
+		view1.maximumSize = 20;
+		assert.equal(sashes[0].enabled, false, 'first sash is disabled');
+		assert.equal(sashes[1].enabled, true, 'second sash is enabled');
+
+		view2.maximumSize = 20;
+		assert.equal(sashes[0].enabled, false, 'first sash is disabled');
+		assert.equal(sashes[1].enabled, false, 'second sash is disabled');
+
+		view1.maximumSize = 300;
+		assert.equal(sashes[0].enabled, true, 'first sash is enabled');
+		assert.equal(sashes[1].enabled, true, 'second sash is enabled');
+
+		view2.maximumSize = 200;
+		assert.equal(sashes[0].enabled, true, 'first sash is enabled');
+		assert.equal(sashes[1].enabled, true, 'second sash is enabled');
+
+		splitview.dispose();
+		view3.dispose();
+		view2.dispose();
+		view1.dispose();
+	});
+
+	test('issue #35497', () => {
+		const view1 = new TestView(160, Number.POSITIVE_INFINITY);
+		const view2 = new TestView(66, 66);
+
+		const splitview = new SplitView(container);
+		splitview.layout(986);
+
+		splitview.addView(view1, 142, 0);
+		assert.equal(view1.size, 986, 'first view is stretched');
+
+		view2.onDidRender(() => {
+			assert.throws(() => splitview.resizeView(1, 922));
+			assert.throws(() => splitview.resizeView(1, 922));
+		});
+
+		splitview.addView(view2, 66, 0);
+		assert.equal(view2.size, 66, 'second view is fixed');
+		assert.equal(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');
+
+		splitview.dispose();
+		view2.dispose();
+		view1.dispose();
+	});
 });

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

@@ -1,78 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-'use strict';
-
-import * as assert from 'assert';
-import { Action, IAction, isAction } from 'vs/base/common/actions';
-
-suite('Actions', () => {
-	test('isAction', function () {
-		assert(isAction(new Action('id', 'label', 'style', true, function () { return null; })));
-		assert(isAction(<IAction>{
-			id: 'id',
-			label: 'label',
-			class: 'style',
-			checked: true,
-			enabled: true,
-			run: function () { return null; }
-		}));
-
-		assert(!isAction({
-			//		id: 'id',
-			label: 'label',
-			class: 'style',
-			checked: true,
-			enabled: true,
-			run: function () { return null; }
-		}));
-		assert(!isAction({
-			id: 1234,
-			label: 'label',
-			class: 'style',
-			checked: true,
-			enabled: true,
-			run: function () { return null; }
-		}));
-		assert(!isAction({
-			id: 'id',
-			label: 'label',
-			class: 'style',
-			checked: 1,
-			enabled: 1,
-			run: function () { return null; }
-		}));
-		assert(!isAction(null));
-		assert(!isAction({
-			id: 'id',
-			label: 'label',
-			//		class: 'style',
-			checked: true,
-			enabled: true,
-			//		run: function() { return null; }
-		}));
-		assert(!isAction({
-			id: 'id',
-			label: 42,
-			class: 'style',
-			checked: true,
-			enabled: true,
-		}));
-		assert(!isAction({
-			id: 'id',
-			label: 'label',
-			class: 'style',
-			checked: 'checked',
-			enabled: true,
-		}));
-		assert(!isAction({
-			id: 'id',
-			label: 'label',
-			class: 'style',
-			checked: true,
-			enabled: true,
-			run: true
-		}));
-	});
-});

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

@@ -102,12 +102,12 @@ suite('Arrays', () => {
 
 		let d = arrays.sortedDiff([1, 2, 4], [], compare);
 		assert.deepEqual(d, [
-			{ start: 0, deleteCount: 3, inserted: [] }
+			{ start: 0, deleteCount: 3, toInsert: [] }
 		]);
 
 		d = arrays.sortedDiff([], [1, 2, 4], compare);
 		assert.deepEqual(d, [
-			{ start: 0, deleteCount: 0, inserted: [1, 2, 4] }
+			{ start: 0, deleteCount: 0, toInsert: [1, 2, 4] }
 		]);
 
 		d = arrays.sortedDiff([1, 2, 4], [1, 2, 4], compare);
@@ -115,27 +115,27 @@ suite('Arrays', () => {
 
 		d = arrays.sortedDiff([1, 2, 4], [2, 3, 4, 5], compare);
 		assert.deepEqual(d, [
-			{ start: 0, deleteCount: 1, inserted: [] },
-			{ start: 2, deleteCount: 0, inserted: [3] },
-			{ start: 3, deleteCount: 0, inserted: [5] },
+			{ start: 0, deleteCount: 1, toInsert: [] },
+			{ start: 2, deleteCount: 0, toInsert: [3] },
+			{ start: 3, deleteCount: 0, toInsert: [5] },
 		]);
 
 		d = arrays.sortedDiff([2, 3, 4, 5], [1, 2, 4], compare);
 		assert.deepEqual(d, [
-			{ start: 0, deleteCount: 0, inserted: [1] },
-			{ start: 1, deleteCount: 1, inserted: [] },
-			{ start: 3, deleteCount: 1, inserted: [] },
+			{ start: 0, deleteCount: 0, toInsert: [1] },
+			{ start: 1, deleteCount: 1, toInsert: [] },
+			{ start: 3, deleteCount: 1, toInsert: [] },
 		]);
 
 		d = arrays.sortedDiff([1, 3, 5, 7], [5, 9, 11], compare);
 		assert.deepEqual(d, [
-			{ start: 0, deleteCount: 2, inserted: [] },
-			{ start: 3, deleteCount: 1, inserted: [9, 11] }
+			{ start: 0, deleteCount: 2, toInsert: [] },
+			{ start: 3, deleteCount: 1, toInsert: [9, 11] }
 		]);
 
 		d = arrays.sortedDiff([1, 3, 7], [5, 9, 11], compare);
 		assert.deepEqual(d, [
-			{ start: 0, deleteCount: 3, inserted: [5, 9, 11] }
+			{ start: 0, deleteCount: 3, toInsert: [5, 9, 11] }
 		]);
 	});
 
@@ -202,7 +202,7 @@ suite('Arrays', () => {
 	});
 
 	test('top', function () {
-		const cmp = (a, b) => {
+		const cmp = (a: number, b: number) => {
 			assert.strictEqual(typeof a, 'number', 'typeof a');
 			assert.strictEqual(typeof b, 'number', 'typeof b');
 			return a - b;
@@ -218,7 +218,7 @@ suite('Arrays', () => {
 	});
 
 	test('topAsync', function (done) {
-		const cmp = (a, b) => {
+		const cmp = (a: number, b: number) => {
 			assert.strictEqual(typeof a, 'number', 'typeof a');
 			assert.strictEqual(typeof b, 'number', 'typeof b');
 			return a - b;

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

@@ -23,7 +23,7 @@ suite('Assert', () => {
 
 		assert.throws(function () {
 			ok(null, 'Foo Bar');
-		}, function (e) {
+		}, function (e: Error) {
 			return e.message.indexOf('Foo Bar') >= 0;
 		});
 

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

@@ -472,7 +472,7 @@ suite('Async', () => {
 	test('Queue - order is kept', function (done) {
 		let queue = new Async.Queue();
 
-		let res = [];
+		let res: number[] = [];
 
 		let f1 = () => TPromise.as(true).then(() => res.push(1));
 		let f2 = () => TPromise.timeout(10).then(() => res.push(2));
@@ -498,7 +498,7 @@ suite('Async', () => {
 	test('Queue - errors bubble individually but not cause stop', function (done) {
 		let queue = new Async.Queue();
 
-		let res = [];
+		let res: number[] = [];
 		let error = false;
 
 		let f1 = () => TPromise.as(true).then(() => res.push(1));
@@ -525,7 +525,7 @@ suite('Async', () => {
 	test('Queue - order is kept (chained)', function (done) {
 		let queue = new Async.Queue();
 
-		let res = [];
+		let res: number[] = [];
 
 		let f1 = () => TPromise.as(true).then(() => res.push(1));
 		let f2 = () => TPromise.timeout(10).then(() => res.push(2));
@@ -560,7 +560,7 @@ suite('Async', () => {
 			done();
 		});
 
-		let res = [];
+		let res: number[] = [];
 
 		let f1 = () => TPromise.timeout(10).then(() => res.push(2));
 		let f2 = () => TPromise.timeout(20).then(() => res.push(4));
@@ -595,4 +595,29 @@ suite('Async', () => {
 		const r1Queue2 = queue.queueFor(URI.file('/some/path'));
 		assert.notEqual(r1Queue, r1Queue2); // previous one got disposed after finishing
 	});
+
+	test('ThrottledEmitter', function () {
+		const emitter = new Async.ThrottledEmitter();
+
+		const fnThatEmitsEvent = () => {
+			emitter.fire();
+		};
+
+		const promiseFn = TPromise.timeout(0).then(() => {
+			fnThatEmitsEvent();
+			fnThatEmitsEvent();
+			fnThatEmitsEvent();
+		});
+
+		let count = 0;
+		emitter.event(() => {
+			count++;
+		});
+
+		emitter.throttle(promiseFn);
+
+		promiseFn.then(() => {
+			assert.equal(count, 1);
+		});
+	});
 });

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

@@ -153,6 +153,7 @@ suite('Color', () => {
 			assert.deepEqual(HSVA.toRGBA(new HSVA(300, 1, 0.502, 1)), new RGBA(128, 0, 128, 1));
 			assert.deepEqual(HSVA.toRGBA(new HSVA(180, 1, 0.502, 1)), new RGBA(0, 128, 128, 1));
 			assert.deepEqual(HSVA.toRGBA(new HSVA(240, 1, 0.502, 1)), new RGBA(0, 0, 128, 1));
+
 		});
 
 		test('HSVA.fromRGBA', () => {
@@ -185,6 +186,11 @@ suite('Color', () => {
 			assert.deepEqual(new Color(new HSVA(10, 0, 0, 0)).rgba, new Color(new HSVA(20, 0, 0, 0)).rgba);
 			assert.notDeepEqual(new Color(new HSVA(10, 0, 0, 0)).hsva, new Color(new HSVA(20, 0, 0, 0)).hsva);
 		});
+
+		test('bug#36240', () => {
+			assert.deepEqual(HSVA.fromRGBA(new RGBA(92, 106, 196, 1)), new HSVA(232, .531, .769, 1));
+			assert.deepEqual(HSVA.toRGBA(HSVA.fromRGBA(new RGBA(92, 106, 196, 1))), new RGBA(92, 106, 196, 1));
+		});
 	});
 
 	suite('Format', () => {

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

@@ -13,33 +13,12 @@ suite('Errors', () => {
 		assert.strictEqual(toErrorMessage(new Error('Foo Bar')), 'Foo Bar');
 
 		let error: any = new Error();
-		error.status = 404;
-		error.statusText = 'Not Found';
-		assert.strictEqual(toErrorMessage(error), 'Not Found (HTTP 404)');
-
 		error = new Error();
 		error.detail = {};
 		error.detail.exception = {};
 		error.detail.exception.message = 'Foo Bar';
 		assert.strictEqual(toErrorMessage(error), 'Foo Bar');
 
-		error = new Error();
-		error.detail = {};
-		error.detail.error = {};
-		error.detail.error.status = 404;
-		error.detail.error.statusText = 'Not Found';
-		assert.strictEqual(toErrorMessage(error), 'Not Found (HTTP 404)');
-
-		error = new Error();
-		error.detail = {};
-		error.detail.error = [];
-
-		let foo: any = {};
-		error.detail.error.push(foo);
-		foo.status = 404;
-		foo.statusText = 'Not Found';
-		assert.strictEqual(toErrorMessage(error), 'Not Found (HTTP 404)');
-
 		assert(toErrorMessage());
 		assert(toErrorMessage(null));
 		assert(toErrorMessage({}));

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

@@ -5,9 +5,8 @@
 'use strict';
 
 import * as assert from 'assert';
-import Event, { Emitter, fromEventEmitter, debounceEvent, EventBufferer, once, fromPromise, stopwatch, buffer, echo, EventMultiplexer } from 'vs/base/common/event';
+import Event, { Emitter, debounceEvent, EventBufferer, once, fromPromise, stopwatch, buffer, echo, EventMultiplexer } from 'vs/base/common/event';
 import { IDisposable } from 'vs/base/common/lifecycle';
-import { EventEmitter } from 'vs/base/common/eventEmitter';
 import Errors = require('vs/base/common/errors');
 import { TPromise } from 'vs/base/common/winjs.base';
 
@@ -38,21 +37,6 @@ namespace Samples {
 		}
 
 	}
-
-	// what: like before but expose an existing event emitter as typed events
-	export class Document3b /*extends EventEmitter*/ {
-
-		private static _didChange = 'this_is_hidden_from_consumers';
-
-		private _eventBus = new EventEmitter();
-
-		onDidChange = fromEventEmitter<string>(this._eventBus, Document3b._didChange);
-
-		setText(value: string) {
-			//...
-			this._eventBus.emit(Document3b._didChange, value);
-		}
-	}
 }
 
 suite('Event', function () {
@@ -78,19 +62,6 @@ suite('Event', function () {
 	});
 
 
-	test('wrap legacy EventEmitter', function () {
-
-		let doc = new Samples.Document3b();
-		let subscription = doc.onDidChange(counter.onEvent, counter);
-		doc.setText('far');
-		doc.setText('boo');
-
-		// unhook listener
-		subscription.dispose();
-		doc.setText('boo');
-		assert.equal(counter.count, 2);
-	});
-
 	test('Emitter, bucket', function () {
 
 		let bucket: IDisposable[] = [];
@@ -112,27 +83,6 @@ suite('Event', function () {
 		assert.equal(counter.count, 2);
 	});
 
-	test('wrapEventEmitter, bucket', function () {
-
-		let bucket: IDisposable[] = [];
-		let doc = new Samples.Document3b();
-		let subscription = doc.onDidChange(counter.onEvent, counter, bucket);
-
-		doc.setText('far');
-		doc.setText('boo');
-
-		// unhook listener
-		while (bucket.length) {
-			bucket.pop().dispose();
-		}
-
-		// noop
-		subscription.dispose();
-
-		doc.setText('boo');
-		assert.equal(counter.count, 2);
-	});
-
 	test('onFirstAdd|onLastRemove', function () {
 
 		let firstCount = 0;
@@ -268,6 +218,25 @@ suite('Event', function () {
 			done();
 		});
 	});
+
+	test('Emitter - In Order Delivery', function () {
+		const a = new Emitter<string>();
+		const listener2Events: string[] = [];
+		a.event(function listener1(event) {
+			if (event === 'e1') {
+				a.fire('e2');
+				// assert that all events are delivered at this point
+				assert.deepEqual(listener2Events, ['e1', 'e2']);
+			}
+		});
+		a.event(function listener2(event) {
+			listener2Events.push(event);
+		});
+		a.fire('e1');
+
+		// assert that all events are delivered in order
+		assert.deepEqual(listener2Events, ['e1', 'e2']);
+	});
 });
 
 suite('Event utils', () => {
@@ -399,7 +368,7 @@ suite('Event utils', () => {
 	suite('buffer', () => {
 
 		test('should buffer events', () => {
-			const result = [];
+			const result: number[] = [];
 			const emitter = new Emitter<number>();
 			const event = emitter.event;
 			const bufferedEvent = buffer(event);
@@ -421,7 +390,7 @@ suite('Event utils', () => {
 		});
 
 		test('should buffer events on next tick', () => {
-			const result = [];
+			const result: number[] = [];
 			const emitter = new Emitter<number>();
 			const event = emitter.event;
 			const bufferedEvent = buffer(event, true);
@@ -445,7 +414,7 @@ suite('Event utils', () => {
 		});
 
 		test('should fire initial buffer events', () => {
-			const result = [];
+			const result: number[] = [];
 			const emitter = new Emitter<number>();
 			const event = emitter.event;
 			const bufferedEvent = buffer(event, false, [-2, -1, 0]);
@@ -463,7 +432,7 @@ suite('Event utils', () => {
 	suite('echo', () => {
 
 		test('should echo events', () => {
-			const result = [];
+			const result: number[] = [];
 			const emitter = new Emitter<number>();
 			const event = emitter.event;
 			const echoEvent = echo(event);
@@ -485,8 +454,8 @@ suite('Event utils', () => {
 		});
 
 		test('should echo events for every listener', () => {
-			const result1 = [];
-			const result2 = [];
+			const result1: number[] = [];
+			const result2: number[] = [];
 			const emitter = new Emitter<number>();
 			const event = emitter.event;
 			const echoEvent = echo(event);
@@ -524,7 +493,7 @@ suite('Event utils', () => {
 	suite('EventMultiplexer', () => {
 
 		test('works', () => {
-			const result = [];
+			const result: number[] = [];
 			const m = new EventMultiplexer<number>();
 			m.event(r => result.push(r));
 
@@ -538,7 +507,7 @@ suite('Event utils', () => {
 		});
 
 		test('multiplexer dispose works', () => {
-			const result = [];
+			const result: number[] = [];
 			const m = new EventMultiplexer<number>();
 			m.event(r => result.push(r));
 
@@ -558,7 +527,7 @@ suite('Event utils', () => {
 		});
 
 		test('event dispose works', () => {
-			const result = [];
+			const result: number[] = [];
 			const m = new EventMultiplexer<number>();
 			m.event(r => result.push(r));
 
@@ -578,7 +547,7 @@ suite('Event utils', () => {
 		});
 
 		test('mutliplexer event dispose works', () => {
-			const result = [];
+			const result: number[] = [];
 			const m = new EventMultiplexer<number>();
 			m.event(r => result.push(r));
 
@@ -598,7 +567,7 @@ suite('Event utils', () => {
 		});
 
 		test('hot start works', () => {
-			const result = [];
+			const result: number[] = [];
 			const m = new EventMultiplexer<number>();
 			m.event(r => result.push(r));
 
@@ -616,7 +585,7 @@ suite('Event utils', () => {
 		});
 
 		test('cold start works', () => {
-			const result = [];
+			const result: number[] = [];
 			const m = new EventMultiplexer<number>();
 
 			const e1 = new Emitter<number>();
@@ -635,7 +604,7 @@ suite('Event utils', () => {
 		});
 
 		test('late add works', () => {
-			const result = [];
+			const result: number[] = [];
 			const m = new EventMultiplexer<number>();
 
 			const e1 = new Emitter<number>();
@@ -656,7 +625,7 @@ suite('Event utils', () => {
 		});
 
 		test('add dispose works', () => {
-			const result = [];
+			const result: number[] = [];
 			const m = new EventMultiplexer<number>();
 
 			const e1 = new Emitter<number>();

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

@@ -1,319 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-'use strict';
-
-import * as assert from 'assert';
-import { EventEmitter, OrderGuaranteeEventEmitter } from 'vs/base/common/eventEmitter';
-
-suite('EventEmitter', () => {
-	let eventEmitter: EventEmitter;
-
-	setup(() => {
-		eventEmitter = new EventEmitter();
-	});
-
-	teardown(() => {
-		eventEmitter.dispose();
-		eventEmitter = null;
-	});
-
-	test('add listener, emit other event type', function () {
-		let didCall = false;
-		eventEmitter.addListener('eventType1', function (e) {
-			didCall = true;
-		});
-		eventEmitter.emit('eventType2', {});
-		assert(!didCall, 'Didn\'t expect to be called');
-	});
-
-	test('add listener, emit event', function () {
-		let didCall = false;
-		eventEmitter.addListener('eventType', function (e) {
-			didCall = true;
-		});
-		eventEmitter.emit('eventType', {});
-		assert(didCall);
-	});
-
-	test('add 2 listeners, emit event', function () {
-		let didCallFirst = false;
-		eventEmitter.addListener('eventType', function (e) {
-			didCallFirst = true;
-		});
-		let didCallSecond = false;
-		eventEmitter.addListener('eventType', function (e) {
-			didCallSecond = true;
-		});
-		eventEmitter.emit('eventType', {});
-		assert(didCallFirst);
-		assert(didCallSecond);
-	});
-
-	test('add 1 listener, remove it, emit event', function () {
-		let didCall = false;
-		let remove = eventEmitter.addListener('eventType', function (e) {
-			didCall = true;
-		});
-		remove.dispose();
-		eventEmitter.emit('eventType', {});
-		assert(!didCall);
-	});
-
-	test('add 2 listeners, emit event, remove one while processing', function () {
-		let firstCallCount = 0;
-		let remove1 = eventEmitter.addListener('eventType', function (e) {
-			firstCallCount++;
-			remove1.dispose();
-		});
-		let secondCallCount = 0;
-		eventEmitter.addListener('eventType', function (e) {
-			secondCallCount++;
-		});
-		eventEmitter.emit('eventType', {});
-		eventEmitter.emit('eventType', {});
-		assert.equal(firstCallCount, 1);
-		assert.equal(secondCallCount, 2);
-	});
-
-	test('event object is assert', function () {
-		let data: any;
-		eventEmitter.addListener('eventType', function (e) {
-			data = e.data;
-		});
-		eventEmitter.emit('eventType', { data: 5 });
-		assert.equal(data, 5);
-	});
-
-	test('deferred emit', function () {
-		let calledCount = 0;
-		eventEmitter.addListener('eventType', function (e) {
-			calledCount++;
-		});
-		eventEmitter.deferredEmit(function () {
-			assert.equal(calledCount, 0);
-			eventEmitter.emit('eventType', {});
-			assert.equal(calledCount, 0);
-			eventEmitter.emit('eventType', {});
-			assert.equal(calledCount, 0);
-		});
-		assert.equal(calledCount, 2);
-	});
-
-	test('deferred emit maintains events order', function () {
-		let order = 0;
-		eventEmitter.addListener('eventType2', function (e) {
-			order++;
-			assert.equal(order, 1);
-		});
-		eventEmitter.addListener('eventType1', function (e) {
-			order++;
-			assert.equal(order, 2);
-		});
-		eventEmitter.deferredEmit(function () {
-			eventEmitter.emit('eventType2', {});
-			eventEmitter.emit('eventType1', {});
-		});
-		assert.equal(order, 2);
-	});
-
-	test('deferred emit maintains events order for bulk listeners', function () {
-		let count = 0;
-		eventEmitter.addBulkListener(function (events) {
-			assert.equal(events[0].type, 'eventType2');
-			assert.equal(events[1].type, 'eventType1');
-			count++;
-		});
-		eventEmitter.deferredEmit(function () {
-			eventEmitter.emit('eventType2', {});
-			eventEmitter.emit('eventType1', {});
-		});
-		assert.equal(count, 1);
-	});
-
-	test('emit notifies bulk listeners', function () {
-		let count = 0;
-		eventEmitter.addBulkListener(function (events) {
-			count++;
-		});
-		eventEmitter.emit('eventType', {});
-		assert.equal(count, 1);
-	});
-
-	test('one event emitter, one listener', function () {
-		let emitter = new EventEmitter();
-		let eventBus = new EventEmitter();
-
-		eventBus.addEmitter(emitter);
-		let didCallFirst = false;
-		eventBus.addListener('eventType', function (e) {
-			didCallFirst = true;
-		});
-		let didCallSecond = false;
-		eventBus.addListener('eventType', function (e) {
-			didCallSecond = true;
-		});
-
-		emitter.emit('eventType', {});
-		assert(didCallFirst);
-		assert(didCallSecond);
-	});
-
-	test('two event emitters, two listeners, deferred emit', function () {
-		let callCnt = 0;
-		let emitter1 = new EventEmitter();
-		let emitter2 = new EventEmitter();
-		let eventBus = new EventEmitter();
-
-		eventBus.addEmitter(emitter1);
-		eventBus.addEmitter(emitter2);
-		eventBus.addListener('eventType1', function (e) {
-			assert(true);
-			callCnt++;
-		});
-		eventBus.addListener('eventType1', function (e) {
-			assert(true);
-			callCnt++;
-		});
-
-		eventBus.deferredEmit(function () {
-			assert.equal(callCnt, 0);
-			emitter1.emit('eventType1', {});
-			emitter2.emit('eventType1', {});
-			assert.equal(callCnt, 0);
-		});
-		assert.equal(callCnt, 4);
-	});
-
-	test('cascading emitters', function () {
-		let emitter1 = new EventEmitter();
-		let emitter2 = new EventEmitter();
-		let emitter3 = new EventEmitter();
-		let emitter4 = new EventEmitter();
-
-		emitter2.addEmitter(emitter1);
-		emitter3.addEmitter(emitter2);
-		emitter4.addEmitter(emitter3);
-
-		let didCall = false;
-		emitter4.addListener('eventType', function (e) {
-			didCall = true;
-		});
-
-		emitter1.emit('eventType', {});
-		assert(didCall);
-	});
-
-	test('EventEmitter makes no order guarantees 1', () => {
-		let emitter = new EventEmitter();
-		let actualCallOrder: string[] = [];
-
-		emitter.addListener('foo', function () {
-			actualCallOrder.push('listener1-foo');
-			emitter.emit('bar');
-		});
-
-
-		emitter.addListener('foo', function () {
-			actualCallOrder.push('listener2-foo');
-		});
-		emitter.addListener('bar', function () {
-			actualCallOrder.push('listener2-bar');
-		});
-
-		emitter.emit('foo');
-
-		assert.deepEqual(actualCallOrder, [
-			'listener1-foo',
-			'listener2-bar',
-			'listener2-foo'
-		]);
-	});
-
-	test('EventEmitter makes no order guarantees 2', () => {
-		let emitter = new EventEmitter();
-		let actualCallOrder: string[] = [];
-
-		emitter.addListener('foo', function () {
-			actualCallOrder.push('listener1-foo');
-			emitter.deferredEmit(() => {
-				emitter.emit('bar');
-			});
-		});
-
-
-		emitter.addListener('foo', function () {
-			actualCallOrder.push('listener2-foo');
-		});
-		emitter.addListener('bar', function () {
-			actualCallOrder.push('listener2-bar');
-		});
-
-		emitter.deferredEmit(() => {
-			emitter.emit('foo');
-		});
-
-		assert.deepEqual(actualCallOrder, [
-			'listener1-foo',
-			'listener2-bar',
-			'listener2-foo'
-		]);
-	});
-
-	test('OrderGuaranteeEventEmitter makes order guarantees 1', () => {
-		let emitter = new OrderGuaranteeEventEmitter();
-		let actualCallOrder: string[] = [];
-
-		emitter.addListener('foo', function () {
-			actualCallOrder.push('listener1-foo');
-			emitter.emit('bar');
-		});
-
-
-		emitter.addListener('foo', function () {
-			actualCallOrder.push('listener2-foo');
-		});
-		emitter.addListener('bar', function () {
-			actualCallOrder.push('listener2-bar');
-		});
-
-		emitter.emit('foo');
-
-		assert.deepEqual(actualCallOrder, [
-			'listener1-foo',
-			'listener2-foo',
-			'listener2-bar'
-		]);
-	});
-
-	test('OrderGuaranteeEventEmitter makes order guarantees 2', () => {
-		let emitter = new OrderGuaranteeEventEmitter();
-		let actualCallOrder: string[] = [];
-
-		emitter.addListener('foo', function () {
-			actualCallOrder.push('listener1-foo');
-			emitter.deferredEmit(() => {
-				emitter.emit('bar');
-			});
-		});
-
-
-		emitter.addListener('foo', function () {
-			actualCallOrder.push('listener2-foo');
-		});
-		emitter.addListener('bar', function () {
-			actualCallOrder.push('listener2-bar');
-		});
-
-		emitter.deferredEmit(() => {
-			emitter.emit('foo');
-		});
-
-		assert.deepEqual(actualCallOrder, [
-			'listener1-foo',
-			'listener2-foo',
-			'listener2-bar'
-		]);
-	});
-});

src/vs/base/test/common/filters.perf.test.ts

@@ -19,7 +19,7 @@ function perfSuite(name: string, callback: (this: Mocha.ISuiteCallbackContext) =
 
 perfSuite('Performance - fuzzyMatch', function () {
 
-	console.log(`Matching ${data.length} items against ${patterns.length} patterns...`);
+	console.log(`Matching ${data.length} items against ${patterns.length} patterns (${data.length * patterns.length} operations) `);
 
 	function perfTest(name: string, match: (pattern: string, word: string) => any) {
 		test(name, function () {
@@ -32,7 +32,8 @@ perfSuite('Performance - fuzzyMatch', function () {
 					match(pattern, item);
 				}
 			}
-			console.log(name, Date.now() - t1, `${(count / (Date.now() - t1)).toPrecision(6)}/ms`);
+			const d = Date.now() - t1;
+			console.log(name, `${d}ms, ${Math.round(count / d) * 15}ops/15ms`);
 		});
 	}
 
@@ -40,6 +41,6 @@ perfSuite('Performance - fuzzyMatch', function () {
 	perfTest('fuzzyContiguousFilter', filters.fuzzyContiguousFilter);
 	perfTest('fuzzyScore', filters.fuzzyScore);
 	perfTest('fuzzyScoreGraceful', filters.fuzzyScoreGraceful);
-
+	perfTest('fuzzyScoreGracefulAggressive', filters.fuzzyScoreGracefulAggressive);
 });
 

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

@@ -5,7 +5,7 @@
 'use strict';
 
 import * as assert from 'assert';
-import { IFilter, or, matchesPrefix, matchesStrictPrefix, matchesCamelCase, matchesSubString, matchesContiguousSubString, matchesWords, fuzzyScore, nextTypoPermutation, fuzzyScoreGraceful } from 'vs/base/common/filters';
+import { IFilter, or, matchesPrefix, matchesStrictPrefix, matchesCamelCase, matchesSubString, matchesContiguousSubString, matchesWords, fuzzyScore, IMatch, fuzzyScoreGraceful, fuzzyScoreGracefulAggressive } from 'vs/base/common/filters';
 
 function filterOk(filter: IFilter, word: string, wordToMatchAgainst: string, highlights?: { start: number; end: number; }[]) {
 	let r = filter(word, wordToMatchAgainst);
@@ -15,15 +15,16 @@ function filterOk(filter: IFilter, word: string, wordToMatchAgainst: string, hig
 	}
 }
 
-function filterNotOk(filter, word, suggestion) {
+function filterNotOk(filter: IFilter, word: string, suggestion: string) {
 	assert(!filter(word, suggestion));
 }
 
 suite('Filters', () => {
 	test('or', function () {
-		let filter, counters;
-		let newFilter = function (i, r) {
-			return function () { counters[i]++; return r; };
+		let filter: IFilter;
+		let counters: number[];
+		let newFilter = function (i: number, r: boolean): IFilter {
+			return function (): IMatch[] { counters[i]++; return r as any; };
 		};
 
 		counters = [0, 0];
@@ -422,27 +423,21 @@ suite('Filters', () => {
 		assertTopScore(fuzzyScore, '_lineS', 0, '_lineS', '_lines');
 	});
 
-	test('nextTypoPermutation', function () {
-
-		function assertTypos(pattern: string, ...variants: string[]) {
-			let pos = 1;
-			for (const expected of variants) {
-				const actual = nextTypoPermutation(pattern, pos);
-				assert.equal(actual, expected);
-				pos += 1;
-			}
-			assert.equal(nextTypoPermutation(pattern, pos), undefined);
-		}
-
-		assertTypos('abc', 'acb');
-		assertTypos('foboar', 'fbooar', 'foobar', 'fobaor', 'fobora');
+	test('HTML closing tag proposal filtered out #38880', function () {
+		assertMatches('\t\t<', '\t\t</body>', '^\t^\t^</body>', (pattern, word) => fuzzyScore(pattern, word, 0));
+		assertMatches('\t\t<', '\t\t</body>', '\t\t^</body>', (pattern, word) => fuzzyScore(pattern, word, 3));
+		assertMatches('\t<', '\t</body>', '\t^</body>', (pattern, word) => fuzzyScore(pattern, word, 2));
 	});
 
 	test('fuzzyScoreGraceful', function () {
 
-		assertMatches('tkb', 'the_black_knight', '^the_^black_^knight', fuzzyScoreGraceful);
-		assertMatches('tkbk', 'the_black_knight', '^the_^blac^k_^knight', fuzzyScoreGraceful);
-		assertMatches('tkkb', 'the_black_knight', undefined, fuzzyScoreGraceful);
-		assertMatches('tkb', 'no_match', undefined, fuzzyScoreGraceful);
+		assertMatches('rlut', 'result', undefined, fuzzyScore);
+		assertMatches('rlut', 'result', '^res^u^l^t', fuzzyScoreGraceful);
+
+		assertMatches('cno', 'console', '^co^ns^ole', fuzzyScore);
+		assertMatches('cno', 'console', '^co^ns^ole', fuzzyScoreGraceful);
+		assertMatches('cno', 'console', '^c^o^nsole', fuzzyScoreGracefulAggressive);
+		assertMatches('cno', 'co_new', '^c^o_^new', fuzzyScoreGraceful);
+		assertMatches('cno', 'co_new', '^c^o_^new', fuzzyScoreGracefulAggressive);
 	});
 });

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

@@ -6,7 +6,7 @@
 
 import * as assert from 'assert';
 import {
-	SyntaxKind, createScanner, parse, getLocation, Node, ParseError, parseTree, ParseErrorCode, ParseOptions, Segment, findNodeAtLocation, getNodeValue, ScanError
+	SyntaxKind, createScanner, parse, Node, ParseError, parseTree, ParseErrorCode, ParseOptions, ScanError
 } from 'vs/base/common/json';
 import { getParseErrorMessage } from 'vs/base/common/jsonErrorMessages';
 
@@ -62,30 +62,6 @@ function assertTree(input: string, expected: any, expectedErrors: number[] = [])
 	assert.deepEqual(actual, expected);
 }
 
-function assertNodeAtLocation(input: Node, segments: Segment[], expected: any) {
-	let actual = findNodeAtLocation(input, segments);
-	assert.deepEqual(actual ? getNodeValue(actual) : void 0, expected);
-}
-
-
-function assertLocation(input: string, expectedSegments: Segment[], expectedNodeType: string, expectedCompleteProperty: boolean): void {
-	var offset = input.indexOf('|');
-	input = input.substring(0, offset) + input.substring(offset + 1, input.length);
-	var actual = getLocation(input, offset);
-	assert(actual);
-	assert.deepEqual(actual.path, expectedSegments, input);
-	assert.equal(actual.previousNode && actual.previousNode.type, expectedNodeType, input);
-	assert.equal(actual.isAtPropertyKey, expectedCompleteProperty, input);
-}
-
-function assertMatchesLocation(input: string, matchingSegments: Segment[], expectedResult = true): void {
-	var offset = input.indexOf('|');
-	input = input.substring(0, offset) + input.substring(offset + 1, input.length);
-	var actual = getLocation(input, offset);
-	assert(actual);
-	assert.equal(actual.matches(matchingSegments), expectedResult);
-}
-
 suite('JSON', () => {
 	test('tokens', () => {
 		assertKinds('{', SyntaxKind.OpenBraceToken);
@@ -258,41 +234,11 @@ suite('JSON', () => {
 		assertValidParse('{ "hello": [] }', { hello: [] }, options);
 		assertValidParse('{ "hello": [], "world": {}, }', { hello: [], world: {} }, options);
 		assertValidParse('{ "hello": [], "world": {} }', { hello: [], world: {} }, options);
+		assertValidParse('{ "hello": [1,] }', { hello: [1] }, options);
 
 		assertInvalidParse('{ "hello": [], }', { hello: [] });
 		assertInvalidParse('{ "hello": [], "world": {}, }', { hello: [], world: {} });
 	});
-	test('location: properties', () => {
-		assertLocation('|{ "foo": "bar" }', [], void 0, false);
-		assertLocation('{| "foo": "bar" }', [''], void 0, true);
-		assertLocation('{ |"foo": "bar" }', ['foo'], 'property', true);
-		assertLocation('{ "foo|": "bar" }', ['foo'], 'property', true);
-		assertLocation('{ "foo"|: "bar" }', ['foo'], 'property', true);
-		assertLocation('{ "foo": "bar"| }', ['foo'], 'string', false);
-		assertLocation('{ "foo":| "bar" }', ['foo'], void 0, false);
-		assertLocation('{ "foo": {"bar|": 1, "car": 2 } }', ['foo', 'bar'], 'property', true);
-		assertLocation('{ "foo": {"bar": 1|, "car": 3 } }', ['foo', 'bar'], 'number', false);
-		assertLocation('{ "foo": {"bar": 1,| "car": 4 } }', ['foo', ''], void 0, true);
-		assertLocation('{ "foo": {"bar": 1, "ca|r": 5 } }', ['foo', 'car'], 'property', true);
-		assertLocation('{ "foo": {"bar": 1, "car": 6| } }', ['foo', 'car'], 'number', false);
-		assertLocation('{ "foo": {"bar": 1, "car": 7 }| }', ['foo'], void 0, false);
-		assertLocation('{ "foo": {"bar": 1, "car": 8 },| "goo": {} }', [''], void 0, true);
-		assertLocation('{ "foo": {"bar": 1, "car": 9 }, "go|o": {} }', ['goo'], 'property', true);
-		assertLocation('{ "dep": {"bar": 1, "car": |', ['dep', 'car'], void 0, false);
-		assertLocation('{ "dep": {"bar": 1,, "car": |', ['dep', 'car'], void 0, false);
-		assertLocation('{ "dep": {"bar": "na", "dar": "ma", "car": | } }', ['dep', 'car'], void 0, false);
-	});
-
-	test('location: arrays', () => {
-		assertLocation('|["foo", null ]', [], void 0, false);
-		assertLocation('[|"foo", null ]', [0], 'string', false);
-		assertLocation('["foo"|, null ]', [0], 'string', false);
-		assertLocation('["foo",| null ]', [1], void 0, false);
-		assertLocation('["foo", |null ]', [1], 'null', false);
-		assertLocation('["foo", null,| ]', [2], void 0, false);
-		assertLocation('["foo", null,,| ]', [3], void 0, false);
-		assertLocation('[["foo", null,, ],|', [1], void 0, false);
-	});
 
 	test('tree: literals', () => {
 		assertTree('true', { type: 'boolean', offset: 0, length: 4, value: true });
@@ -376,27 +322,4 @@ suite('JSON', () => {
 			}
 			, [ParseErrorCode.PropertyNameExpected, ParseErrorCode.ValueExpected]);
 	});
-
-	test('tree: find location', () => {
-		let root = parseTree('{ "key1": { "key11": [ "val111", "val112" ] }, "key2": [ { "key21": false, "key22": 221 }, null, [{}] ] }');
-		assertNodeAtLocation(root, ['key1'], { key11: ['val111', 'val112'] });
-		assertNodeAtLocation(root, ['key1', 'key11'], ['val111', 'val112']);
-		assertNodeAtLocation(root, ['key1', 'key11', 0], 'val111');
-		assertNodeAtLocation(root, ['key1', 'key11', 1], 'val112');
-		assertNodeAtLocation(root, ['key1', 'key11', 2], void 0);
-		assertNodeAtLocation(root, ['key2', 0, 'key21'], false);
-		assertNodeAtLocation(root, ['key2', 0, 'key22'], 221);
-		assertNodeAtLocation(root, ['key2', 1], null);
-		assertNodeAtLocation(root, ['key2', 2], [{}]);
-		assertNodeAtLocation(root, ['key2', 2, 0], {});
-	});
-
-	test('location: matches', () => {
-		assertMatchesLocation('{ "dependencies": { | } }', ['dependencies']);
-		assertMatchesLocation('{ "dependencies": { "fo| } }', ['dependencies']);
-		assertMatchesLocation('{ "dependencies": { "fo|" } }', ['dependencies']);
-		assertMatchesLocation('{ "dependencies": { "fo|": 1 } }', ['dependencies']);
-		assertMatchesLocation('{ "dependencies": { "fo|": 1 } }', ['dependencies']);
-		assertMatchesLocation('{ "dependencies": { "fo": | } }', ['dependencies', '*']);
-	});
 });

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

@@ -8,6 +8,7 @@
 import * as assert from 'assert';
 import labels = require('vs/base/common/labels');
 import platform = require('vs/base/common/platform');
+import { getBaseLabel } from 'vs/base/common/labels';
 
 suite('Labels', () => {
 	test('shorten - windows', () => {
@@ -143,4 +144,27 @@ suite('Labels', () => {
 		assert.strictEqual(labels.template(t, { dirty: '', activeEditorShort: 'somefile.txt', rootName: 'monaco', appName: 'Visual Studio Code', separator: { label: ' - ' } }), 'somefile.txt - monaco - Visual Studio Code');
 		assert.strictEqual(labels.template(t, { dirty: '* ', activeEditorShort: 'somefile.txt', rootName: 'monaco', appName: 'Visual Studio Code', separator: { label: ' - ' } }), '* somefile.txt - monaco - Visual Studio Code');
 	});
+
+	test('getBaseLabel - unix', () => {
+		if (platform.isWindows) {
+			assert.ok(true);
+			return;
+		}
+
+		assert.equal(getBaseLabel('/some/folder/file.txt'), 'file.txt');
+		assert.equal(getBaseLabel('/some/folder'), 'folder');
+		assert.equal(getBaseLabel('/'), '/');
+	});
+
+	test('getBaseLabel - windows', () => {
+		if (!platform.isWindows) {
+			assert.ok(true);
+			return;
+		}
+
+		assert.equal(getBaseLabel('c:'), 'C:');
+		assert.equal(getBaseLabel('c:\\'), 'C:');
+		assert.equal(getBaseLabel('c:\\some\\folder\\file.txt'), 'file.txt');
+		assert.equal(getBaseLabel('c:\\some\\folder'), 'folder');
+	});
 });

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

@@ -5,15 +5,76 @@
 
 'use strict';
 
-
-import { BoundedMap, ResourceMap, TernarySearchTree, PathIterator, StringIterator } from 'vs/base/common/map';
+import { ResourceMap, TernarySearchTree, PathIterator, StringIterator, LinkedMap, Touch, LRUCache } from 'vs/base/common/map';
 import * as assert from 'assert';
 import URI from 'vs/base/common/uri';
 
 suite('Map', () => {
 
-	test('BoundedMap - basics', function () {
-		const map = new BoundedMap<any>();
+	test('LinkedMap - Simple', () => {
+		let map = new LinkedMap<string, string>();
+		map.set('ak', 'av');
+		map.set('bk', 'bv');
+		assert.deepStrictEqual(map.keys(), ['ak', 'bk']);
+		assert.deepStrictEqual(map.values(), ['av', 'bv']);
+	});
+
+	test('LinkedMap - Touch Old one', () => {
+		let map = new LinkedMap<string, string>();
+		map.set('ak', 'av');
+		map.set('ak', 'av', Touch.AsOld);
+		assert.deepStrictEqual(map.keys(), ['ak']);
+		assert.deepStrictEqual(map.values(), ['av']);
+	});
+
+	test('LinkedMap - Touch New one', () => {
+		let map = new LinkedMap<string, string>();
+		map.set('ak', 'av');
+		map.set('ak', 'av', Touch.AsNew);
+		assert.deepStrictEqual(map.keys(), ['ak']);
+		assert.deepStrictEqual(map.values(), ['av']);
+	});
+
+	test('LinkedMap - Touch Old two', () => {
+		let map = new LinkedMap<string, string>();
+		map.set('ak', 'av');
+		map.set('bk', 'bv');
+		map.set('bk', 'bv', Touch.AsOld);
+		assert.deepStrictEqual(map.keys(), ['bk', 'ak']);
+		assert.deepStrictEqual(map.values(), ['bv', 'av']);
+	});
+
+	test('LinkedMap - Touch New two', () => {
+		let map = new LinkedMap<string, string>();
+		map.set('ak', 'av');
+		map.set('bk', 'bv');
+		map.set('ak', 'av', Touch.AsNew);
+		assert.deepStrictEqual(map.keys(), ['bk', 'ak']);
+		assert.deepStrictEqual(map.values(), ['bv', 'av']);
+	});
+
+	test('LinkedMap - Touch Old from middle', () => {
+		let map = new LinkedMap<string, string>();
+		map.set('ak', 'av');
+		map.set('bk', 'bv');
+		map.set('ck', 'cv');
+		map.set('bk', 'bv', Touch.AsOld);
+		assert.deepStrictEqual(map.keys(), ['bk', 'ak', 'ck']);
+		assert.deepStrictEqual(map.values(), ['bv', 'av', 'cv']);
+	});
+
+	test('LinkedMap - Touch New from middle', () => {
+		let map = new LinkedMap<string, string>();
+		map.set('ak', 'av');
+		map.set('bk', 'bv');
+		map.set('ck', 'cv');
+		map.set('bk', 'bv', Touch.AsNew);
+		assert.deepStrictEqual(map.keys(), ['ak', 'ck', 'bk']);
+		assert.deepStrictEqual(map.values(), ['av', 'cv', 'bv']);
+	});
+
+	test('LinkedMap - basics', function () {
+		const map = new LinkedMap<string, any>();
 
 		assert.equal(map.size, 0);
 
@@ -37,11 +98,11 @@ suite('Map', () => {
 
 		map.delete('6');
 		assert.equal(map.size, 5);
-		assert.equal(map.delete('1'), 1);
-		assert.equal(map.delete('2'), '2');
+		assert.equal(map.delete('1'), true);
+		assert.equal(map.delete('2'), true);
 		assert.equal(map.delete('3'), true);
-		assert.equal(map.delete('4'), obj);
-		assert.equal(map.delete('5'), date);
+		assert.equal(map.delete('4'), true);
+		assert.equal(map.delete('5'), true);
 
 		assert.equal(map.size, 0);
 		assert.ok(!map.get('5'));
@@ -52,8 +113,7 @@ suite('Map', () => {
 
 		map.set('1', 1);
 		map.set('2', '2');
-		assert.ok(map.set('3', true)); // adding an element returns true
-		assert.ok(!map.set('3', true)); // adding it again returns false
+		map.set('3', true);
 
 		assert.ok(map.has('1'));
 		assert.equal(map.get('1'), 1);
@@ -67,248 +127,77 @@ suite('Map', () => {
 		assert.ok(!map.get('2'));
 		assert.ok(!map.get('3'));
 		assert.ok(!map.has('1'));
-
-		const res = map.getOrSet('foo', 'bar');
-		assert.equal(map.get('foo'), res);
-		assert.equal(res, 'bar');
 	});
 
-	test('BoundedMap - serialization', function () {
-		const map = new BoundedMap<any>(5);
+	test('LinkedMap - LRU Cache simple', () => {
+		const cache = new LRUCache<number, number>(5);
 
-		map.set('1', 1);
-		map.set('2', '2');
-		map.set('3', true);
-
-		const obj = Object.create(null);
-		map.set('4', obj);
-
-		const date = Date.now();
-		map.set('5', date);
-
-		const mapClone = new BoundedMap<any>(5, 1, map.serialize());
-
-		assert.deepEqual(map.serialize(), mapClone.serialize());
-
-		assert.equal(mapClone.size, 5);
-		assert.equal(mapClone.get('1'), 1);
-		assert.equal(mapClone.get('2'), '2');
-		assert.equal(mapClone.get('3'), true);
-		assert.equal(mapClone.get('4'), obj);
-		assert.equal(mapClone.get('5'), date);
-		assert.ok(!mapClone.get('6'));
-
-		mapClone.set('6', '6');
-		assert.equal(mapClone.size, 5);
-		assert.ok(!mapClone.get('1'));
+		[1, 2, 3, 4, 5].forEach(value => cache.set(value, value));
+		assert.strictEqual(cache.size, 5);
+		cache.set(6, 6);
+		assert.strictEqual(cache.size, 5);
+		assert.deepStrictEqual(cache.keys(), [2, 3, 4, 5, 6]);
+		cache.set(7, 7);
+		assert.strictEqual(cache.size, 5);
+		assert.deepStrictEqual(cache.keys(), [3, 4, 5, 6, 7]);
+		let values: number[] = [];
+		[3, 4, 5, 6, 7].forEach(key => values.push(cache.get(key)));
+		assert.deepStrictEqual(values, [3, 4, 5, 6, 7]);
 	});
 
-	test('BoundedMap - setLimit', function () {
-		const map = new BoundedMap<any>(5);
+	test('LinkedMap - LRU Cache get', () => {
+		const cache = new LRUCache<number, number>(5);
 
-		map.set('1', 1);
-		map.set('2', '2');
-		map.set('3', true);
-
-		const obj = Object.create(null);
-		map.set('4', obj);
-
-		const date = Date.now();
-		map.set('5', date);
-
-		assert.equal(map.size, 5);
-		assert.equal(map.get('1'), 1);
-		assert.equal(map.get('2'), '2');
-		assert.equal(map.get('3'), true);
-		assert.equal(map.get('4'), obj);
-		assert.equal(map.get('5'), date);
-		assert.ok(!map.get('6'));
-
-		map.setLimit(3);
-
-		assert.equal(map.size, 3);
-		assert.ok(!map.get('1'));
-		assert.ok(!map.get('2'));
-		assert.equal(map.get('3'), true);
-		assert.equal(map.get('4'), obj);
-		assert.equal(map.get('5'), date);
-
-		map.setLimit(0);
-
-		assert.equal(map.size, 0);
-		assert.ok(!map.get('3'));
-		assert.ok(!map.get('4'));
-		assert.ok(!map.get('5'));
-
-		map.set('6', 6);
-
-		assert.equal(map.size, 0);
-		assert.ok(!map.get('6'));
-
-		map.setLimit(100);
-
-		map.set('1', 1);
-		map.set('2', '2');
-		map.set('3', true);
-		map.set('4', obj);
-		map.set('5', date);
-
-		assert.equal(map.size, 5);
-		assert.equal(map.get('1'), 1);
-		assert.equal(map.get('2'), '2');
-		assert.equal(map.get('3'), true);
-		assert.equal(map.get('4'), obj);
-		assert.equal(map.get('5'), date);
+		[1, 2, 3, 4, 5].forEach(value => cache.set(value, value));
+		assert.strictEqual(cache.size, 5);
+		assert.deepStrictEqual(cache.keys(), [1, 2, 3, 4, 5]);
+		cache.get(3);
+		assert.deepStrictEqual(cache.keys(), [1, 2, 4, 5, 3]);
+		cache.peek(4);
+		assert.deepStrictEqual(cache.keys(), [1, 2, 4, 5, 3]);
+		let values: number[] = [];
+		[1, 2, 3, 4, 5].forEach(key => values.push(cache.get(key)));
+		assert.deepStrictEqual(values, [1, 2, 3, 4, 5]);
 	});
 
-	test('BoundedMap - bounded', function () {
-		const map = new BoundedMap<number>(5);
+	test('LinkedMap - LRU Cache limit', () => {
+		const cache = new LRUCache<number, number>(10);
 
-		assert.equal(0, map.size);
-
-		map.set('1', 1);
-		map.set('2', 2);
-		map.set('3', 3);
-		map.set('4', 4);
-		map.set('5', 5);
-
-		assert.equal(5, map.size);
-
-		assert.equal(map.get('1'), 1);
-		assert.equal(map.get('2'), 2);
-		assert.equal(map.get('3'), 3);
-		assert.equal(map.get('4'), 4);
-		assert.equal(map.get('5'), 5);
-
-		map.set('6', 6);
-
-		assert.equal(5, map.size);
-		assert.ok(!map.get('1'));
-		assert.equal(map.get('2'), 2);
-		assert.equal(map.get('3'), 3);
-		assert.equal(map.get('4'), 4);
-		assert.equal(map.get('5'), 5);
-		assert.equal(map.get('6'), 6);
-
-		map.set('7', 7);
-		map.set('8', 8);
-		map.set('9', 9);
-
-		assert.equal(5, map.size);
-		assert.ok(!map.get('1'));
-		assert.ok(!map.get('2'));
-		assert.ok(!map.get('3'));
-		assert.ok(!map.get('4'));
-
-		assert.equal(map.get('5'), 5);
-		assert.equal(map.get('6'), 6);
-		assert.equal(map.get('7'), 7);
-		assert.equal(map.get('8'), 8);
-		assert.equal(map.get('9'), 9);
-
-		map.delete('5');
-		map.delete('7');
-
-		assert.equal(3, map.size);
-		assert.ok(!map.get('5'));
-		assert.ok(!map.get('7'));
-		assert.equal(map.get('6'), 6);
-		assert.equal(map.get('8'), 8);
-		assert.equal(map.get('9'), 9);
-
-		map.set('10', 10);
-		map.set('11', 11);
-		map.set('12', 12);
-		map.set('13', 13);
-		map.set('14', 14);
-
-		assert.equal(5, map.size);
-		assert.equal(map.get('10'), 10);
-		assert.equal(map.get('11'), 11);
-		assert.equal(map.get('12'), 12);
-		assert.equal(map.get('13'), 13);
-		assert.equal(map.get('14'), 14);
-	});
-
-	test('BoundedMap - bounded with ratio', function () {
-		const map = new BoundedMap<number>(6, 0.5);
-
-		assert.equal(0, map.size);
-
-		map.set('1', 1);
-		map.set('2', 2);
-		map.set('3', 3);
-		map.set('4', 4);
-		map.set('5', 5);
-		map.set('6', 6);
-
-		assert.equal(6, map.size);
-
-		map.set('7', 7);
-
-		assert.equal(3, map.size);
-		assert.ok(!map.has('1'));
-		assert.ok(!map.has('2'));
-		assert.ok(!map.has('3'));
-		assert.ok(!map.has('4'));
-		assert.equal(map.get('5'), 5);
-		assert.equal(map.get('6'), 6);
-		assert.equal(map.get('7'), 7);
-
-		map.set('8', 8);
-		map.set('9', 9);
-		map.set('10', 10);
-
-		assert.equal(6, map.size);
-		assert.equal(map.get('5'), 5);
-		assert.equal(map.get('6'), 6);
-		assert.equal(map.get('7'), 7);
-		assert.equal(map.get('8'), 8);
-		assert.equal(map.get('9'), 9);
-		assert.equal(map.get('10'), 10);
-	});
-
-	test('BoundedMap - MRU order', function () {
-		const map = new BoundedMap<number>(3);
-
-		function peek(key) {
-			const res = map.get(key);
-			if (res) {
-				map.delete(key);
-				map.set(key, res);
-			}
-
-			return res;
+		for (let i = 1; i <= 10; i++) {
+			cache.set(i, i);
 		}
+		assert.strictEqual(cache.size, 10);
+		cache.limit = 5;
+		assert.strictEqual(cache.size, 5);
+		assert.deepStrictEqual(cache.keys(), [6, 7, 8, 9, 10]);
+		cache.limit = 20;
+		assert.strictEqual(cache.size, 5);
+		for (let i = 11; i <= 20; i++) {
+			cache.set(i, i);
+		}
+		assert.deepEqual(cache.size, 15);
+		let values: number[] = [];
+		for (let i = 6; i <= 20; i++) {
+			values.push(cache.get(i));
+			assert.strictEqual(cache.get(i), i);
+		}
+		assert.deepStrictEqual(cache.values(), values);
+	});
 
-		assert.equal(0, map.size);
+	test('LinkedMap - LRU Cache limit with ratio', () => {
+		const cache = new LRUCache<number, number>(10, 0.5);
 
-		map.set('1', 1);
-		map.set('2', 2);
-		map.set('3', 3);
-
-		assert.equal(3, map.size);
-
-		assert.equal(map.get('1'), 1);
-		assert.equal(map.get('2'), 2);
-		assert.equal(map.get('3'), 3);
-
-		map.set('4', 4);
-
-		assert.equal(3, map.size);
-		assert.equal(peek('4'), 4); // this changes MRU order
-		assert.equal(peek('3'), 3);
-		assert.equal(peek('2'), 2);
-
-		map.set('5', 5);
-		map.set('6', 6);
-
-		assert.equal(3, map.size);
-		assert.equal(peek('2'), 2);
-		assert.equal(peek('5'), 5);
-		assert.equal(peek('6'), 6);
-		assert.ok(!map.has('3'));
-		assert.ok(!map.has('4'));
+		for (let i = 1; i <= 10; i++) {
+			cache.set(i, i);
+		}
+		assert.strictEqual(cache.size, 10);
+		cache.set(11, 11);
+		assert.strictEqual(cache.size, 5);
+		assert.deepStrictEqual(cache.keys(), [7, 8, 9, 10, 11]);
+		let values: number[] = [];
+		cache.keys().forEach(key => values.push(cache.get(key)));
+		assert.deepStrictEqual(values, [7, 8, 9, 10, 11]);
+		assert.deepStrictEqual(cache.values(), values);
 	});
 
 	test('PathIterator', function () {
@@ -447,6 +336,16 @@ suite('Map', () => {
 		assert.equal(trie.get('bar'), undefined);
 	});
 
+	test('TernarySearchTree - delete & cleanup', function () {
+		let trie = new TernarySearchTree<number>(new StringIterator());
+		trie.set('foo', 1);
+		trie.set('foobar', 2);
+		trie.set('bar', 3);
+
+		trie.delete('foo');
+		trie.delete('foobar');
+	});
+
 	test('TernarySearchTree (PathSegments) - basics', function () {
 		let trie = new TernarySearchTree<number>(new PathIterator());
 

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

@@ -7,12 +7,12 @@
 import * as assert from 'assert';
 import objects = require('vs/base/common/objects');
 
-let check = (one, other, msg) => {
+let check = (one: any, other: any, msg: string) => {
 	assert(objects.equals(one, other), msg);
 	assert(objects.equals(other, one), '[reverse] ' + msg);
 };
 
-let checkNot = (one, other, msg) => {
+let checkNot = (one: any, other: any, msg: string) => {
 	assert(!objects.equals(one, other), msg);
 	assert(!objects.equals(other, one), '[reverse] ' + msg);
 };
@@ -92,11 +92,11 @@ suite('Objects', () => {
 	});
 
 	test('safeStringify', function () {
-		let obj1 = {
+		let obj1: any = {
 			friend: null
 		};
 
-		let obj2 = {
+		let obj2: any = {
 			friend: null
 		};
 
@@ -106,7 +106,7 @@ suite('Objects', () => {
 		let arr: any = [1];
 		arr.push(arr);
 
-		let circular = {
+		let circular: any = {
 			a: 42,
 			b: null,
 			c: [
@@ -138,42 +138,6 @@ suite('Objects', () => {
 		});
 	});
 
-	test('derive', function () {
-
-		let someValue = 2;
-
-		function Base(): void {
-			//example
-		}
-		(<any>Base).favoriteColor = 'blue';
-		Base.prototype.test = function () { return 42; };
-
-		function Child(): void {
-			//example
-		}
-		Child.prototype.test2 = function () { return 43; };
-		Object.defineProperty(Child.prototype, 'getter', {
-			get: function () { return someValue; },
-			enumerable: true,
-			configurable: true
-		});
-
-		objects.derive(Base, Child);
-
-		let base = new Base();
-		let child = new Child();
-
-		assert(base instanceof Base);
-		assert(child instanceof Child);
-
-		assert.strictEqual(base.test, child.test);
-		assert.strictEqual(base.test(), 42);
-		assert.strictEqual(child.test2(), 43);
-		assert.strictEqual((<any>Child).favoriteColor, 'blue');
-		someValue = 4;
-		assert.strictEqual(child.getter, 4);
-	});
-
 	test('distinct', function () {
 		let base = {
 			one: 'one',

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

@@ -9,34 +9,6 @@ import paths = require('vs/base/common/paths');
 import platform = require('vs/base/common/platform');
 
 suite('Paths', () => {
-	test('relative', () => {
-		assert.equal(paths.relative('/test/api/files/test', '/test/api/files/lib/foo'), '../lib/foo');
-		assert.equal(paths.relative('far/boo', 'boo/far'), '../../boo/far');
-		assert.equal(paths.relative('far/boo', 'far/boo'), '');
-		assert.equal(paths.relative('far/boo', 'far/boo/bar/foo'), 'bar/foo');
-
-		if (platform.isWindows) {
-			assert.equal(paths.relative('C:\\test\\api\\files\\test', 'C:\\test\\api\\files\\lib\\foo'), '../lib/foo');
-			assert.equal(paths.relative('C:\\', 'C:\\vscode'), 'vscode');
-			assert.equal(paths.relative('C:\\', 'C:\\vscode\\foo.txt'), 'vscode/foo.txt');
-		}
-
-		// // ignore trailing slashes
-		assert.equal(paths.relative('/test/api/files/test/', '/test/api/files/lib/foo'), '../lib/foo');
-		assert.equal(paths.relative('/test/api/files/test', '/test/api/files/lib/foo/'), '../lib/foo');
-		assert.equal(paths.relative('/test/api/files/test/', '/test/api/files/lib/foo/'), '../lib/foo');
-		assert.equal(paths.relative('far/boo/', 'boo/far'), '../../boo/far');
-		assert.equal(paths.relative('far/boo/', 'boo/far/'), '../../boo/far');
-		assert.equal(paths.relative('far/boo/', 'far/boo'), '');
-		assert.equal(paths.relative('far/boo', 'far/boo/'), '');
-		assert.equal(paths.relative('far/boo/', 'far/boo/'), '');
-
-		if (platform.isWindows) {
-			assert.equal(paths.relative('C:\\test\\api\\files\\test\\', 'C:\\test\\api\\files\\lib\\foo'), '../lib/foo');
-			assert.equal(paths.relative('C:\\test\\api\\files\\test', 'C:\\test\\api\\files\\lib\\foo\\'), '../lib/foo');
-			assert.equal(paths.relative('C:\\test\\api\\files\\test\\', 'C:\\test\\api\\files\\lib\\foo\\'), '../lib/foo');
-		}
-	});
 
 	test('dirname', () => {
 		assert.equal(paths.dirname('foo/bar'), 'foo');

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

@@ -103,30 +103,18 @@ suite('Strings', () => {
 		assert.equal(strings.overlap('full', 'full'), 4);
 		assert.equal(strings.overlap('full', 'fulloverlap'), 4);
 	});
+	test('lcut', () => {
+		assert.strictEqual(strings.lcut('foo bar', 0), '');
+		assert.strictEqual(strings.lcut('foo bar', 1), 'bar');
+		assert.strictEqual(strings.lcut('foo bar', 3), 'bar');
+		assert.strictEqual(strings.lcut('foo bar', 4), 'bar'); // Leading whitespace trimmed
+		assert.strictEqual(strings.lcut('foo bar', 5), 'foo bar');
+		assert.strictEqual(strings.lcut('test string 0.1.2.3', 3), '2.3');
 
-	test('computeLineStarts', function () {
-		function assertLineStart(text: string, ...offsets: number[]): void {
-			const actual = strings.computeLineStarts(text);
-			assert.equal(actual.length, offsets.length);
-			if (actual.length !== offsets.length) {
-				return;
-			}
-			while (offsets.length > 0) {
-				assert.equal(actual.pop(), offsets.pop());
-			}
-		}
-
-		assertLineStart('', 0);
-		assertLineStart('farboo', 0);
-		assertLineStart('far\nboo', 0, 4);
-		assertLineStart('far\rboo', 0, 4);
-		assertLineStart('far\r\nboo', 0, 5);
-		assertLineStart('far\n\rboo', 0, 4, 5);
-		assertLineStart('far\n \rboo', 0, 4, 6);
-		assertLineStart('far\nboo\nfar', 0, 4, 8);
+		assert.strictEqual(strings.lcut('', 10), '');
+		assert.strictEqual(strings.lcut('a', 10), 'a');
 	});
 
-
 	test('pad', function () {
 		assert.strictEqual(strings.pad(1, 0), '1');
 		assert.strictEqual(strings.pad(1, 1), '1');
@@ -207,13 +195,6 @@ suite('Strings', () => {
 		assert.strictEqual(' 	  '.trim(), '');
 	});
 
-	test('appendWithLimit', function () {
-		assert.strictEqual(strings.appendWithLimit('ab', 'cd', 100), 'abcd');
-		assert.strictEqual(strings.appendWithLimit('ab', 'cd', 2), '...cd');
-		assert.strictEqual(strings.appendWithLimit('ab', 'cdefgh', 4), '...efgh');
-		assert.strictEqual(strings.appendWithLimit('abcdef', 'ghijk', 7), '...efghijk');
-	});
-
 	test('repeat', () => {
 		assert.strictEqual(strings.repeat(' ', 4), '    ');
 		assert.strictEqual(strings.repeat(' ', 1), ' ');

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

@@ -184,7 +184,7 @@ suite('Types', () => {
 		function isFoo(f) { }
 		assert.throws(() => types.validateConstraints([new foo()], [isFoo]));
 
-		function isFoo2(f) { return true; };
+		function isFoo2(f) { return true; }
 		types.validateConstraints([new foo()], [isFoo2]);
 
 		assert.throws(() => types.validateConstraints([1, true], [types.isNumber, types.isString]));
@@ -198,7 +198,7 @@ suite('Types', () => {
 		assert(types.create(zeroConstructor) instanceof zeroConstructor);
 		assert(types.isObject(types.create(zeroConstructor)));
 
-		let manyArgConstructor = function (foo, bar) {
+		let manyArgConstructor = function (this: any, foo, bar) {
 			this.foo = foo;
 			this.bar = bar;
 		};

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

@@ -85,6 +85,6 @@ export function onError(error: Error, done: () => void): void {
 	done();
 }
 
-export function toResource(path) {
+export function toResource(this: any, path: string) {
 	return URI.file(paths.join('C:\\', new Buffer(this.test.fullTitle()).toString('base64'), path));
 }

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

@@ -12,14 +12,13 @@ suite('UUID', () => {
 		var asHex = uuid.v4().asHex();
 		assert.equal(asHex.length, 36);
 		assert.equal(asHex[14], '4');
-		assert(asHex[19] === '8' || asHex[19] === '9' || asHex[19] === 'a' || asHex[19] === 'b');
+		assert.ok(asHex[19] === '8' || asHex[19] === '9' || asHex[19] === 'a' || asHex[19] === 'b');
 	});
 
 	test('parse', () => {
 		var id = uuid.v4();
 		var asHext = id.asHex();
 		var id2 = uuid.parse(asHext);
-		assert(id.equals(id2));
-		assert(id2.equals(id));
+		assert.equal(id.asHex(), id2.asHex());
 	});
-});
+});

src/vs/base/test/common/winjs.polyfill.promise.test.ts

@@ -11,142 +11,6 @@ import { Promise as WinJSPromise } from 'vs/base/common/winjs.base';
 suite('Polyfill Promise', function () {
 
 	test('sync-resolve, NativePromise', function () {
-		// native promise behaviour
-		const actual: string[] = [];
-		const promise = new Promise(resolve => {
-			actual.push('inCtor');
-			resolve(null);
-		}).then(() => actual.push('inThen'));
-		actual.push('afterCtor');
-		return promise.then(() => {
-			assert.deepEqual(actual, ['inCtor', 'afterCtor', 'inThen']);
-		});
 	});
 
-	test('sync-resolve, WinJSPromise', function () {
-
-		// winjs promise behaviour
-		const actual: string[] = [];
-		const promise = new WinJSPromise(resolve => {
-			actual.push('inCtor');
-			resolve(null);
-		}).then(() => actual.push('inThen'));
-		actual.push('afterCtor');
-		return promise.then(() => {
-			assert.deepEqual(actual, ['inCtor', 'inThen', 'afterCtor']);
-		});
-	});
-
-	test('sync-resolve, PolyfillPromise', function () {
-
-		// winjs promise behaviour
-		const actual: string[] = [];
-		const promise = new PolyfillPromise(resolve => {
-			actual.push('inCtor');
-			resolve(null);
-		}).then(() => actual.push('inThen'));
-		actual.push('afterCtor');
-		return promise.then(() => {
-			assert.deepEqual(actual, ['inCtor', 'afterCtor', 'inThen']);
-		});
-	});
-
-	test('PolyfillPromise, executor has two params', function () {
-		return new PolyfillPromise(function () {
-			assert.equal(arguments.length, 2);
-			assert.equal(typeof arguments[0], 'function');
-			assert.equal(typeof arguments[1], 'function');
-
-			arguments[0]();
-		});
-	});
-
-	// run the same tests for the native and polyfill promise
-	(<any[]>[Promise, PolyfillPromise]).forEach(PromiseCtor => {
-
-		test(PromiseCtor.name + ', resolved value', function () {
-			return new PromiseCtor(resolve => resolve(1)).then(value => assert.equal(value, 1));
-		});
-
-		test(PromiseCtor.name + ', rejected value', function () {
-			return new PromiseCtor((_, reject) => reject(1)).then(null, value => assert.equal(value, 1));
-		});
-
-		test(PromiseCtor.name + ', catch', function () {
-			return new PromiseCtor((_, reject) => reject(1)).catch(value => assert.equal(value, 1));
-		});
-
-		test(PromiseCtor.name + ', static-resolve', function () {
-			return PromiseCtor.resolve(42).then(value => assert.equal(value, 42));
-		});
-
-		test(PromiseCtor.name + ', static-reject', function () {
-			return PromiseCtor.reject(42).then(null, value => assert.equal(value, 42));
-		});
-
-		test(PromiseCtor.name + ', static-all, 1', function () {
-			return PromiseCtor.all([
-				PromiseCtor.resolve(1),
-				PromiseCtor.resolve(2)
-			]).then(values => {
-				assert.deepEqual(values, [1, 2]);
-			});
-		});
-
-		test(PromiseCtor.name + ', static-all, 2', function () {
-			return PromiseCtor.all([
-				PromiseCtor.resolve(1),
-				3,
-				PromiseCtor.resolve(2)
-			]).then(values => {
-				assert.deepEqual(values, [1, 3, 2]);
-			});
-		});
-
-		test(PromiseCtor.name + ', static-all, 3', function () {
-			return PromiseCtor.all([
-				PromiseCtor.resolve(1),
-				PromiseCtor.reject(13),
-				PromiseCtor.reject(12),
-			]).catch(values => {
-				assert.deepEqual(values, 13);
-			});
-		});
-
-		test(PromiseCtor.name + ', static-race, 1', function () {
-			return PromiseCtor.race([
-				PromiseCtor.resolve(1),
-				PromiseCtor.resolve(2),
-			]).then(value => {
-				assert.deepEqual(value, 1);
-			});
-		});
-
-		test(PromiseCtor.name + ', static-race, 2', function () {
-			return PromiseCtor.race([
-				PromiseCtor.reject(-1),
-				PromiseCtor.resolve(2),
-			]).catch(value => {
-				assert.deepEqual(value, -1);
-			});
-		});
-
-		test(PromiseCtor.name + ', static-race, 3', function () {
-			return PromiseCtor.race([
-				PromiseCtor.resolve(1),
-				PromiseCtor.reject(2),
-			]).then(value => {
-				assert.deepEqual(value, 1);
-			});
-		});
-
-		test(PromiseCtor.name + ', throw in ctor', function () {
-			return new PromiseCtor(() => {
-				throw new Error('sooo bad');
-			}).catch(err => {
-				assert.equal(err.message, 'sooo bad');
-			});
-		});
-
-	});
 });

src/vs/base/test/node/config.test.ts

@@ -14,6 +14,7 @@ import extfs = require('vs/base/node/extfs');
 import uuid = require('vs/base/common/uuid');
 import { ConfigWatcher } from 'vs/base/node/config';
 import { onError } from 'vs/base/test/common/utils';
+import { mkdirp } from 'vs/base/node/pfs';
 
 suite('Config', () => {
 
@@ -23,9 +24,9 @@ suite('Config', () => {
 		const newDir = path.join(parentDir, 'config', id);
 		const testFile = path.join(newDir, 'config.json');
 
-		extfs.mkdirp(newDir, 493, error => {
-			callback(error, testFile, (callback) => extfs.del(parentDir, os.tmpdir(), () => { }, callback));
-		});
+		const onMkdirp = error => callback(error, testFile, (callback) => extfs.del(parentDir, os.tmpdir(), () => { }, callback));
+
+		mkdirp(newDir, 493).done(() => onMkdirp(null), error => onMkdirp(error));
 	}
 
 	test('defaults', function () {

src/vs/base/test/node/encoding/encoding.test.ts

@@ -8,6 +8,7 @@
 import assert = require('assert');
 
 import encoding = require('vs/base/node/encoding');
+import { encodingExists } from 'vs/base/node/encoding';
 
 suite('Encoding', () => {
 	test('detectBOM UTF-8', (done: (err?: any) => void) => {
@@ -54,4 +55,21 @@ suite('Encoding', () => {
 			done();
 		}, done);
 	});
+
+	test('resolve terminal encoding (detect)', function (done: (err?: any) => void) {
+		encoding.resolveTerminalEncoding().then(encoding => {
+			assert.ok(encodingExists(encoding));
+			done();
+		}, done);
+	});
+
+	test('resolve terminal encoding (environment)', function (done: (err?: any) => void) {
+		process.env['VSCODE_CLI_ENCODING'] = 'utf16le';
+
+		encoding.resolveTerminalEncoding().then(encoding => {
+			assert.ok(encodingExists(encoding));
+			assert.equal(encoding, 'utf16le');
+			done();
+		}, done);
+	});
 });

src/vs/base/test/node/extfs/extfs.test.ts

@@ -18,6 +18,10 @@ import { onError } from 'vs/base/test/common/utils';
 
 const ignore = () => { };
 
+const mkdirp = (path: string, mode: number, callback: (error) => void) => {
+	extfs.mkdirp(path, mode).done(() => callback(null), error => callback(error));
+};
+
 suite('Extfs', () => {
 
 	test('mkdirp', function (done: () => void) {
@@ -25,7 +29,7 @@ suite('Extfs', () => {
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
 
-		extfs.mkdirp(newDir, 493, (error) => {
+		mkdirp(newDir, 493, error => {
 			if (error) {
 				return onError(error, done);
 			}
@@ -51,7 +55,7 @@ suite('Extfs', () => {
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
 
-		extfs.mkdirp(newDir, 493, (error) => {
+		mkdirp(newDir, 493, error => {
 			if (error) {
 				return onError(error, done);
 			}
@@ -71,7 +75,7 @@ suite('Extfs', () => {
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
 
-		extfs.mkdirp(newDir, 493, (error) => {
+		mkdirp(newDir, 493, error => {
 			if (error) {
 				return onError(error, done);
 			}
@@ -97,7 +101,7 @@ suite('Extfs', () => {
 		const targetDir = path.join(parentDir, id);
 		const targetDir2 = path.join(parentDir, id2);
 
-		extfs.copy(sourceDir, targetDir, (error) => {
+		extfs.copy(sourceDir, targetDir, error => {
 			if (error) {
 				return onError(error, done);
 			}
@@ -109,7 +113,7 @@ suite('Extfs', () => {
 			assert.ok(fs.statSync(path.join(targetDir, 'examples')).isDirectory());
 			assert.ok(fs.existsSync(path.join(targetDir, 'examples', 'small.jxs')));
 
-			extfs.mv(targetDir, targetDir2, (error) => {
+			extfs.mv(targetDir, targetDir2, error => {
 				if (error) {
 					return onError(error, done);
 				}
@@ -122,7 +126,7 @@ suite('Extfs', () => {
 				assert.ok(fs.statSync(path.join(targetDir2, 'examples')).isDirectory());
 				assert.ok(fs.existsSync(path.join(targetDir2, 'examples', 'small.jxs')));
 
-				extfs.mv(path.join(targetDir2, 'index.html'), path.join(targetDir2, 'index_moved.html'), (error) => {
+				extfs.mv(path.join(targetDir2, 'index.html'), path.join(targetDir2, 'index_moved.html'), error => {
 					if (error) {
 						return onError(error, done);
 					}
@@ -130,11 +134,11 @@ suite('Extfs', () => {
 					assert.ok(!fs.existsSync(path.join(targetDir2, 'index.html')));
 					assert.ok(fs.existsSync(path.join(targetDir2, 'index_moved.html')));
 
-					extfs.del(parentDir, os.tmpdir(), (error) => {
+					extfs.del(parentDir, os.tmpdir(), error => {
 						if (error) {
 							return onError(error, done);
 						}
-					}, (error) => {
+					}, error => {
 						if (error) {
 							return onError(error, done);
 						}
@@ -152,7 +156,7 @@ suite('Extfs', () => {
 			const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 			const newDir = path.join(parentDir, 'extfs', id, 'öäü');
 
-			extfs.mkdirp(newDir, 493, (error) => {
+			mkdirp(newDir, 493, error => {
 				if (error) {
 					return onError(error, done);
 				}
@@ -176,14 +180,14 @@ suite('Extfs', () => {
 		const newDir = path.join(parentDir, 'extfs', id);
 		const testFile = path.join(newDir, 'flushed.txt');
 
-		extfs.mkdirp(newDir, 493, (error) => {
+		mkdirp(newDir, 493, error => {
 			if (error) {
 				return onError(error, done);
 			}
 
 			assert.ok(fs.existsSync(newDir));
 
-			extfs.writeFileAndFlush(testFile, 'Hello World', null, (error) => {
+			extfs.writeFileAndFlush(testFile, 'Hello World', null, error => {
 				if (error) {
 					return onError(error, done);
 				}
@@ -192,7 +196,7 @@ suite('Extfs', () => {
 
 				const largeString = (new Array(100 * 1024)).join('Large String\n');
 
-				extfs.writeFileAndFlush(testFile, largeString, null, (error) => {
+				extfs.writeFileAndFlush(testFile, largeString, null, error => {
 					if (error) {
 						return onError(error, done);
 					}
@@ -205,12 +209,37 @@ suite('Extfs', () => {
 		});
 	});
 
+	test('writeFileAndFlushSync', function (done: () => void) {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'extfs', id);
+		const testFile = path.join(newDir, 'flushed.txt');
+
+		mkdirp(newDir, 493, error => {
+			if (error) {
+				return onError(error, done);
+			}
+
+			assert.ok(fs.existsSync(newDir));
+
+			extfs.writeFileAndFlushSync(testFile, 'Hello World', null);
+			assert.equal(fs.readFileSync(testFile), 'Hello World');
+
+			const largeString = (new Array(100 * 1024)).join('Large String\n');
+
+			extfs.writeFileAndFlushSync(testFile, largeString, null);
+			assert.equal(fs.readFileSync(testFile), largeString);
+
+			extfs.del(parentDir, os.tmpdir(), done, ignore);
+		});
+	});
+
 	test('realcase', (done) => {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
 
-		extfs.mkdirp(newDir, 493, (error) => {
+		mkdirp(newDir, 493, error => {
 
 			// assume case insensitive file system
 			if (process.platform === 'win32' || process.platform === 'darwin') {
@@ -239,7 +268,7 @@ suite('Extfs', () => {
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
 
-		extfs.mkdirp(newDir, 493, (error) => {
+		mkdirp(newDir, 493, error => {
 
 			extfs.realpath(newDir, (error, realpath) => {
 				assert.ok(realpath);
@@ -255,7 +284,7 @@ suite('Extfs', () => {
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
 
-		extfs.mkdirp(newDir, 493, (error) => {
+		mkdirp(newDir, 493, error => {
 			let realpath: string;
 			try {
 				realpath = extfs.realpathSync(newDir);

src/vs/base/test/node/flow.test.ts

@@ -13,45 +13,45 @@ const sequence = flow.sequence;
 const parallel = flow.parallel;
 
 suite('Flow', () => {
-	function assertCounterEquals(counter, expected): void {
+	function assertCounterEquals(counter: number, expected: number): void {
 		assert.ok(counter === expected, 'Expected ' + expected + ' assertions, but got ' + counter);
 	}
 
-	function syncThrowsError(callback): void {
+	function syncThrowsError(callback: any): void {
 		callback(new Error('foo'), null);
 	}
 
-	function syncSequenceGetThrowsError(value, callback) {
+	function syncSequenceGetThrowsError(value: any, callback: any) {
 		sequence(
 			function onError(error) {
 				callback(error, null);
 			},
 
-			function getFirst() {
+			function getFirst(this: any) {
 				syncThrowsError(this);
 			},
 
-			function handleFirst(first) {
+			function handleFirst(first: number) {
 				//Foo
 			}
 		);
 	}
 
-	function syncGet(value, callback): void {
+	function syncGet(value: any, callback: any): void {
 		callback(null, value);
 	}
 
-	function syncGetError(value, callback): void {
+	function syncGetError(value: any, callback: any): void {
 		callback(new Error(''), null);
 	}
 
-	function asyncGet(value, callback): void {
+	function asyncGet(value: any, callback: any): void {
 		process.nextTick(function () {
 			callback(null, value);
 		});
 	}
 
-	function asyncGetError(value, callback): void {
+	function asyncGetError(value: any, callback: any): void {
 		process.nextTick(function () {
 			callback(new Error(''), null);
 		});
@@ -72,7 +72,7 @@ suite('Flow', () => {
 	});
 
 	test('loopByFunctionSync', function (done: () => void) {
-		const elements = function (callback) {
+		const elements = function (callback: Function) {
 			callback(null, ['1', '2', '3']);
 		};
 
@@ -87,7 +87,7 @@ suite('Flow', () => {
 	});
 
 	test('loopByFunctionAsync', function (done: () => void) {
-		const elements = function (callback) {
+		const elements = function (callback: Function) {
 			process.nextTick(function () {
 				callback(null, ['1', '2', '3']);
 			});
@@ -176,23 +176,23 @@ suite('Flow', () => {
 				errorCount++;
 			},
 
-			function getFirst() {
+			function getFirst(this: any) {
 				syncGet('1', this);
 			},
 
-			function handleFirst(first) {
+			function handleFirst(this: any, first: number) {
 				assert.deepEqual('1', first);
 				assertionCount++;
 				syncGet('2', this);
 			},
 
-			function handleSecond(second) {
+			function handleSecond(this: any, second: any) {
 				assert.deepEqual('2', second);
 				assertionCount++;
 				syncGet(null, this);
 			},
 
-			function handleThird(third) {
+			function handleThird(third: any) {
 				assert.ok(!third);
 				assertionCount++;
 
@@ -212,23 +212,23 @@ suite('Flow', () => {
 				errorCount++;
 			},
 
-			function getFirst() {
+			function getFirst(this: any) {
 				asyncGet('1', this);
 			},
 
-			function handleFirst(first) {
+			function handleFirst(this: any, first: number) {
 				assert.deepEqual('1', first);
 				assertionCount++;
 				asyncGet('2', this);
 			},
 
-			function handleSecond(second) {
+			function handleSecond(this: any, second: number) {
 				assert.deepEqual('2', second);
 				assertionCount++;
 				asyncGet(null, this);
 			},
 
-			function handleThird(third) {
+			function handleThird(third: number) {
 				assert.ok(!third);
 				assertionCount++;
 
@@ -252,17 +252,17 @@ suite('Flow', () => {
 				done();
 			},
 
-			function getFirst() {
+			function getFirst(this: any) {
 				syncGet('1', this);
 			},
 
-			function handleFirst(first) {
+			function handleFirst(this: any, first: number) {
 				assert.deepEqual('1', first);
 				assertionCount++;
 				syncGet('2', this);
 			},
 
-			function handleSecond(second) {
+			function handleSecond(second: number) {
 				if (true) {
 					throw new Error('');
 				}
@@ -270,7 +270,7 @@ suite('Flow', () => {
 				// syncGet(null, this);
 			},
 
-			function handleThird(third) {
+			function handleThird(third: number) {
 				throw new Error('We should not be here');
 			}
 		);
@@ -289,17 +289,17 @@ suite('Flow', () => {
 				done();
 			},
 
-			function getFirst() {
+			function getFirst(this: any) {
 				syncGet('1', this);
 			},
 
-			function handleFirst(first) {
+			function handleFirst(this: any, first: number) {
 				assert.deepEqual('1', first);
 				assertionCount++;
 				syncGetError('2', this);
 			},
 
-			function handleSecond(second) {
+			function handleSecond(second: number) {
 				throw new Error('We should not be here');
 			}
 		);
@@ -318,17 +318,17 @@ suite('Flow', () => {
 				done();
 			},
 
-			function getFirst() {
+			function getFirst(this: any) {
 				asyncGet('1', this);
 			},
 
-			function handleFirst(first) {
+			function handleFirst(this: any, first: number) {
 				assert.deepEqual('1', first);
 				assertionCount++;
 				asyncGet('2', this);
 			},
 
-			function handleSecond(second) {
+			function handleSecond(second: number) {
 				if (true) {
 					throw new Error('');
 				}
@@ -336,7 +336,7 @@ suite('Flow', () => {
 				// asyncGet(null, this);
 			},
 
-			function handleThird(third) {
+			function handleThird(third: number) {
 				throw new Error('We should not be here');
 			}
 		);
@@ -355,17 +355,17 @@ suite('Flow', () => {
 				done();
 			},
 
-			function getFirst() {
+			function getFirst(this: any) {
 				asyncGet('1', this);
 			},
 
-			function handleFirst(first) {
+			function handleFirst(this: any, first: number) {
 				assert.deepEqual('1', first);
 				assertionCount++;
 				asyncGetError('2', this);
 			},
 
-			function handleSecond(second) {
+			function handleSecond(second: number) {
 				throw new Error('We should not be here');
 			}
 		);
@@ -377,7 +377,7 @@ suite('Flow', () => {
 				done();
 			},
 
-			function getFirst() {
+			function getFirst(this: any) {
 				syncSequenceGetThrowsError('1', this);
 			}
 		);
@@ -392,16 +392,16 @@ suite('Flow', () => {
 				errorCount++;
 			},
 
-			function getFirst() {
+			function getFirst(this: any) {
 				this(true);
 			},
 
-			function getSecond(result) {
+			function getSecond(this: any, result: boolean) {
 				assert.equal(result, true);
 				this(false);
 			},
 
-			function last(result) {
+			function last(result: boolean) {
 				assert.equal(result, false);
 				assertionCount++;
 

src/vs/base/test/node/glob.test.ts

@@ -416,7 +416,7 @@ suite('Glob', () => {
 
 		assert.strictEqual(glob.match(expression, 'test.js', () => siblings), null);
 
-		expression = <any>{
+		expression = {
 			'**/*.js': {
 			}
 		};
@@ -460,6 +460,46 @@ suite('Glob', () => {
 		assert(!glob.match(p, 'foo.8'));
 		assert(!glob.match(p, 'bar.5'));
 		assert(glob.match(p, 'foo.f'));
+
+		p = 'foo.[!0-9]';
+
+		assert(!glob.match(p, 'foo.5'));
+		assert(!glob.match(p, 'foo.8'));
+		assert(!glob.match(p, 'bar.5'));
+		assert(glob.match(p, 'foo.f'));
+
+		p = 'foo.[0!^*?]';
+
+		assert(!glob.match(p, 'foo.5'));
+		assert(!glob.match(p, 'foo.8'));
+		assert(glob.match(p, 'foo.0'));
+		assert(glob.match(p, 'foo.!'));
+		assert(glob.match(p, 'foo.^'));
+		assert(glob.match(p, 'foo.*'));
+		assert(glob.match(p, 'foo.?'));
+
+		p = 'foo[/]bar';
+
+		assert(!glob.match(p, 'foo/bar'));
+
+		p = 'foo.[[]';
+
+		assert(glob.match(p, 'foo.['));
+
+		p = 'foo.[]]';
+
+		assert(glob.match(p, 'foo.]'));
+
+		p = 'foo.[][!]';
+
+		assert(glob.match(p, 'foo.]'));
+		assert(glob.match(p, 'foo.['));
+		assert(glob.match(p, 'foo.!'));
+
+		p = 'foo.[]-]';
+
+		assert(glob.match(p, 'foo.]'));
+		assert(glob.match(p, 'foo.-'));
 	});
 
 	test('full path', function () {
@@ -867,35 +907,16 @@ suite('Glob', () => {
 		return slashPath.replace(/\//g, path.sep);
 	}
 
-	test('mergeExpressions', () => {
-		// Empty => empty
-		assert.deepEqual(glob.mergeExpressions(), glob.getEmptyExpression());
-
-		// Doesn't modify given expressions
-		const expr1 = { 'a': true };
-		glob.mergeExpressions(expr1, { 'b': true });
-		assert.deepEqual(expr1, { 'a': true });
-
-		// Merges correctly
-		assert.deepEqual(glob.mergeExpressions({ 'a': true }, { 'b': true }), { 'a': true, 'b': true });
-
-		// Ignores null/undefined portions
-		assert.deepEqual(glob.mergeExpressions(undefined, { 'a': true }, null, { 'b': true }), { 'a': true, 'b': true });
-
-		// Later expressions take precedence
-		assert.deepEqual(glob.mergeExpressions({ 'a': true, 'b': false, 'c': true }, { 'a': false, 'b': true }), { 'a': false, 'b': true, 'c': true });
-	});
-
 	test('relative pattern - glob star', function () {
 		if (isWindows) {
-			let p = { base: 'C:\\DNXConsoleApp\\foo', pattern: '**/*.cs' };
+			let p: glob.IRelativePattern = { base: 'C:\\DNXConsoleApp\\foo', pattern: '**/*.cs', pathToRelative: (from, to) => path.relative(from, to) };
 			assert(glob.match(p, 'C:\\DNXConsoleApp\\foo\\Program.cs'));
 			assert(glob.match(p, 'C:\\DNXConsoleApp\\foo\\bar\\Program.cs'));
 			assert(!glob.match(p, 'C:\\DNXConsoleApp\\foo\\Program.ts'));
 			assert(!glob.match(p, 'C:\\DNXConsoleApp\\Program.cs'));
 			assert(!glob.match(p, 'C:\\other\\DNXConsoleApp\\foo\\Program.ts'));
 		} else {
-			let p: glob.IRelativePattern = { base: '/DNXConsoleApp/foo', pattern: '**/*.cs' };
+			let p: glob.IRelativePattern = { base: '/DNXConsoleApp/foo', pattern: '**/*.cs', pathToRelative: (from, to) => path.relative(from, to) };
 			assert(glob.match(p, '/DNXConsoleApp/foo/Program.cs'));
 			assert(glob.match(p, '/DNXConsoleApp/foo/bar/Program.cs'));
 			assert(!glob.match(p, '/DNXConsoleApp/foo/Program.ts'));
@@ -906,14 +927,14 @@ suite('Glob', () => {
 
 	test('relative pattern - single star', function () {
 		if (isWindows) {
-			let p = { base: 'C:\\DNXConsoleApp\\foo', pattern: '*.cs' };
+			let p: glob.IRelativePattern = { base: 'C:\\DNXConsoleApp\\foo', pattern: '*.cs', pathToRelative: (from, to) => path.relative(from, to) };
 			assert(glob.match(p, 'C:\\DNXConsoleApp\\foo\\Program.cs'));
 			assert(!glob.match(p, 'C:\\DNXConsoleApp\\foo\\bar\\Program.cs'));
 			assert(!glob.match(p, 'C:\\DNXConsoleApp\\foo\\Program.ts'));
 			assert(!glob.match(p, 'C:\\DNXConsoleApp\\Program.cs'));
 			assert(!glob.match(p, 'C:\\other\\DNXConsoleApp\\foo\\Program.ts'));
 		} else {
-			let p: glob.IRelativePattern = { base: '/DNXConsoleApp/foo', pattern: '*.cs' };
+			let p: glob.IRelativePattern = { base: '/DNXConsoleApp/foo', pattern: '*.cs', pathToRelative: (from, to) => path.relative(from, to) };
 			assert(glob.match(p, '/DNXConsoleApp/foo/Program.cs'));
 			assert(!glob.match(p, '/DNXConsoleApp/foo/bar/Program.cs'));
 			assert(!glob.match(p, '/DNXConsoleApp/foo/Program.ts'));
@@ -924,11 +945,11 @@ suite('Glob', () => {
 
 	test('relative pattern - single star with path', function () {
 		if (isWindows) {
-			let p = { base: 'C:\\DNXConsoleApp\\foo', pattern: 'something/*.cs' };
+			let p: glob.IRelativePattern = { base: 'C:\\DNXConsoleApp\\foo', pattern: 'something/*.cs', pathToRelative: (from, to) => path.relative(from, to) };
 			assert(glob.match(p, 'C:\\DNXConsoleApp\\foo\\something\\Program.cs'));
 			assert(!glob.match(p, 'C:\\DNXConsoleApp\\foo\\Program.cs'));
 		} else {
-			let p: glob.IRelativePattern = { base: '/DNXConsoleApp/foo', pattern: 'something/*.cs' };
+			let p: glob.IRelativePattern = { base: '/DNXConsoleApp/foo', pattern: 'something/*.cs', pathToRelative: (from, to) => path.relative(from, to) };
 			assert(glob.match(p, '/DNXConsoleApp/foo/something/Program.cs'));
 			assert(!glob.match(p, '/DNXConsoleApp/foo/Program.cs'));
 		}

src/vs/base/test/node/id.test.ts

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import * as assert from 'assert';
+import { getMachineId } from 'vs/base/node/id';
+
+suite('ID', () => {
+
+	test('getMachineId', function () {
+		return getMachineId().then(id => {
+			assert.ok(id);
+		});
+	});
+});

src/vs/base/test/node/mime/mime.test.ts

@@ -9,29 +9,34 @@ import assert = require('assert');
 
 import mimeCommon = require('vs/base/common/mime');
 import mime = require('vs/base/node/mime');
+import { readExactlyByFile } from 'vs/base/node/stream';
 
 suite('Mime', () => {
 
 	test('detectMimesFromFile (JSON saved as PNG)', function (done: (err?: any) => void) {
 		const file = require.toUrl('./fixtures/some.json.png');
-		mime.detectMimesFromFile(file).then(mimes => {
+
+		readExactlyByFile(file, 512).then(buffer => {
+			const mimes = mime.detectMimeAndEncodingFromBuffer(buffer);
 			assert.deepEqual(mimes.mimes, ['text/plain']);
 			done();
-		}, done);
+		});
 	});
 
 	test('detectMimesFromFile (PNG saved as TXT)', function (done: (err?: any) => void) {
 		mimeCommon.registerTextMime({ id: 'text', mime: 'text/plain', extension: '.txt' });
 		const file = require.toUrl('./fixtures/some.png.txt');
-		mime.detectMimesFromFile(file).then(mimes => {
-			assert.deepEqual(mimes.mimes, ['text/plain', 'application/octet-stream']);
+		readExactlyByFile(file, 512).then(buffer => {
+			const mimes = mime.detectMimeAndEncodingFromBuffer(buffer);
+			assert.deepEqual(mimes.mimes, ['application/octet-stream']);
 			done();
 		}, done);
 	});
 
 	test('detectMimesFromFile (XML saved as PNG)', function (done: (err?: any) => void) {
 		const file = require.toUrl('./fixtures/some.xml.png');
-		mime.detectMimesFromFile(file).then(mimes => {
+		readExactlyByFile(file, 512).then(buffer => {
+			const mimes = mime.detectMimeAndEncodingFromBuffer(buffer);
 			assert.deepEqual(mimes.mimes, ['text/plain']);
 			done();
 		}, done);
@@ -39,15 +44,17 @@ suite('Mime', () => {
 
 	test('detectMimesFromFile (QWOFF saved as TXT)', function (done: (err?: any) => void) {
 		const file = require.toUrl('./fixtures/some.qwoff.txt');
-		mime.detectMimesFromFile(file).then(mimes => {
-			assert.deepEqual(mimes.mimes, ['text/plain', 'application/octet-stream']);
+		readExactlyByFile(file, 512).then(buffer => {
+			const mimes = mime.detectMimeAndEncodingFromBuffer(buffer);
+			assert.deepEqual(mimes.mimes, ['application/octet-stream']);
 			done();
 		}, done);
 	});
 
 	test('detectMimesFromFile (CSS saved as QWOFF)', function (done: (err?: any) => void) {
 		const file = require.toUrl('./fixtures/some.css.qwoff');
-		mime.detectMimesFromFile(file).then(mimes => {
+		readExactlyByFile(file, 512).then(buffer => {
+			const mimes = mime.detectMimeAndEncodingFromBuffer(buffer);
 			assert.deepEqual(mimes.mimes, ['text/plain']);
 			done();
 		}, done);
@@ -55,7 +62,8 @@ suite('Mime', () => {
 
 	test('detectMimesFromFile (PDF)', function (done: () => void) {
 		const file = require.toUrl('./fixtures/some.pdf');
-		mime.detectMimesFromFile(file).then(mimes => {
+		readExactlyByFile(file, 512).then(buffer => {
+			const mimes = mime.detectMimeAndEncodingFromBuffer(buffer);
 			assert.deepEqual(mimes.mimes, ['application/octet-stream']);
 			done();
 		}, done);
@@ -63,17 +71,21 @@ suite('Mime', () => {
 
 	test('autoGuessEncoding (ShiftJIS)', function (done: () => void) {
 		const file = require.toUrl('./fixtures/some.shiftjis.txt');
-		mime.detectMimesFromFile(file, { autoGuessEncoding: true }).then(mimes => {
-			assert.equal(mimes.encoding, 'shiftjis');
-			done();
+		readExactlyByFile(file, 512 * 8).then(buffer => {
+			mime.detectMimeAndEncodingFromBuffer(buffer, true).then(mimes => {
+				assert.equal(mimes.encoding, 'shiftjis');
+				done();
+			});
 		}, done);
 	});
 
 	test('autoGuessEncoding (CP1252)', function (done: () => void) {
 		const file = require.toUrl('./fixtures/some.cp1252.txt');
-		mime.detectMimesFromFile(file, { autoGuessEncoding: true }).then(mimes => {
-			assert.equal(mimes.encoding, 'windows1252');
-			done();
+		readExactlyByFile(file, 512 * 8).then(buffer => {
+			mime.detectMimeAndEncodingFromBuffer(buffer, true).then(mimes => {
+				assert.equal(mimes.encoding, 'windows1252');
+				done();
+			});
 		}, done);
 	});
 });

src/vs/base/test/node/pfs.test.ts

@@ -25,7 +25,7 @@ suite('PFS', () => {
 		const newDir = path.join(parentDir, 'pfs', id);
 		const testFile = path.join(newDir, 'writefile.txt');
 
-		extfs.mkdirp(newDir, 493, (error) => {
+		const onMkdirp = error => {
 			if (error) {
 				return onError(error, done);
 			}
@@ -37,7 +37,9 @@ suite('PFS', () => {
 
 				extfs.del(parentDir, os.tmpdir(), () => { }, done);
 			}, error => onError(error, done));
-		});
+		};
+
+		pfs.mkdirp(newDir, 493).done(() => onMkdirp(null), error => onMkdirp(error));
 	});
 
 	test('writeFile - parallel write on different files works', function (done: () => void) {
@@ -50,7 +52,7 @@ suite('PFS', () => {
 		const testFile4 = path.join(newDir, 'writefile4.txt');
 		const testFile5 = path.join(newDir, 'writefile5.txt');
 
-		extfs.mkdirp(newDir, 493, (error) => {
+		const onMkdirp = error => {
 			if (error) {
 				return onError(error, done);
 			}
@@ -72,7 +74,9 @@ suite('PFS', () => {
 
 				extfs.del(parentDir, os.tmpdir(), () => { }, done);
 			}, error => onError(error, done));
-		});
+		};
+
+		pfs.mkdirp(newDir, 493).done(() => onMkdirp(null), error => onMkdirp(error));
 	});
 
 	test('writeFile - parallel write on same files works and is sequentalized', function (done: () => void) {
@@ -81,7 +85,7 @@ suite('PFS', () => {
 		const newDir = path.join(parentDir, 'pfs', id);
 		const testFile = path.join(newDir, 'writefile.txt');
 
-		extfs.mkdirp(newDir, 493, (error) => {
+		const onMkdirp = error => {
 			if (error) {
 				return onError(error, done);
 			}
@@ -99,7 +103,9 @@ suite('PFS', () => {
 
 				extfs.del(parentDir, os.tmpdir(), () => { }, done);
 			}, error => onError(error, done));
-		});
+		};
+
+		pfs.mkdirp(newDir, 493).done(() => onMkdirp(null), error => onMkdirp(error));
 	});
 
 	test('rimraf - simple', function (done: () => void) {
@@ -107,7 +113,7 @@ suite('PFS', () => {
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
 
-		extfs.mkdirp(newDir, 493, (error) => {
+		const onMkdirp = error => {
 			if (error) {
 				return onError(error, done);
 			}
@@ -119,7 +125,9 @@ suite('PFS', () => {
 				assert.ok(!fs.existsSync(newDir));
 				done();
 			}, error => onError(error, done));
-		}); // 493 = 0755
+		};
+
+		pfs.mkdirp(newDir, 493).done(() => onMkdirp(null), error => onMkdirp(error));
 	});
 
 	test('rimraf - recursive folder structure', function (done: () => void) {
@@ -127,7 +135,7 @@ suite('PFS', () => {
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
 
-		extfs.mkdirp(newDir, 493, (error) => {
+		const onMkdirp = error => {
 			if (error) {
 				return onError(error, done);
 			}
@@ -142,6 +150,8 @@ suite('PFS', () => {
 				assert.ok(!fs.existsSync(newDir));
 				done();
 			}, error => onError(error, done));
-		}); // 493 = 0755
+		};
+
+		pfs.mkdirp(newDir, 493).done(() => onMkdirp(null), error => onMkdirp(error));
 	});
 });

src/vs/base/test/node/port.test.ts

@@ -18,7 +18,7 @@ suite('Ports', () => {
 		}
 
 		// get an initial freeport >= 7000
-		ports.findFreePort(7000, 100, 300000, (initialPort) => {
+		ports.findFreePort(7000, 100, 300000).then(initialPort => {
 			assert.ok(initialPort >= 7000);
 
 			// create a server to block this port
@@ -26,7 +26,7 @@ suite('Ports', () => {
 			server.listen(initialPort, null, null, () => {
 
 				// once listening, find another free port and assert that the port is different from the opened one
-				ports.findFreePort(7000, 50, 300000, (freePort) => {
+				ports.findFreePort(7000, 50, 300000).then(freePort => {
 					assert.ok(freePort >= 7000 && freePort !== initialPort);
 					server.close();
 

src/vs/base/test/node/processes/processes.test.ts

@@ -14,7 +14,7 @@ import processes = require('vs/base/node/processes');
 
 function fork(id: string): cp.ChildProcess {
 	const opts: any = {
-		env: objects.mixin(objects.clone(process.env), {
+		env: objects.mixin(objects.deepClone(process.env), {
 			AMD_ENTRYPOINT: id,
 			PIPE_LOGGING: 'true',
 			VERBOSE_LOGGING: true
@@ -86,4 +86,4 @@ suite('Processes', () => {
 			}
 		});
 	});
-});
+});

src/vs/base/test/node/stream/stream.test.ts

@@ -6,7 +6,6 @@
 'use strict';
 
 import assert = require('assert');
-import fs = require('fs');
 
 import stream = require('vs/base/node/stream');
 
@@ -30,25 +29,6 @@ suite('Stream', () => {
 		}, done);
 	});
 
-	test('readExactlyByStream - ANSI', function (done: (err?: any) => void) {
-		const file = require.toUrl('./fixtures/file.css');
-
-		stream.readExactlyByStream(fs.createReadStream(file), 10).then(({ buffer, bytesRead }) => {
-			assert.equal(bytesRead, 10);
-			assert.equal(buffer.toString(), '/*--------');
-			done();
-		}, done);
-	});
-
-	test('readExactlyByStream - empty', function (done: (err?: any) => void) {
-		const file = require.toUrl('./fixtures/empty.txt');
-
-		stream.readExactlyByStream(fs.createReadStream(file), 10).then(({ bytesRead }) => {
-			assert.equal(bytesRead, 0);
-			done();
-		}, done);
-	});
-
 	test('readToMatchingString - ANSI', function (done: (err?: any) => void) {
 		const file = require.toUrl('./fixtures/file.css');