Merge VS Code 1.23.1 (#1520)

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

@@ -5,11 +5,24 @@
 'use strict';
 
 import * as assert from 'assert';
-import { Build, Builder, MultiBuilder, $, bindElement, withElement, setPropertyOnElement, getPropertyFromElement } from 'vs/base/browser/builder';
+import { 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';
 import { IDisposable } from 'vs/base/common/lifecycle';
+import { timeout } from 'vs/base/common/async';
+
+function withElementById(id: string, offdom?: boolean): Builder {
+	let element = document.getElementById(id);
+	if (element) {
+		return new Builder(element, offdom);
+	}
+
+	return null;
+}
+
+const Build = {
+	withElementById: withElementById
+};
 
 let withElementsBySelector = function (selector: string, offdom: boolean = false) {
 	let elements = window.document.querySelectorAll(selector);

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

@@ -6,7 +6,6 @@
 
 import * as assert from 'assert';
 import { ProgressBar } from 'vs/base/browser/ui/progressbar/progressbar';
-import { Builder } from 'vs/base/browser/builder';
 
 suite('ProgressBar', () => {
 	let fixture: HTMLElement;
@@ -21,10 +20,7 @@ suite('ProgressBar', () => {
 	});
 
 	test('Progress Bar', function () {
-		const b = new Builder(fixture);
-
-		const bar = new ProgressBar(b);
-		assert(bar.getContainer());
+		const bar = new ProgressBar(fixture);
 		assert(bar.infinite());
 		assert(bar.total(100));
 		assert(bar.worked(50));

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

@@ -3,7 +3,7 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import assert = require('assert');
+import * as assert from 'assert';
 import { RangeMap, intersect, groupIntersect, consolidate } from 'vs/base/browser/ui/list/rangeMap';
 
 suite('RangeMap', () => {

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

@@ -6,32 +6,31 @@
 
 import * as assert from 'assert';
 import { TPromise } from 'vs/base/common/winjs.base';
-import arrays = require('vs/base/common/arrays');
-import { coalesce } from 'vs/base/common/arrays';
+import * as arrays from 'vs/base/common/arrays';
 
 suite('Arrays', () => {
 	test('findFirst', function () {
 		const array = [1, 4, 5, 7, 55, 59, 60, 61, 64, 69];
 
-		let idx = arrays.findFirst(array, e => e >= 0);
+		let idx = arrays.findFirstInSorted(array, e => e >= 0);
 		assert.equal(array[idx], 1);
 
-		idx = arrays.findFirst(array, e => e > 1);
+		idx = arrays.findFirstInSorted(array, e => e > 1);
 		assert.equal(array[idx], 4);
 
-		idx = arrays.findFirst(array, e => e >= 8);
+		idx = arrays.findFirstInSorted(array, e => e >= 8);
 		assert.equal(array[idx], 55);
 
-		idx = arrays.findFirst(array, e => e >= 61);
+		idx = arrays.findFirstInSorted(array, e => e >= 61);
 		assert.equal(array[idx], 61);
 
-		idx = arrays.findFirst(array, e => e >= 69);
+		idx = arrays.findFirstInSorted(array, e => e >= 69);
 		assert.equal(array[idx], 69);
 
-		idx = arrays.findFirst(array, e => e >= 70);
+		idx = arrays.findFirstInSorted(array, e => e >= 70);
 		assert.equal(idx, array.length);
 
-		idx = arrays.findFirst([], e => e >= 0);
+		idx = arrays.findFirstInSorted([], e => e >= 0);
 		assert.equal(array[idx], 1);
 	});
 
@@ -76,7 +75,7 @@ suite('Arrays', () => {
 			for (let i = 1; i < array.length; i++) {
 				let n = array[i];
 				if (last > n) {
-					assert.fail(array.slice(i - 10, i + 10));
+					assert.fail(JSON.stringify(array.slice(i - 10, i + 10)));
 				}
 			}
 		}
@@ -218,18 +217,17 @@ suite('Arrays', () => {
 		assert.deepEqual(arrays.top([4, 6, 2, 7, 8, 3, 5, 1], cmp, 3), [1, 2, 3]);
 	});
 
-	test('topAsync', function (done) {
+	test('topAsync', function () {
 		const cmp = (a: number, b: number) => {
 			assert.strictEqual(typeof a, 'number', 'typeof a');
 			assert.strictEqual(typeof b, 'number', 'typeof b');
 			return a - b;
 		};
 
-		testTopAsync(cmp, 1)
+		return testTopAsync(cmp, 1)
 			.then(() => {
 				return testTopAsync(cmp, 2);
-			})
-			.then(done, done);
+			});
 	});
 
 	function testTopAsync(cmp: any, m: number) {
@@ -272,13 +270,13 @@ suite('Arrays', () => {
 	}
 
 	test('coalesce', function () {
-		let a = coalesce([null, 1, null, 2, 3]);
+		let a = arrays.coalesce([null, 1, null, 2, 3]);
 		assert.equal(a.length, 3);
 		assert.equal(a[0], 1);
 		assert.equal(a[1], 2);
 		assert.equal(a[2], 3);
 
-		coalesce([null, 1, null, void 0, undefined, 2, 3]);
+		arrays.coalesce([null, 1, null, void 0, undefined, 2, 3]);
 		assert.equal(a.length, 3);
 		assert.equal(a[0], 1);
 		assert.equal(a[1], 2);
@@ -288,7 +286,7 @@ suite('Arrays', () => {
 		b[10] = 1;
 		b[20] = 2;
 		b[30] = 3;
-		b = coalesce(b);
+		b = arrays.coalesce(b);
 		assert.equal(b.length, 3);
 		assert.equal(b[0], 1);
 		assert.equal(b[1], 2);
@@ -303,7 +301,7 @@ suite('Arrays', () => {
 
 		assert.equal(sparse.length, 1002);
 
-		sparse = coalesce(sparse);
+		sparse = arrays.coalesce(sparse);
 		assert.equal(sparse.length, 5);
 	});
 });

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

@@ -6,11 +6,11 @@
 
 import * as assert from 'assert';
 import { Promise, TPromise } from 'vs/base/common/winjs.base';
-import Async = require('vs/base/common/async');
+import * as Async from 'vs/base/common/async';
 import URI from 'vs/base/common/uri';
 
 suite('Async', () => {
-	test('Throttler - non async', function (done) {
+	test('Throttler - non async', function () {
 		let count = 0;
 		let factory = () => {
 			return TPromise.as(++count);
@@ -18,16 +18,16 @@ suite('Async', () => {
 
 		let throttler = new Async.Throttler();
 
-		Promise.join([
+		return Promise.join([
 			throttler.queue(factory).then((result) => { assert.equal(result, 1); }),
 			throttler.queue(factory).then((result) => { assert.equal(result, 2); }),
 			throttler.queue(factory).then((result) => { assert.equal(result, 3); }),
 			throttler.queue(factory).then((result) => { assert.equal(result, 4); }),
 			throttler.queue(factory).then((result) => { assert.equal(result, 5); })
-		]).done(() => done());
+		]);
 	});
 
-	test('Throttler', function (done) {
+	test('Throttler', function () {
 		let count = 0;
 		let factory = () => {
 			return TPromise.timeout(0).then(() => {
@@ -37,24 +37,24 @@ suite('Async', () => {
 
 		let throttler = new Async.Throttler();
 
-		Promise.join([
+		return Promise.join([
 			throttler.queue(factory).then((result) => { assert.equal(result, 1); }),
 			throttler.queue(factory).then((result) => { assert.equal(result, 2); }),
 			throttler.queue(factory).then((result) => { assert.equal(result, 2); }),
 			throttler.queue(factory).then((result) => { assert.equal(result, 2); }),
 			throttler.queue(factory).then((result) => { assert.equal(result, 2); })
-		]).done(() => {
+		]).then(() => {
 			Promise.join([
 				throttler.queue(factory).then((result) => { assert.equal(result, 3); }),
 				throttler.queue(factory).then((result) => { assert.equal(result, 4); }),
 				throttler.queue(factory).then((result) => { assert.equal(result, 4); }),
 				throttler.queue(factory).then((result) => { assert.equal(result, 4); }),
 				throttler.queue(factory).then((result) => { assert.equal(result, 4); })
-			]).done(() => done());
+			]);
 		});
 	});
 
-	test('Throttler - cancel should not cancel other promises', function (done) {
+	test('Throttler - cancel should not cancel other promises', function () {
 		let count = 0;
 		let factory = () => {
 			return TPromise.timeout(0).then(() => {
@@ -65,17 +65,19 @@ suite('Async', () => {
 		let throttler = new Async.Throttler();
 		let p1: Promise;
 
-		Promise.join([
+		const p = Promise.join([
 			p1 = throttler.queue(factory).then((result) => { assert(false, 'should not be here, 1'); }, () => { assert(true, 'yes, it was cancelled'); }),
 			throttler.queue(factory).then((result) => { assert.equal(result, 1); }, () => { assert(false, 'should not be here, 2'); }),
 			throttler.queue(factory).then((result) => { assert.equal(result, 1); }, () => { assert(false, 'should not be here, 3'); }),
 			throttler.queue(factory).then((result) => { assert.equal(result, 1); }, () => { assert(false, 'should not be here, 4'); })
-		]).done(() => done());
+		]);
 
 		p1.cancel();
+
+		return p;
 	});
 
-	test('Throttler - cancel the first queued promise should not cancel other promises', function (done) {
+	test('Throttler - cancel the first queued promise should not cancel other promises', function () {
 		let count = 0;
 		let factory = () => {
 			return TPromise.timeout(0).then(() => {
@@ -86,17 +88,19 @@ suite('Async', () => {
 		let throttler = new Async.Throttler();
 		let p2: Promise;
 
-		Promise.join([
+		const p = Promise.join([
 			throttler.queue(factory).then((result) => { assert.equal(result, 1); }, () => { assert(false, 'should not be here, 1'); }),
 			p2 = throttler.queue(factory).then((result) => { assert(false, 'should not be here, 2'); }, () => { assert(true, 'yes, it was cancelled'); }),
 			throttler.queue(factory).then((result) => { assert.equal(result, 2); }, () => { assert(false, 'should not be here, 3'); }),
 			throttler.queue(factory).then((result) => { assert.equal(result, 2); }, () => { assert(false, 'should not be here, 4'); })
-		]).done(() => done());
+		]);
 
 		p2.cancel();
+
+		return p;
 	});
 
-	test('Throttler - cancel in the middle should not cancel other promises', function (done) {
+	test('Throttler - cancel in the middle should not cancel other promises', function () {
 		let count = 0;
 		let factory = () => {
 			return TPromise.timeout(0).then(() => {
@@ -107,17 +111,19 @@ suite('Async', () => {
 		let throttler = new Async.Throttler();
 		let p3: Promise;
 
-		Promise.join([
+		const p = Promise.join([
 			throttler.queue(factory).then((result) => { assert.equal(result, 1); }, () => { assert(false, 'should not be here, 1'); }),
 			throttler.queue(factory).then((result) => { assert.equal(result, 2); }, () => { assert(false, 'should not be here, 2'); }),
 			p3 = throttler.queue(factory).then((result) => { assert(false, 'should not be here, 3'); }, () => { assert(true, 'yes, it was cancelled'); }),
 			throttler.queue(factory).then((result) => { assert.equal(result, 2); }, () => { assert(false, 'should not be here, 4'); })
-		]).done(() => done());
+		]);
 
 		p3.cancel();
+
+		return p;
 	});
 
-	test('Throttler - last factory should be the one getting called', function (done) {
+	test('Throttler - last factory should be the one getting called', function () {
 		let factoryFactory = (n: number) => () => {
 			return TPromise.timeout(0).then(() => n);
 		};
@@ -130,10 +136,10 @@ suite('Async', () => {
 		promises.push(throttler.queue(factoryFactory(2)).then((n) => { assert.equal(n, 3); }));
 		promises.push(throttler.queue(factoryFactory(3)).then((n) => { assert.equal(n, 3); }));
 
-		Promise.join(promises).done(() => done());
+		return Promise.join(promises);
 	});
 
-	test('Throttler - progress should work', function (done) {
+	test('Throttler - progress should work', function () {
 		let order = 0;
 		let factory = () => new TPromise((c, e, p) => {
 			TPromise.timeout(0).done(() => {
@@ -150,15 +156,14 @@ suite('Async', () => {
 		promises.push(throttler.queue(factory).then(null, null, (p) => progresses[1].push(p)));
 		promises.push(throttler.queue(factory).then(null, null, (p) => progresses[2].push(p)));
 
-		Promise.join(promises).done(() => {
+		return Promise.join(promises).then(() => {
 			assert.deepEqual(progresses[0], [0]);
 			assert.deepEqual(progresses[1], [0]);
 			assert.deepEqual(progresses[2], [0]);
-			done();
 		});
 	});
 
-	test('Delayer', function (done) {
+	test('Delayer', function () {
 		let count = 0;
 		let factory = () => {
 			return TPromise.as(++count);
@@ -178,13 +183,12 @@ suite('Async', () => {
 		promises.push(delayer.trigger(factory).then((result) => { assert.equal(result, 1); assert(!delayer.isTriggered()); }));
 		assert(delayer.isTriggered());
 
-		Promise.join(promises).done(() => {
+		return Promise.join(promises).then(() => {
 			assert(!delayer.isTriggered());
-			done();
 		});
 	});
 
-	test('Delayer - simple cancel', function (done) {
+	test('Delayer - simple cancel', function () {
 		let count = 0;
 		let factory = () => {
 			return TPromise.as(++count);
@@ -194,18 +198,20 @@ suite('Async', () => {
 
 		assert(!delayer.isTriggered());
 
-		delayer.trigger(factory).then(() => {
+		const p = delayer.trigger(factory).then(() => {
 			assert(false);
 		}, () => {
 			assert(true, 'yes, it was cancelled');
-		}).done(() => done());
+		});
 
 		assert(delayer.isTriggered());
 		delayer.cancel();
 		assert(!delayer.isTriggered());
+
+		return p;
 	});
 
-	test('Delayer - cancel should cancel all calls to trigger', function (done) {
+	test('Delayer - cancel should cancel all calls to trigger', function () {
 		let count = 0;
 		let factory = () => {
 			return TPromise.as(++count);
@@ -227,13 +233,12 @@ suite('Async', () => {
 
 		delayer.cancel();
 
-		Promise.join(promises).done(() => {
+		return Promise.join(promises).then(() => {
 			assert(!delayer.isTriggered());
-			done();
 		});
 	});
 
-	test('Delayer - trigger, cancel, then trigger again', function (done) {
+	test('Delayer - trigger, cancel, then trigger again', function () {
 		let count = 0;
 		let factory = () => {
 			return TPromise.as(++count);
@@ -244,7 +249,7 @@ suite('Async', () => {
 
 		assert(!delayer.isTriggered());
 
-		delayer.trigger(factory).then((result) => {
+		const p = delayer.trigger(factory).then((result) => {
 			assert.equal(result, 1);
 			assert(!delayer.isTriggered());
 
@@ -256,8 +261,7 @@ suite('Async', () => {
 
 			delayer.cancel();
 
-			Promise.join(promises).then(() => {
-
+			const p = Promise.join(promises).then(() => {
 				promises = [];
 
 				assert(!delayer.isTriggered());
@@ -268,22 +272,26 @@ suite('Async', () => {
 				promises.push(delayer.trigger(factory).then(() => { assert.equal(result, 1); assert(!delayer.isTriggered()); }));
 				assert(delayer.isTriggered());
 
-				Promise.join(promises).then(() => {
+				const p = Promise.join(promises).then(() => {
 					assert(!delayer.isTriggered());
-
-					done();
 				});
 
 				assert(delayer.isTriggered());
+
+				return p;
 			});
 
 			assert(delayer.isTriggered());
+
+			return p;
 		});
 
 		assert(delayer.isTriggered());
+
+		return p;
 	});
 
-	test('Delayer - last task should be the one getting called', function (done) {
+	test('Delayer - last task should be the one getting called', function () {
 		let factoryFactory = (n: number) => () => {
 			return TPromise.as(n);
 		};
@@ -297,15 +305,16 @@ suite('Async', () => {
 		promises.push(delayer.trigger(factoryFactory(2)).then((n) => { assert.equal(n, 3); }));
 		promises.push(delayer.trigger(factoryFactory(3)).then((n) => { assert.equal(n, 3); }));
 
-		Promise.join(promises).then(() => {
+		const p = Promise.join(promises).then(() => {
 			assert(!delayer.isTriggered());
-			done();
 		});
 
 		assert(delayer.isTriggered());
+
+		return p;
 	});
 
-	test('Delayer - progress should work', function (done) {
+	test('Delayer - progress should work', function () {
 		let order = 0;
 		let factory = () => new TPromise((c, e, p) => {
 			TPromise.timeout(0).done(() => {
@@ -322,15 +331,14 @@ suite('Async', () => {
 		promises.push(delayer.trigger(factory).then(null, null, (p) => progresses[1].push(p)));
 		promises.push(delayer.trigger(factory).then(null, null, (p) => progresses[2].push(p)));
 
-		Promise.join(promises).done(() => {
+		return Promise.join(promises).then(() => {
 			assert.deepEqual(progresses[0], [0]);
 			assert.deepEqual(progresses[1], [0]);
 			assert.deepEqual(progresses[2], [0]);
-			done();
 		});
 	});
 
-	test('ThrottledDelayer - progress should work', function (done) {
+	test('ThrottledDelayer - progress should work', function () {
 		let order = 0;
 		let factory = () => new TPromise((c, e, p) => {
 			TPromise.timeout(0).done(() => {
@@ -347,20 +355,19 @@ suite('Async', () => {
 		promises.push(delayer.trigger(factory).then(null, null, (p) => progresses[1].push(p)));
 		promises.push(delayer.trigger(factory).then(null, null, (p) => progresses[2].push(p)));
 
-		Promise.join(promises).done(() => {
+		return Promise.join(promises).then(() => {
 			assert.deepEqual(progresses[0], [0]);
 			assert.deepEqual(progresses[1], [0]);
 			assert.deepEqual(progresses[2], [0]);
-			done();
 		});
 	});
 
-	test('Sequence', function (done) {
+	test('Sequence', function () {
 		let factoryFactory = (n: number) => () => {
 			return TPromise.as(n);
 		};
 
-		Async.sequence([
+		return Async.sequence([
 			factoryFactory(1),
 			factoryFactory(2),
 			factoryFactory(3),
@@ -373,11 +380,10 @@ suite('Async', () => {
 			assert.equal(3, result[2]);
 			assert.equal(4, result[3]);
 			assert.equal(5, result[4]);
-			done();
 		});
 	});
 
-	test('Limiter - sync', function (done) {
+	test('Limiter - sync', function () {
 		let factoryFactory = (n: number) => () => {
 			return TPromise.as(n);
 		};
@@ -387,7 +393,7 @@ suite('Async', () => {
 		let promises: Promise[] = [];
 		[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(n => promises.push(limiter.queue(factoryFactory(n))));
 
-		Promise.join(promises).then((res) => {
+		return Promise.join(promises).then((res) => {
 			assert.equal(10, res.length);
 
 			limiter = new Async.Limiter(100);
@@ -398,10 +404,10 @@ suite('Async', () => {
 			return Promise.join(promises).then((res) => {
 				assert.equal(10, res.length);
 			});
-		}).done(() => done());
+		});
 	});
 
-	test('Limiter - async', function (done) {
+	test('Limiter - async', function () {
 		let factoryFactory = (n: number) => () => {
 			return TPromise.timeout(0).then(() => n);
 		};
@@ -410,7 +416,7 @@ suite('Async', () => {
 		let promises: Promise[] = [];
 		[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(n => promises.push(limiter.queue(factoryFactory(n))));
 
-		Promise.join(promises).then((res) => {
+		return Promise.join(promises).then((res) => {
 			assert.equal(10, res.length);
 
 			limiter = new Async.Limiter(100);
@@ -418,13 +424,13 @@ suite('Async', () => {
 			promises = [];
 			[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(n => promises.push(limiter.queue(factoryFactory(n))));
 
-			Promise.join(promises).then((res) => {
+			return Promise.join(promises).then((res) => {
 				assert.equal(10, res.length);
 			});
-		}).done(() => done());
+		});
 	});
 
-	test('Limiter - assert degree of paralellism', function (done) {
+	test('Limiter - assert degree of paralellism', function () {
 		let activePromises = 0;
 		let factoryFactory = (n: number) => () => {
 			activePromises++;
@@ -437,14 +443,13 @@ suite('Async', () => {
 		let promises: Promise[] = [];
 		[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].forEach(n => promises.push(limiter.queue(factoryFactory(n))));
 
-		Promise.join(promises).then((res) => {
+		return Promise.join(promises).then((res) => {
 			assert.equal(10, res.length);
 			assert.deepEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], res);
-			done();
 		});
 	});
 
-	test('Queue - simple', function (done) {
+	test('Queue - simple', function () {
 		let queue = new Async.Queue();
 
 		let syncPromise = false;
@@ -464,12 +469,10 @@ suite('Async', () => {
 			assert.equal(queue.size, 1);
 			assert.ok(syncPromise);
 			assert.ok(asyncPromise);
-
-			done();
 		});
 	});
 
-	test('Queue - order is kept', function (done) {
+	test('Queue - order is kept', function () {
 		let queue = new Async.Queue();
 
 		let res: number[] = [];
@@ -484,18 +487,16 @@ suite('Async', () => {
 		queue.queue(f2);
 		queue.queue(f3);
 		queue.queue(f4);
-		queue.queue(f5).then(() => {
+		return queue.queue(f5).then(() => {
 			assert.equal(res[0], 1);
 			assert.equal(res[1], 2);
 			assert.equal(res[2], 3);
 			assert.equal(res[3], 4);
 			assert.equal(res[4], 5);
-
-			done();
 		});
 	});
 
-	test('Queue - errors bubble individually but not cause stop', function (done) {
+	test('Queue - errors bubble individually but not cause stop', function () {
 		let queue = new Async.Queue();
 
 		let res: number[] = [];
@@ -511,18 +512,16 @@ suite('Async', () => {
 		queue.queue(f2);
 		queue.queue(f3).then(null, () => error = true);
 		queue.queue(f4);
-		queue.queue(f5).then(() => {
+		return queue.queue(f5).then(() => {
 			assert.equal(res[0], 1);
 			assert.equal(res[1], 2);
 			assert.ok(error);
 			assert.equal(res[2], 4);
 			assert.equal(res[3], 5);
-
-			done();
 		});
 	});
 
-	test('Queue - order is kept (chained)', function (done) {
+	test('Queue - order is kept (chained)', function () {
 		let queue = new Async.Queue();
 
 		let res: number[] = [];
@@ -533,18 +532,16 @@ suite('Async', () => {
 		let f4 = () => TPromise.timeout(20).then(() => res.push(4));
 		let f5 = () => TPromise.timeout(0).then(() => res.push(5));
 
-		queue.queue(f1).then(() => {
-			queue.queue(f2).then(() => {
-				queue.queue(f3).then(() => {
-					queue.queue(f4).then(() => {
-						queue.queue(f5).then(() => {
+		return queue.queue(f1).then(() => {
+			return queue.queue(f2).then(() => {
+				return queue.queue(f3).then(() => {
+					return queue.queue(f4).then(() => {
+						return queue.queue(f5).then(() => {
 							assert.equal(res[0], 1);
 							assert.equal(res[1], 2);
 							assert.equal(res[2], 3);
 							assert.equal(res[3], 4);
 							assert.equal(res[4], 5);
-
-							done();
 						});
 					});
 				});

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

@@ -16,9 +16,9 @@ suite('Cache', () => {
 		const cache = new Cache(() => TPromise.as(counter++));
 
 		return cache.get()
-			.then(c => assert.equal(c, 0), () => assert.fail())
+			.then(c => assert.equal(c, 0), () => assert.fail('Unexpected assertion error'))
 			.then(() => cache.get())
-			.then(c => assert.equal(c, 0), () => assert.fail());
+			.then(c => assert.equal(c, 0), () => assert.fail('Unexpected assertion error'));
 	});
 
 	test('simple error', () => {
@@ -26,9 +26,9 @@ suite('Cache', () => {
 		const cache = new Cache(() => TPromise.wrapError(new Error(String(counter++))));
 
 		return cache.get()
-			.then(() => assert.fail(), err => assert.equal(err.message, 0))
+			.then(() => assert.fail('Unexpected assertion error'), err => assert.equal(err.message, 0))
 			.then(() => cache.get())
-			.then(() => assert.fail(), err => assert.equal(err.message, 0));
+			.then(() => assert.fail('Unexpected assertion error'), err => assert.equal(err.message, 0));
 	});
 
 	test('should retry cancellations', () => {

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

@@ -82,4 +82,18 @@ suite('CancellationToken', function () {
 		token = source.token;
 		assert.ok(token === source.token); // doesn't change on get
 	});
+
+	test('dispose calls no listeners', function () {
+
+		let count = 0;
+
+		let source = new CancellationTokenSource();
+		source.token.onCancellationRequested(function () {
+			count += 1;
+		});
+
+		source.dispose();
+		source.cancel();
+		assert.equal(count, 0);
+	});
 });

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

@@ -6,7 +6,7 @@
 'use strict';
 
 import * as assert from 'assert';
-import collections = require('vs/base/common/collections');
+import * as collections from 'vs/base/common/collections';
 
 
 suite('Collections', () => {

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

@@ -5,9 +5,9 @@
 'use strict';
 
 import * as assert from 'assert';
-import Event, { Emitter, debounceEvent, EventBufferer, once, fromPromise, stopwatch, buffer, echo, EventMultiplexer } from 'vs/base/common/event';
+import { Event, Emitter, debounceEvent, EventBufferer, once, fromPromise, stopwatch, buffer, echo, EventMultiplexer, latch } from 'vs/base/common/event';
 import { IDisposable } from 'vs/base/common/lifecycle';
-import Errors = require('vs/base/common/errors');
+import * as Errors from 'vs/base/common/errors';
 import { TPromise } from 'vs/base/common/winjs.base';
 
 namespace Samples {
@@ -183,7 +183,7 @@ suite('Event', function () {
 		doc.setText('3');
 	});
 
-	test('Debounce Event - leading', function (done: () => void) {
+	test('Debounce Event - leading', function () {
 		const emitter = new Emitter<void>();
 		let debounced = debounceEvent(emitter.event, (l, e) => e, 0, /*leading=*/true);
 
@@ -194,13 +194,13 @@ suite('Event', function () {
 
 		// If the source event is fired once, the debounced (on the leading edge) event should be fired only once
 		emitter.fire();
-		setTimeout(() => {
+
+		return TPromise.timeout(1).then(() => {
 			assert.equal(calls, 1);
-			done();
 		});
 	});
 
-	test('Debounce Event - leading', function (done: () => void) {
+	test('Debounce Event - leading', function () {
 		const emitter = new Emitter<void>();
 		let debounced = debounceEvent(emitter.event, (l, e) => e, 0, /*leading=*/true);
 
@@ -213,9 +213,8 @@ suite('Event', function () {
 		emitter.fire();
 		emitter.fire();
 		emitter.fire();
-		setTimeout(() => {
+		return TPromise.timeout(1).then(() => {
 			assert.equal(calls, 2);
-			done();
 		});
 	});
 
@@ -652,4 +651,40 @@ suite('Event utils', () => {
 			assert.deepEqual(result, [1, 2, 3, 4, 5]);
 		});
 	});
+
+	test('latch', function () {
+		const emitter = new Emitter<number>();
+		const event = latch(emitter.event);
+
+		const result: number[] = [];
+		const listener = event(num => result.push(num));
+
+		assert.deepEqual(result, []);
+
+		emitter.fire(1);
+		assert.deepEqual(result, [1]);
+
+		emitter.fire(2);
+		assert.deepEqual(result, [1, 2]);
+
+		emitter.fire(2);
+		assert.deepEqual(result, [1, 2]);
+
+		emitter.fire(1);
+		assert.deepEqual(result, [1, 2, 1]);
+
+		emitter.fire(1);
+		assert.deepEqual(result, [1, 2, 1]);
+
+		emitter.fire(3);
+		assert.deepEqual(result, [1, 2, 1, 3]);
+
+		emitter.fire(3);
+		assert.deepEqual(result, [1, 2, 1, 3]);
+
+		emitter.fire(3);
+		assert.deepEqual(result, [1, 2, 1, 3]);
+
+		listener.dispose();
+	});
 });

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

@@ -9,36 +9,36 @@ import { HistoryNavigator } from 'vs/base/common/history';
 
 suite('History Navigator', () => {
 
-	test('create reduces the input to limit', function () {
-		let testObject = new HistoryNavigator(['1', '2', '3', '4'], 2);
+	test('create reduces the input to limit', () => {
+		const testObject = new HistoryNavigator(['1', '2', '3', '4'], 2);
 
 		assert.deepEqual(['3', '4'], toArray(testObject));
 	});
 
-	test('create sets the position to last', function () {
-		let testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
+	test('create sets the position to last', () => {
+		const testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
 
 		assert.equal('4', testObject.current());
 		assert.equal(null, testObject.next());
 		assert.equal('3', testObject.previous());
 	});
 
-	test('last returns last element', function () {
-		let testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
+	test('last returns last element', () => {
+		const testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
 
 		testObject.first();
 
 		assert.equal('4', testObject.last());
 	});
 
-	test('first returns first element', function () {
-		let testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
+	test('first returns first element', () => {
+		const testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
 
 		assert.equal('2', testObject.first());
 	});
 
-	test('next returns next element', function () {
-		let testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
+	test('next returns next element', () => {
+		const testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
 
 		testObject.first();
 
@@ -47,16 +47,16 @@ suite('History Navigator', () => {
 		assert.equal(null, testObject.next());
 	});
 
-	test('previous returns previous element', function () {
-		let testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
+	test('previous returns previous element', () => {
+		const testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
 
 		assert.equal('3', testObject.previous());
 		assert.equal('2', testObject.previous());
 		assert.equal(null, testObject.previous());
 	});
 
-	test('next on last element returs null and remains on last', function () {
-		let testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
+	test('next on last element returs null and remains on last', () => {
+		const testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
 
 		testObject.first();
 		testObject.last();
@@ -65,8 +65,8 @@ suite('History Navigator', () => {
 		assert.equal(null, testObject.next());
 	});
 
-	test('previous on first element returs null and remains on first', function () {
-		let testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
+	test('previous on first element returs null and remains on first', () => {
+		const testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
 
 		testObject.first();
 
@@ -74,24 +74,24 @@ suite('History Navigator', () => {
 		assert.equal(null, testObject.previous());
 	});
 
-	test('add reduces the input to limit', function () {
-		let testObject = new HistoryNavigator(['1', '2', '3', '4'], 2);
+	test('add reduces the input to limit', () => {
+		const testObject = new HistoryNavigator(['1', '2', '3', '4'], 2);
 
 		testObject.add('5');
 
 		assert.deepEqual(['4', '5'], toArray(testObject));
 	});
 
-	test('adding existing element changes the position', function () {
-		let testObject = new HistoryNavigator(['1', '2', '3', '4'], 5);
+	test('adding existing element changes the position', () => {
+		const testObject = new HistoryNavigator(['1', '2', '3', '4'], 5);
 
 		testObject.add('2');
 
 		assert.deepEqual(['1', '3', '4', '2'], toArray(testObject));
 	});
 
-	test('add resets the navigator to last', function () {
-		let testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
+	test('add resets the navigator to last', () => {
+		const testObject = new HistoryNavigator(['1', '2', '3', '4'], 3);
 
 		testObject.first();
 		testObject.add('5');
@@ -100,14 +100,21 @@ suite('History Navigator', () => {
 		assert.equal(null, testObject.next());
 	});
 
-	test('adding an existing item changes the order', function () {
-		let testObject = new HistoryNavigator(['1', '2', '3']);
+	test('adding an existing item changes the order', () => {
+		const testObject = new HistoryNavigator(['1', '2', '3']);
 
 		testObject.add('1');
 
 		assert.deepEqual(['2', '3', '1'], toArray(testObject));
 	});
 
+	test('clear', () => {
+		const testObject = new HistoryNavigator(['a', 'b', 'c']);
+		assert.equal('c', testObject.current());
+		testObject.clear();
+		assert.equal(undefined, testObject.current());
+	});
+
 	function toArray(historyNavigator: HistoryNavigator<string>): string[] {
 		let result = [];
 		historyNavigator.first();

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

@@ -6,7 +6,7 @@
 
 import { FormattingOptions, Edit } from 'vs/base/common/jsonFormatter';
 import { setProperty, removeProperty } from 'vs/base/common/jsonEdit';
-import assert = require('assert');
+import * as assert from 'assert';
 
 suite('JSON - edits', () => {
 

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

@@ -4,8 +4,8 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import Formatter = require('vs/base/common/jsonFormatter');
-import assert = require('assert');
+import * as Formatter from 'vs/base/common/jsonFormatter';
+import * as assert from 'assert';
 
 suite('JSON - formatter', () => {
 

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

@@ -6,9 +6,8 @@
 'use strict';
 
 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';
+import * as labels from 'vs/base/common/labels';
+import * as platform from 'vs/base/common/platform';
 
 suite('Labels', () => {
 	test('shorten - windows', () => {
@@ -125,9 +124,9 @@ suite('Labels', () => {
 
 		// conditional separator
 		assert.strictEqual(labels.template('Foo${separator}Bar'), 'FooBar');
-		assert.strictEqual(labels.template('Foo${separator}Bar', { separator: { label: ' - ' } }), 'FooBar');
-		assert.strictEqual(labels.template('${separator}Foo${separator}Bar', { value: 'something', separator: { label: ' - ' } }), 'FooBar');
-		assert.strictEqual(labels.template('${value} Foo${separator}Bar', { value: 'something', separator: { label: ' - ' } }), 'something FooBar');
+		assert.strictEqual(labels.template('Foo${separator}Bar', { separator: { label: ' - ' } }), 'Foo - Bar');
+		assert.strictEqual(labels.template('${separator}Foo${separator}Bar', { value: 'something', separator: { label: ' - ' } }), 'Foo - Bar');
+		assert.strictEqual(labels.template('${value} Foo${separator}Bar', { value: 'something', separator: { label: ' - ' } }), 'something Foo - Bar');
 
 		// // real world example (macOS)
 		let t = '${activeEditorShort}${separator}${rootName}';
@@ -151,9 +150,9 @@ suite('Labels', () => {
 			return;
 		}
 
-		assert.equal(getBaseLabel('/some/folder/file.txt'), 'file.txt');
-		assert.equal(getBaseLabel('/some/folder'), 'folder');
-		assert.equal(getBaseLabel('/'), '/');
+		assert.equal(labels.getBaseLabel('/some/folder/file.txt'), 'file.txt');
+		assert.equal(labels.getBaseLabel('/some/folder'), 'folder');
+		assert.equal(labels.getBaseLabel('/'), '/');
 	});
 
 	test('getBaseLabel - windows', () => {
@@ -162,9 +161,9 @@ suite('Labels', () => {
 			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');
+		assert.equal(labels.getBaseLabel('c:'), 'C:');
+		assert.equal(labels.getBaseLabel('c:\\'), 'C:');
+		assert.equal(labels.getBaseLabel('c:\\some\\folder\\file.txt'), 'file.txt');
+		assert.equal(labels.getBaseLabel('c:\\some\\folder'), 'folder');
 	});
 });

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

@@ -200,6 +200,33 @@ suite('Map', () => {
 		assert.deepStrictEqual(cache.values(), values);
 	});
 
+	test('LinkedMap - toJSON / fromJSON', () => {
+		let map = new LinkedMap<string, string>();
+		map.set('ak', 'av');
+		map.set('bk', 'bv');
+		map.set('ck', 'cv');
+
+		const json = map.toJSON();
+		map = new LinkedMap<string, string>();
+		map.fromJSON(json);
+
+		let i = 0;
+		map.forEach((value, key) => {
+			if (i === 0) {
+				assert.equal(key, 'ak');
+				assert.equal(value, 'av');
+			} else if (i === 1) {
+				assert.equal(key, 'bk');
+				assert.equal(value, 'bv');
+			} else if (i === 2) {
+				assert.equal(key, 'ck');
+				assert.equal(value, 'cv');
+			}
+
+			i++;
+		});
+	});
+
 	test('PathIterator', function () {
 		const iter = new PathIterator();
 		iter.reset('file:///usr/bin/file.txt');
@@ -517,32 +544,32 @@ suite('Map', () => {
 		assert.equal(map.get(uncFile), 'true');
 	});
 
-	test('ResourceMap - files (ignorecase)', function () {
-		const map = new ResourceMap<any>(true);
+	// test('ResourceMap - files (ignorecase)', function () {
+	// 	const map = new ResourceMap<any>(true);
 
-		const fileA = URI.parse('file://some/filea');
-		const fileB = URI.parse('some://some/other/fileb');
-		const fileAUpper = URI.parse('file://SOME/FILEA');
+	// 	const fileA = URI.parse('file://some/filea');
+	// 	const fileB = URI.parse('some://some/other/fileb');
+	// 	const fileAUpper = URI.parse('file://SOME/FILEA');
 
-		map.set(fileA, 'true');
-		assert.equal(map.get(fileA), 'true');
+	// 	map.set(fileA, 'true');
+	// 	assert.equal(map.get(fileA), 'true');
 
-		assert.equal(map.get(fileAUpper), 'true');
+	// 	assert.equal(map.get(fileAUpper), 'true');
 
-		assert.ok(!map.get(fileB));
+	// 	assert.ok(!map.get(fileB));
 
-		map.set(fileAUpper, 'false');
-		assert.equal(map.get(fileAUpper), 'false');
+	// 	map.set(fileAUpper, 'false');
+	// 	assert.equal(map.get(fileAUpper), 'false');
 
-		assert.equal(map.get(fileA), 'false');
+	// 	assert.equal(map.get(fileA), 'false');
 
-		const windowsFile = URI.file('c:\\test with %25\\c#code');
-		const uncFile = URI.file('\\\\shäres\\path\\c#\\plugin.json');
+	// 	const windowsFile = URI.file('c:\\test with %25\\c#code');
+	// 	const uncFile = URI.file('\\\\shäres\\path\\c#\\plugin.json');
 
-		map.set(windowsFile, 'true');
-		map.set(uncFile, 'true');
+	// 	map.set(windowsFile, 'true');
+	// 	map.set(uncFile, 'true');
 
-		assert.equal(map.get(windowsFile), 'true');
-		assert.equal(map.get(uncFile), 'true');
-	});
+	// 	assert.equal(map.get(windowsFile), 'true');
+	// 	assert.equal(map.get(uncFile), 'true');
+	// });
 });

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

@@ -5,7 +5,7 @@
 'use strict';
 
 import * as assert from 'assert';
-import objects = require('vs/base/common/objects');
+import * as objects from 'vs/base/common/objects';
 
 let check = (one: any, other: any, msg: string) => {
 	assert(objects.equals(one, other), msg);

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

@@ -5,8 +5,8 @@
 'use strict';
 
 import * as assert from 'assert';
-import paths = require('vs/base/common/paths');
-import platform = require('vs/base/common/platform');
+import * as paths from 'vs/base/common/paths';
+import * as platform from 'vs/base/common/platform';
 
 suite('Paths', () => {
 
@@ -20,6 +20,7 @@ suite('Paths', () => {
 		assert.equal(paths.dirname('/'), '/');
 		assert.equal(paths.dirname('\\'), '\\');
 		assert.equal(paths.dirname('foo'), '.');
+		assert.equal(paths.dirname('/folder/'), '/');
 		if (platform.isWindows) {
 			assert.equal(paths.dirname('c:\\some\\file.txt'), 'c:\\some');
 			assert.equal(paths.dirname('c:\\some'), 'c:\\');
@@ -226,4 +227,4 @@ suite('Paths', () => {
 			assert.ok(!paths.isAbsolute_posix(nonAbsolutePath), nonAbsolutePath);
 		});
 	});
-});
+});

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

@@ -42,13 +42,12 @@ suite('Resources', () => {
 		assert.equal(distinct[2].toString(), resources[4].toString());
 	});
 
-	test('dirname', (done) => {
+	test('dirname', () => {
 		const f = URI.file('/some/file/test.txt');
 		const d = dirname(f);
 		assert.equal(d.fsPath, normalize('/some/file', true));
 
 		// does not explode (https://github.com/Microsoft/vscode/issues/41987)
 		dirname(URI.from({ scheme: 'file', authority: '/users/someone/portal.h' }));
-		done();
 	});
 });

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

@@ -5,7 +5,7 @@
 'use strict';
 
 import * as assert from 'assert';
-import strings = require('vs/base/common/strings');
+import * as strings from 'vs/base/common/strings';
 
 suite('Strings', () => {
 	test('equalsIgnoreCase', function () {
@@ -21,29 +21,29 @@ suite('Strings', () => {
 	});
 
 	test('beginsWithIgnoreCase', function () {
-		assert(strings.beginsWithIgnoreCase('', ''));
-		assert(!strings.beginsWithIgnoreCase('', '1'));
-		assert(strings.beginsWithIgnoreCase('1', ''));
+		assert(strings.startsWithIgnoreCase('', ''));
+		assert(!strings.startsWithIgnoreCase('', '1'));
+		assert(strings.startsWithIgnoreCase('1', ''));
 
-		assert(strings.beginsWithIgnoreCase('a', 'a'));
-		assert(strings.beginsWithIgnoreCase('abc', 'Abc'));
-		assert(strings.beginsWithIgnoreCase('abc', 'ABC'));
-		assert(strings.beginsWithIgnoreCase('Höhenmeter', 'HÖhenmeter'));
-		assert(strings.beginsWithIgnoreCase('ÖL', 'Öl'));
+		assert(strings.startsWithIgnoreCase('a', 'a'));
+		assert(strings.startsWithIgnoreCase('abc', 'Abc'));
+		assert(strings.startsWithIgnoreCase('abc', 'ABC'));
+		assert(strings.startsWithIgnoreCase('Höhenmeter', 'HÖhenmeter'));
+		assert(strings.startsWithIgnoreCase('ÖL', 'Öl'));
 
-		assert(strings.beginsWithIgnoreCase('alles klar', 'a'));
-		assert(strings.beginsWithIgnoreCase('alles klar', 'A'));
-		assert(strings.beginsWithIgnoreCase('alles klar', 'alles k'));
-		assert(strings.beginsWithIgnoreCase('alles klar', 'alles K'));
-		assert(strings.beginsWithIgnoreCase('alles klar', 'ALLES K'));
-		assert(strings.beginsWithIgnoreCase('alles klar', 'alles klar'));
-		assert(strings.beginsWithIgnoreCase('alles klar', 'ALLES KLAR'));
+		assert(strings.startsWithIgnoreCase('alles klar', 'a'));
+		assert(strings.startsWithIgnoreCase('alles klar', 'A'));
+		assert(strings.startsWithIgnoreCase('alles klar', 'alles k'));
+		assert(strings.startsWithIgnoreCase('alles klar', 'alles K'));
+		assert(strings.startsWithIgnoreCase('alles klar', 'ALLES K'));
+		assert(strings.startsWithIgnoreCase('alles klar', 'alles klar'));
+		assert(strings.startsWithIgnoreCase('alles klar', 'ALLES KLAR'));
 
-		assert(!strings.beginsWithIgnoreCase('alles klar', ' ALLES K'));
-		assert(!strings.beginsWithIgnoreCase('alles klar', 'ALLES K '));
-		assert(!strings.beginsWithIgnoreCase('alles klar', 'öALLES K '));
-		assert(!strings.beginsWithIgnoreCase('alles klar', ' '));
-		assert(!strings.beginsWithIgnoreCase('alles klar', 'ö'));
+		assert(!strings.startsWithIgnoreCase('alles klar', ' ALLES K'));
+		assert(!strings.startsWithIgnoreCase('alles klar', 'ALLES K '));
+		assert(!strings.startsWithIgnoreCase('alles klar', 'öALLES K '));
+		assert(!strings.startsWithIgnoreCase('alles klar', ' '));
+		assert(!strings.startsWithIgnoreCase('alles klar', 'ö'));
 	});
 
 	test('compareIgnoreCase', function () {

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

@@ -5,7 +5,7 @@
 'use strict';
 
 import * as assert from 'assert';
-import types = require('vs/base/common/types');
+import * as types from 'vs/base/common/types';
 
 suite('Types', () => {
 	test('isFunction', () => {

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

@@ -5,7 +5,6 @@
 
 'use strict';
 
-import * as assert from 'assert';
 import { TPromise, PPromise, TValueCallback, TProgressCallback, ProgressCallback } from 'vs/base/common/winjs.base';
 import * as errors from 'vs/base/common/errors';
 import * as paths from 'vs/base/common/paths';
@@ -80,11 +79,6 @@ export class DeferredPPromise<C, P> extends PPromise<C, P> {
 	}
 }
 
-export function onError(error: Error, done: () => void): void {
-	assert.fail(error);
-	done();
-}
-
 export function toResource(this: any, path: string) {
 	return URI.file(paths.join('C:\\', Buffer.from(this.test.fullTitle()).toString('base64'), path));
 }

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

@@ -5,7 +5,7 @@
 'use strict';
 
 import * as assert from 'assert';
-import uuid = require('vs/base/common/uuid');
+import * as uuid from 'vs/base/common/uuid';
 
 suite('UUID', () => {
 	test('generation', () => {

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

@@ -5,30 +5,17 @@
 
 'use strict';
 
-import assert = require('assert');
-import os = require('os');
+import * as assert from 'assert';
+import * as os from 'os';
 
-import path = require('path');
-import fs = require('fs');
-import extfs = require('vs/base/node/extfs');
-import uuid = require('vs/base/common/uuid');
+import * as path from 'path';
+import * as fs from 'fs';
+import * as uuid from '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';
+import { testFile } from 'vs/base/test/node/utils';
 
 suite('Config', () => {
 
-	function testFile(callback: (error: Error, path: string, cleanUp: (callback: () => void) => void) => void): void {
-		const id = uuid.generateUuid();
-		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
-		const newDir = path.join(parentDir, 'config', id);
-		const testFile = path.join(newDir, 'config.json');
-
-		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 () {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
@@ -52,15 +39,11 @@ suite('Config', () => {
 		watcher.dispose();
 	});
 
-	test('getConfig / getValue', function (done: () => void) {
-		testFile((error, testFile, cleanUp) => {
-			if (error) {
-				return onError(error, done);
-			}
+	test('getConfig / getValue', function () {
+		return testFile('config', 'config.json').then(res => {
+			fs.writeFileSync(res.testFile, '// my comment\n{ "foo": "bar" }');
 
-			fs.writeFileSync(testFile, '// my comment\n{ "foo": "bar" }');
-
-			let watcher = new ConfigWatcher<{ foo: string; }>(testFile);
+			let watcher = new ConfigWatcher<{ foo: string; }>(res.testFile);
 
 			let config = watcher.getConfig();
 			assert.ok(config);
@@ -72,19 +55,15 @@ suite('Config', () => {
 
 			watcher.dispose();
 
-			cleanUp(done);
+			return res.cleanUp();
 		});
 	});
 
-	test('getConfig / getValue - broken JSON', function (done: () => void) {
-		testFile((error, testFile, cleanUp) => {
-			if (error) {
-				return onError(error, done);
-			}
+	test('getConfig / getValue - broken JSON', function () {
+		return testFile('config', 'config.json').then(res => {
+			fs.writeFileSync(res.testFile, '// my comment\n "foo": "bar ... ');
 
-			fs.writeFileSync(testFile, '// my comment\n "foo": "bar ... ');
-
-			let watcher = new ConfigWatcher<{ foo: string; }>(testFile);
+			let watcher = new ConfigWatcher<{ foo: string; }>(res.testFile);
 
 			let config = watcher.getConfig();
 			assert.ok(config);
@@ -94,24 +73,20 @@ suite('Config', () => {
 
 			watcher.dispose();
 
-			cleanUp(done);
+			return res.cleanUp();
 		});
 	});
 
-	test('watching', function (done: () => void) {
+	test('watching', function (done) {
 		this.timeout(10000); // watching is timing intense
 
-		testFile((error, testFile, cleanUp) => {
-			if (error) {
-				return onError(error, done);
-			}
+		testFile('config', 'config.json').then(res => {
+			fs.writeFileSync(res.testFile, '// my comment\n{ "foo": "bar" }');
 
-			fs.writeFileSync(testFile, '// my comment\n{ "foo": "bar" }');
-
-			let watcher = new ConfigWatcher<{ foo: string; }>(testFile);
+			let watcher = new ConfigWatcher<{ foo: string; }>(res.testFile);
 			watcher.getConfig(); // ensure we are in sync
 
-			fs.writeFileSync(testFile, '// my comment\n{ "foo": "changed" }');
+			fs.writeFileSync(res.testFile, '// my comment\n{ "foo": "changed" }');
 
 			watcher.onDidUpdateConfiguration(event => {
 				assert.ok(event);
@@ -120,24 +95,19 @@ suite('Config', () => {
 
 				watcher.dispose();
 
-				cleanUp(done);
+				res.cleanUp().then(done, done);
 			});
-
-		});
+		}, done);
 	});
 
-	test('watching also works when file created later', function (done: () => void) {
+	test('watching also works when file created later', function (done) {
 		this.timeout(10000); // watching is timing intense
 
-		testFile((error, testFile, cleanUp) => {
-			if (error) {
-				return onError(error, done);
-			}
-
-			let watcher = new ConfigWatcher<{ foo: string; }>(testFile);
+		testFile('config', 'config.json').then(res => {
+			let watcher = new ConfigWatcher<{ foo: string; }>(res.testFile);
 			watcher.getConfig(); // ensure we are in sync
 
-			fs.writeFileSync(testFile, '// my comment\n{ "foo": "changed" }');
+			fs.writeFileSync(res.testFile, '// my comment\n{ "foo": "changed" }');
 
 			watcher.onDidUpdateConfiguration(event => {
 				assert.ok(event);
@@ -146,23 +116,18 @@ suite('Config', () => {
 
 				watcher.dispose();
 
-				cleanUp(done);
+				res.cleanUp().then(done, done);
 			});
-
-		});
+		}, done);
 	});
 
-	test('watching detects the config file getting deleted', function (done: () => void) {
+	test('watching detects the config file getting deleted', function (done) {
 		this.timeout(10000); // watching is timing intense
 
-		testFile((error, testFile, cleanUp) => {
-			if (error) {
-				return onError(error, done);
-			}
+		testFile('config', 'config.json').then(res => {
+			fs.writeFileSync(res.testFile, '// my comment\n{ "foo": "bar" }');
 
-			fs.writeFileSync(testFile, '// my comment\n{ "foo": "bar" }');
-
-			let watcher = new ConfigWatcher<{ foo: string; }>(testFile);
+			let watcher = new ConfigWatcher<{ foo: string; }>(res.testFile);
 			watcher.getConfig(); // ensure we are in sync
 
 			watcher.onDidUpdateConfiguration(event => {
@@ -170,25 +135,21 @@ suite('Config', () => {
 
 				watcher.dispose();
 
-				cleanUp(done);
+				res.cleanUp().then(done, done);
 			});
 
-			fs.unlinkSync(testFile);
-		});
+			fs.unlinkSync(res.testFile);
+		}, done);
 	});
 
-	test('reload', function (done: () => void) {
-		testFile((error, testFile, cleanUp) => {
-			if (error) {
-				return onError(error, done);
-			}
+	test('reload', function (done) {
+		testFile('config', 'config.json').then(res => {
+			fs.writeFileSync(res.testFile, '// my comment\n{ "foo": "bar" }');
 
-			fs.writeFileSync(testFile, '// my comment\n{ "foo": "bar" }');
-
-			let watcher = new ConfigWatcher<{ foo: string; }>(testFile, { changeBufferDelay: 100, onError: console.error });
+			let watcher = new ConfigWatcher<{ foo: string; }>(res.testFile, { changeBufferDelay: 100, onError: console.error });
 			watcher.getConfig(); // ensure we are in sync
 
-			fs.writeFileSync(testFile, '// my comment\n{ "foo": "changed" }');
+			fs.writeFileSync(res.testFile, '// my comment\n{ "foo": "changed" }');
 
 			// still old values because change is not bubbling yet
 			assert.equal(watcher.getConfig().foo, 'bar');
@@ -202,8 +163,8 @@ suite('Config', () => {
 
 				watcher.dispose();
 
-				cleanUp(done);
+				res.cleanUp().then(done, done);
 			});
-		});
+		}, done);
 	});
 });

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

@@ -6,7 +6,7 @@
 'use strict';
 
 import * as assert from 'assert';
-import decoder = require('vs/base/node/decoder');
+import * as decoder from 'vs/base/node/decoder';
 
 suite('Decoder', () => {
 

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

@@ -5,71 +5,261 @@
 
 'use strict';
 
-import assert = require('assert');
-
-import encoding = require('vs/base/node/encoding');
-import { encodingExists } from 'vs/base/node/encoding';
+import * as assert from 'assert';
+import * as fs from 'fs';
+import * as encoding from 'vs/base/node/encoding';
+import { readExactlyByFile } from 'vs/base/node/stream';
+import { Readable } from 'stream';
 
 suite('Encoding', () => {
-	test('detectBOM UTF-8', (done: (err?: any) => void) => {
+	test('detectBOM UTF-8', () => {
 		const file = require.toUrl('./fixtures/some_utf8.css');
 
-		encoding.detectEncodingByBOM(file).then((encoding: string) => {
+		return encoding.detectEncodingByBOM(file).then((encoding: string) => {
 			assert.equal(encoding, 'utf8');
-			done();
-		}, done);
+		});
 	});
 
-	test('detectBOM UTF-16 LE', (done: (err?: any) => void) => {
+	test('detectBOM UTF-16 LE', () => {
 		const file = require.toUrl('./fixtures/some_utf16le.css');
 
-		encoding.detectEncodingByBOM(file).then((encoding: string) => {
+		return encoding.detectEncodingByBOM(file).then((encoding: string) => {
 			assert.equal(encoding, 'utf16le');
-			done();
-		}, done);
+		});
 	});
 
-	test('detectBOM UTF-16 BE', (done: (err?: any) => void) => {
+	test('detectBOM UTF-16 BE', () => {
 		const file = require.toUrl('./fixtures/some_utf16be.css');
 
-		encoding.detectEncodingByBOM(file).then((encoding: string) => {
+		return encoding.detectEncodingByBOM(file).then((encoding: string) => {
 			assert.equal(encoding, 'utf16be');
-			done();
-		}, done);
+		});
 	});
 
-	test('detectBOM ANSI', function (done: (err?: any) => void) {
+	test('detectBOM ANSI', function () {
 		const file = require.toUrl('./fixtures/some_ansi.css');
 
-		encoding.detectEncodingByBOM(file).then((encoding: string) => {
+		return encoding.detectEncodingByBOM(file).then((encoding: string) => {
 			assert.equal(encoding, null);
-			done();
-		}, done);
+		});
 	});
 
-	test('detectBOM ANSI', function (done: (err?: any) => void) {
+	test('detectBOM ANSI', function () {
 		const file = require.toUrl('./fixtures/empty.txt');
 
-		encoding.detectEncodingByBOM(file).then((encoding: string) => {
+		return encoding.detectEncodingByBOM(file).then((encoding: string) => {
 			assert.equal(encoding, null);
-			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 (detect)', function () {
+		return encoding.resolveTerminalEncoding().then(enc => {
+			assert.ok(encoding.encodingExists(enc));
+		});
 	});
 
-	test('resolve terminal encoding (environment)', function (done: (err?: any) => void) {
+	test('resolve terminal encoding (environment)', function () {
 		process.env['VSCODE_CLI_ENCODING'] = 'utf16le';
 
-		encoding.resolveTerminalEncoding().then(encoding => {
-			assert.ok(encodingExists(encoding));
-			assert.equal(encoding, 'utf16le');
-			done();
-		}, done);
+		return encoding.resolveTerminalEncoding().then(enc => {
+			assert.ok(encoding.encodingExists(enc));
+			assert.equal(enc, 'utf16le');
+		});
+	});
+
+	test('detectEncodingFromBuffer (JSON saved as PNG)', function () {
+		const file = require.toUrl('./fixtures/some.json.png');
+
+		return readExactlyByFile(file, 512).then(buffer => {
+			const mimes = encoding.detectEncodingFromBuffer(buffer);
+			assert.equal(mimes.seemsBinary, false);
+		});
+	});
+
+	test('detectEncodingFromBuffer (PNG saved as TXT)', function () {
+		const file = require.toUrl('./fixtures/some.png.txt');
+		return readExactlyByFile(file, 512).then(buffer => {
+			const mimes = encoding.detectEncodingFromBuffer(buffer);
+			assert.equal(mimes.seemsBinary, true);
+		});
+	});
+
+	test('detectEncodingFromBuffer (XML saved as PNG)', function () {
+		const file = require.toUrl('./fixtures/some.xml.png');
+		return readExactlyByFile(file, 512).then(buffer => {
+			const mimes = encoding.detectEncodingFromBuffer(buffer);
+			assert.equal(mimes.seemsBinary, false);
+		});
+	});
+
+	test('detectEncodingFromBuffer (QWOFF saved as TXT)', function () {
+		const file = require.toUrl('./fixtures/some.qwoff.txt');
+		return readExactlyByFile(file, 512).then(buffer => {
+			const mimes = encoding.detectEncodingFromBuffer(buffer);
+			assert.equal(mimes.seemsBinary, true);
+		});
+	});
+
+	test('detectEncodingFromBuffer (CSS saved as QWOFF)', function () {
+		const file = require.toUrl('./fixtures/some.css.qwoff');
+		return readExactlyByFile(file, 512).then(buffer => {
+			const mimes = encoding.detectEncodingFromBuffer(buffer);
+			assert.equal(mimes.seemsBinary, false);
+		});
+	});
+
+	test('detectEncodingFromBuffer (PDF)', function () {
+		const file = require.toUrl('./fixtures/some.pdf');
+		return readExactlyByFile(file, 512).then(buffer => {
+			const mimes = encoding.detectEncodingFromBuffer(buffer);
+			assert.equal(mimes.seemsBinary, true);
+		});
+	});
+
+	test('detectEncodingFromBuffer (guess UTF-16 LE from content without BOM)', function () {
+		const file = require.toUrl('./fixtures/utf16_le_nobom.txt');
+		return readExactlyByFile(file, 512).then(buffer => {
+			const mimes = encoding.detectEncodingFromBuffer(buffer);
+			assert.equal(mimes.encoding, encoding.UTF16le);
+			assert.equal(mimes.seemsBinary, false);
+		});
+	});
+
+	test('detectEncodingFromBuffer (guess UTF-16 BE from content without BOM)', function () {
+		const file = require.toUrl('./fixtures/utf16_be_nobom.txt');
+		return readExactlyByFile(file, 512).then(buffer => {
+			const mimes = encoding.detectEncodingFromBuffer(buffer);
+			assert.equal(mimes.encoding, encoding.UTF16be);
+			assert.equal(mimes.seemsBinary, false);
+		});
+	});
+
+	test('autoGuessEncoding (ShiftJIS)', function () {
+		const file = require.toUrl('./fixtures/some.shiftjis.txt');
+		return readExactlyByFile(file, 512 * 8).then(buffer => {
+			return encoding.detectEncodingFromBuffer(buffer, true).then(mimes => {
+				assert.equal(mimes.encoding, 'shiftjis');
+			});
+		});
+	});
+
+	test('autoGuessEncoding (CP1252)', function () {
+		const file = require.toUrl('./fixtures/some.cp1252.txt');
+		return readExactlyByFile(file, 512 * 8).then(buffer => {
+			return encoding.detectEncodingFromBuffer(buffer, true).then(mimes => {
+				assert.equal(mimes.encoding, 'windows1252');
+			});
+		});
+	});
+
+	async function readAndDecodeFromDisk(path, _encoding) {
+		return new Promise<string>((resolve, reject) => {
+			fs.readFile(path, (err, data) => {
+				if (err) {
+					reject(err);
+				} else {
+					resolve(encoding.decode(data, _encoding));
+				}
+			});
+		});
+	}
+
+	async function readAllAsString(stream: NodeJS.ReadableStream) {
+		return new Promise<string>((resolve, reject) => {
+			let all = '';
+			stream.on('data', chunk => {
+				all += chunk;
+				assert.equal(typeof chunk, 'string');
+			});
+			stream.on('end', () => {
+				resolve(all);
+			});
+			stream.on('error', reject);
+		});
+	}
+
+	test('toDecodeStream - some stream', async function () {
+
+		let source = new Readable({
+			read(size) {
+				this.push(Buffer.from([65, 66, 67]));
+				this.push(Buffer.from([65, 66, 67]));
+				this.push(Buffer.from([65, 66, 67]));
+				this.push(null);
+			}
+		});
+
+		let { detected, stream } = await encoding.toDecodeStream(source, { minBytesRequiredForDetection: 4 });
+
+		assert.ok(detected);
+		assert.ok(stream);
+
+		const content = await readAllAsString(stream);
+		assert.equal(content, 'ABCABCABC');
+	});
+
+	test('toDecodeStream - some stream, expect too much data', async function () {
+
+		let source = new Readable({
+			read(size) {
+				this.push(Buffer.from([65, 66, 67]));
+				this.push(Buffer.from([65, 66, 67]));
+				this.push(Buffer.from([65, 66, 67]));
+				this.push(null);
+			}
+		});
+
+		let { detected, stream } = await encoding.toDecodeStream(source, { minBytesRequiredForDetection: 64 });
+
+		assert.ok(detected);
+		assert.ok(stream);
+
+		const content = await readAllAsString(stream);
+		assert.equal(content, 'ABCABCABC');
+	});
+
+	test('toDecodeStream - some stream, no data', async function () {
+
+		let source = new Readable({
+			read(size) {
+				this.push(null); // empty
+			}
+		});
+
+		let { detected, stream } = await encoding.toDecodeStream(source, { minBytesRequiredForDetection: 512 });
+
+		assert.ok(detected);
+		assert.ok(stream);
+
+		const content = await readAllAsString(stream);
+		assert.equal(content, '');
+	});
+
+
+	test('toDecodeStream - encoding, utf16be', async function () {
+
+		let path = require.toUrl('./fixtures/some_utf16be.css');
+		let source = fs.createReadStream(path);
+
+		let { detected, stream } = await encoding.toDecodeStream(source, { minBytesRequiredForDetection: 64 });
+
+		assert.equal(detected.encoding, 'utf16be');
+		assert.equal(detected.seemsBinary, false);
+
+		let expected = await readAndDecodeFromDisk(path, detected.encoding);
+		let actual = await readAllAsString(stream);
+		assert.equal(actual, expected);
+	});
+
+
+	test('toDecodeStream - empty file', async function () {
+
+		let path = require.toUrl('./fixtures/empty.txt');
+		let source = fs.createReadStream(path);
+		let { detected, stream } = await encoding.toDecodeStream(source, {});
+
+		let expected = await readAndDecodeFromDisk(path, detected.encoding);
+		let actual = await readAllAsString(stream);
+		assert.equal(actual, expected);
 	});
 });

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

@@ -5,16 +5,15 @@
 
 'use strict';
 
-import assert = require('assert');
-import os = require('os');
+import * as assert from 'assert';
+import * as os from 'os';
 
-import path = require('path');
-import fs = require('fs');
+import * as path from 'path';
+import * as fs from 'fs';
 
-import uuid = require('vs/base/common/uuid');
-import strings = require('vs/base/common/strings');
-import extfs = require('vs/base/node/extfs');
-import { onError } from 'vs/base/test/common/utils';
+import * as uuid from 'vs/base/common/uuid';
+import * as strings from 'vs/base/common/strings';
+import * as extfs from 'vs/base/node/extfs';
 import { Readable } from 'stream';
 import { isLinux, isWindows } from 'vs/base/common/platform';
 
@@ -58,14 +57,14 @@ function toReadable(value: string, throwError?: boolean): Readable {
 
 suite('Extfs', () => {
 
-	test('mkdirp', function (done: () => void) {
+	test('mkdirp', function (done) {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
 
 		mkdirp(newDir, 493, error => {
 			if (error) {
-				return onError(error, done);
+				return done(error);
 			}
 
 			assert.ok(fs.existsSync(newDir));
@@ -74,7 +73,7 @@ suite('Extfs', () => {
 		}); // 493 = 0755
 	});
 
-	test('stat link', function (done: () => void) {
+	test('stat link', function (done) {
 		if (isWindows) {
 			// Symlinks are not the same on win, and we can not create them programitically without admin privileges
 			return done();
@@ -89,21 +88,21 @@ suite('Extfs', () => {
 
 		mkdirp(directory, 493, error => {
 			if (error) {
-				return onError(error, done);
+				return done(error);
 			}
 
 			fs.symlinkSync(directory, symbolicLink);
 
 			extfs.statLink(directory, (error, statAndIsLink) => {
 				if (error) {
-					return onError(error, done);
+					return done(error);
 				}
 
 				assert.ok(!statAndIsLink.isSymbolicLink);
 
 				extfs.statLink(symbolicLink, (error, statAndIsLink) => {
 					if (error) {
-						return onError(error, done);
+						return done(error);
 					}
 
 					assert.ok(statAndIsLink.isSymbolicLink);
@@ -124,14 +123,14 @@ suite('Extfs', () => {
 		assert.ok(!fs.existsSync(newDir));
 	});
 
-	test('delSync - simple', function (done: () => void) {
+	test('delSync - simple', function (done) {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
 
 		mkdirp(newDir, 493, error => {
 			if (error) {
-				return onError(error, done);
+				return done(error);
 			}
 
 			fs.writeFileSync(path.join(newDir, 'somefile.txt'), 'Contents');
@@ -144,14 +143,14 @@ suite('Extfs', () => {
 		}); // 493 = 0755
 	});
 
-	test('delSync - recursive folder structure', function (done: () => void) {
+	test('delSync - recursive folder structure', function (done) {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
 
 		mkdirp(newDir, 493, error => {
 			if (error) {
-				return onError(error, done);
+				return done(error);
 			}
 
 			fs.writeFileSync(path.join(newDir, 'somefile.txt'), 'Contents');
@@ -167,7 +166,7 @@ suite('Extfs', () => {
 		}); // 493 = 0755
 	});
 
-	test('copy, move and delete', function (done: () => void) {
+	test('copy, move and delete', function (done) {
 		const id = uuid.generateUuid();
 		const id2 = uuid.generateUuid();
 		const sourceDir = require.toUrl('./fixtures');
@@ -177,7 +176,7 @@ suite('Extfs', () => {
 
 		extfs.copy(sourceDir, targetDir, error => {
 			if (error) {
-				return onError(error, done);
+				return done(error);
 			}
 
 			assert.ok(fs.existsSync(targetDir));
@@ -189,7 +188,7 @@ suite('Extfs', () => {
 
 			extfs.mv(targetDir, targetDir2, error => {
 				if (error) {
-					return onError(error, done);
+					return done(error);
 				}
 
 				assert.ok(!fs.existsSync(targetDir));
@@ -202,7 +201,7 @@ suite('Extfs', () => {
 
 				extfs.mv(path.join(targetDir2, 'index.html'), path.join(targetDir2, 'index_moved.html'), error => {
 					if (error) {
-						return onError(error, done);
+						return done(error);
 					}
 
 					assert.ok(!fs.existsSync(path.join(targetDir2, 'index.html')));
@@ -210,11 +209,11 @@ suite('Extfs', () => {
 
 					extfs.del(parentDir, os.tmpdir(), error => {
 						if (error) {
-							return onError(error, done);
+							return done(error);
 						}
 					}, error => {
 						if (error) {
-							return onError(error, done);
+							return done(error);
 						}
 						assert.ok(!fs.existsSync(parentDir));
 						done();
@@ -224,7 +223,7 @@ suite('Extfs', () => {
 		});
 	});
 
-	test('readdir', function (done: () => void) {
+	test('readdir', function (done) {
 		if (strings.canNormalize && typeof process.versions['electron'] !== 'undefined' /* needs electron */) {
 			const id = uuid.generateUuid();
 			const parentDir = path.join(os.tmpdir(), 'vsctests', id);
@@ -232,7 +231,7 @@ suite('Extfs', () => {
 
 			mkdirp(newDir, 493, error => {
 				if (error) {
-					return onError(error, done);
+					return done(error);
 				}
 
 				assert.ok(fs.existsSync(newDir));
@@ -248,7 +247,7 @@ suite('Extfs', () => {
 		}
 	});
 
-	test('writeFileAndFlush (string)', function (done: () => void) {
+	test('writeFileAndFlush (string)', function (done) {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
@@ -256,14 +255,14 @@ suite('Extfs', () => {
 
 		mkdirp(newDir, 493, error => {
 			if (error) {
-				return onError(error, done);
+				return done(error);
 			}
 
 			assert.ok(fs.existsSync(newDir));
 
 			extfs.writeFileAndFlush(testFile, 'Hello World', null, error => {
 				if (error) {
-					return onError(error, done);
+					return done(error);
 				}
 
 				assert.equal(fs.readFileSync(testFile), 'Hello World');
@@ -272,7 +271,7 @@ suite('Extfs', () => {
 
 				extfs.writeFileAndFlush(testFile, largeString, null, error => {
 					if (error) {
-						return onError(error, done);
+						return done(error);
 					}
 
 					assert.equal(fs.readFileSync(testFile), largeString);
@@ -283,7 +282,7 @@ suite('Extfs', () => {
 		});
 	});
 
-	test('writeFileAndFlush (stream)', function (done: () => void) {
+	test('writeFileAndFlush (stream)', function (done) {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
@@ -291,14 +290,14 @@ suite('Extfs', () => {
 
 		mkdirp(newDir, 493, error => {
 			if (error) {
-				return onError(error, done);
+				return done(error);
 			}
 
 			assert.ok(fs.existsSync(newDir));
 
 			extfs.writeFileAndFlush(testFile, toReadable('Hello World'), null, error => {
 				if (error) {
-					return onError(error, done);
+					return done(error);
 				}
 
 				assert.equal(fs.readFileSync(testFile), 'Hello World');
@@ -307,7 +306,7 @@ suite('Extfs', () => {
 
 				extfs.writeFileAndFlush(testFile, toReadable(largeString), null, error => {
 					if (error) {
-						return onError(error, done);
+						return done(error);
 					}
 
 					assert.equal(fs.readFileSync(testFile), largeString);
@@ -318,7 +317,7 @@ suite('Extfs', () => {
 		});
 	});
 
-	test('writeFileAndFlush (file stream)', function (done: () => void) {
+	test('writeFileAndFlush (file stream)', function (done) {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const sourceFile = require.toUrl('./fixtures/index.html');
@@ -327,14 +326,14 @@ suite('Extfs', () => {
 
 		mkdirp(newDir, 493, error => {
 			if (error) {
-				return onError(error, done);
+				return done(error);
 			}
 
 			assert.ok(fs.existsSync(newDir));
 
 			extfs.writeFileAndFlush(testFile, fs.createReadStream(sourceFile), null, error => {
 				if (error) {
-					return onError(error, done);
+					return done(error);
 				}
 
 				assert.equal(fs.readFileSync(testFile).toString(), fs.readFileSync(sourceFile).toString());
@@ -344,7 +343,7 @@ suite('Extfs', () => {
 		});
 	});
 
-	test('writeFileAndFlush (string, error handling)', function (done: () => void) {
+	test('writeFileAndFlush (string, error handling)', function (done) {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
@@ -352,7 +351,7 @@ suite('Extfs', () => {
 
 		mkdirp(newDir, 493, error => {
 			if (error) {
-				return onError(error, done);
+				return done(error);
 			}
 
 			assert.ok(fs.existsSync(newDir));
@@ -361,7 +360,7 @@ suite('Extfs', () => {
 
 			extfs.writeFileAndFlush(testFile, 'Hello World', null, error => {
 				if (!error) {
-					return onError(new Error('Expected error for writing to readonly file'), done);
+					return done(new Error('Expected error for writing to readonly file'));
 				}
 
 				extfs.del(parentDir, os.tmpdir(), done, ignore);
@@ -369,7 +368,7 @@ suite('Extfs', () => {
 		});
 	});
 
-	test('writeFileAndFlush (stream, error handling EISDIR)', function (done: () => void) {
+	test('writeFileAndFlush (stream, error handling EISDIR)', function (done) {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
@@ -377,7 +376,7 @@ suite('Extfs', () => {
 
 		mkdirp(newDir, 493, error => {
 			if (error) {
-				return onError(error, done);
+				return done(error);
 			}
 
 			assert.ok(fs.existsSync(newDir));
@@ -387,7 +386,7 @@ suite('Extfs', () => {
 			const readable = toReadable('Hello World');
 			extfs.writeFileAndFlush(testFile, readable, null, error => {
 				if (!error || (<any>error).code !== 'EISDIR') {
-					return onError(new Error('Expected EISDIR error for writing to folder but got: ' + (error ? (<any>error).code : 'no error')), done);
+					return done(new Error('Expected EISDIR error for writing to folder but got: ' + (error ? (<any>error).code : 'no error')));
 				}
 
 				// verify that the stream is still consumable (for https://github.com/Microsoft/vscode/issues/42542)
@@ -398,7 +397,7 @@ suite('Extfs', () => {
 		});
 	});
 
-	test('writeFileAndFlush (stream, error handling READERROR)', function (done: () => void) {
+	test('writeFileAndFlush (stream, error handling READERROR)', function (done) {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
@@ -406,14 +405,14 @@ suite('Extfs', () => {
 
 		mkdirp(newDir, 493, error => {
 			if (error) {
-				return onError(error, done);
+				return done(error);
 			}
 
 			assert.ok(fs.existsSync(newDir));
 
 			extfs.writeFileAndFlush(testFile, toReadable('Hello World', true /* throw error */), null, error => {
 				if (!error || error.message !== readError) {
-					return onError(new Error('Expected error for writing to folder'), done);
+					return done(new Error('Expected error for writing to folder'));
 				}
 
 				extfs.del(parentDir, os.tmpdir(), done, ignore);
@@ -421,7 +420,7 @@ suite('Extfs', () => {
 		});
 	});
 
-	test('writeFileAndFlush (stream, error handling EACCES)', function (done: () => void) {
+	test('writeFileAndFlush (stream, error handling EACCES)', function (done) {
 		if (isLinux) {
 			return done(); // somehow this test fails on Linux in our TFS builds
 		}
@@ -433,7 +432,7 @@ suite('Extfs', () => {
 
 		mkdirp(newDir, 493, error => {
 			if (error) {
-				return onError(error, done);
+				return done(error);
 			}
 
 			assert.ok(fs.existsSync(newDir));
@@ -443,7 +442,7 @@ suite('Extfs', () => {
 
 			extfs.writeFileAndFlush(testFile, toReadable('Hello World'), null, error => {
 				if (!error || !((<any>error).code !== 'EACCES' || (<any>error).code !== 'EPERM')) {
-					return onError(new Error('Expected EACCES/EPERM error for writing to folder but got: ' + (error ? (<any>error).code : 'no error')), done);
+					return done(new Error('Expected EACCES/EPERM error for writing to folder but got: ' + (error ? (<any>error).code : 'no error')));
 				}
 
 				extfs.del(parentDir, os.tmpdir(), done, ignore);
@@ -451,7 +450,7 @@ suite('Extfs', () => {
 		});
 	});
 
-	test('writeFileAndFlush (file stream, error handling)', function (done: () => void) {
+	test('writeFileAndFlush (file stream, error handling)', function (done) {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const sourceFile = require.toUrl('./fixtures/index.html');
@@ -460,7 +459,7 @@ suite('Extfs', () => {
 
 		mkdirp(newDir, 493, error => {
 			if (error) {
-				return onError(error, done);
+				return done(error);
 			}
 
 			assert.ok(fs.existsSync(newDir));
@@ -469,7 +468,7 @@ suite('Extfs', () => {
 
 			extfs.writeFileAndFlush(testFile, fs.createReadStream(sourceFile), null, error => {
 				if (!error) {
-					return onError(new Error('Expected error for writing to folder'), done);
+					return done(new Error('Expected error for writing to folder'));
 				}
 
 				extfs.del(parentDir, os.tmpdir(), done, ignore);
@@ -477,7 +476,7 @@ suite('Extfs', () => {
 		});
 	});
 
-	test('writeFileAndFlushSync', function (done: () => void) {
+	test('writeFileAndFlushSync', function (done) {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
@@ -485,7 +484,7 @@ suite('Extfs', () => {
 
 		mkdirp(newDir, 493, error => {
 			if (error) {
-				return onError(error, done);
+				return done(error);
 			}
 
 			assert.ok(fs.existsSync(newDir));

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

@@ -6,7 +6,7 @@
 'use strict';
 
 import * as assert from 'assert';
-import flow = require('vs/base/node/flow');
+import * as flow from 'vs/base/node/flow';
 
 const loop = flow.loop;
 const sequence = flow.sequence;

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

@@ -6,7 +6,7 @@
 
 import * as assert from 'assert';
 import * as path from 'path';
-import glob = require('vs/base/common/glob');
+import * as glob from 'vs/base/common/glob';
 import { isWindows } from 'vs/base/common/platform';
 
 suite('Glob', () => {

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

@@ -1,91 +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 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');
-
-		readExactlyByFile(file, 512).then(buffer => {
-			const mimes = mime.detectMimeAndEncodingFromBuffer(buffer);
-			assert.deepEqual(mimes.mimes, ['text/plain']);
-			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');
-		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');
-		readExactlyByFile(file, 512).then(buffer => {
-			const mimes = mime.detectMimeAndEncodingFromBuffer(buffer);
-			assert.deepEqual(mimes.mimes, ['text/plain']);
-			done();
-		}, done);
-	});
-
-	test('detectMimesFromFile (QWOFF saved as TXT)', function (done: (err?: any) => void) {
-		const file = require.toUrl('./fixtures/some.qwoff.txt');
-		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');
-		readExactlyByFile(file, 512).then(buffer => {
-			const mimes = mime.detectMimeAndEncodingFromBuffer(buffer);
-			assert.deepEqual(mimes.mimes, ['text/plain']);
-			done();
-		}, done);
-	});
-
-	test('detectMimesFromFile (PDF)', function (done: () => void) {
-		const file = require.toUrl('./fixtures/some.pdf');
-		readExactlyByFile(file, 512).then(buffer => {
-			const mimes = mime.detectMimeAndEncodingFromBuffer(buffer);
-			assert.deepEqual(mimes.mimes, ['application/octet-stream']);
-			done();
-		}, done);
-	});
-
-	test('autoGuessEncoding (ShiftJIS)', function (done: () => void) {
-		const file = require.toUrl('./fixtures/some.shiftjis.txt');
-		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');
-		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

@@ -6,43 +6,36 @@
 
 import { TPromise } from 'vs/base/common/winjs.base';
 
-import assert = require('assert');
-import os = require('os');
+import * as assert from 'assert';
+import * as os from 'os';
 
-import path = require('path');
-import fs = require('fs');
+import * as path from 'path';
+import * as fs from 'fs';
 
-import uuid = require('vs/base/common/uuid');
-import extfs = require('vs/base/node/extfs');
-import { onError } from 'vs/base/test/common/utils';
+import * as uuid from 'vs/base/common/uuid';
 import * as pfs from 'vs/base/node/pfs';
+import { timeout } from 'vs/base/common/async';
 
 suite('PFS', () => {
 
-	test('writeFile', function (done: () => void) {
+	test('writeFile', function () {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'pfs', id);
 		const testFile = path.join(newDir, 'writefile.txt');
 
-		const onMkdirp = error => {
-			if (error) {
-				return onError(error, done);
-			}
-
+		return pfs.mkdirp(newDir, 493).then(() => {
 			assert.ok(fs.existsSync(newDir));
 
-			pfs.writeFile(testFile, 'Hello World', null).done(() => {
+			return pfs.writeFile(testFile, 'Hello World', null).then(() => {
 				assert.equal(fs.readFileSync(testFile), 'Hello World');
 
-				extfs.del(parentDir, os.tmpdir(), () => { }, done);
-			}, error => onError(error, done));
-		};
-
-		pfs.mkdirp(newDir, 493).done(() => onMkdirp(null), error => onMkdirp(error));
+				return pfs.del(parentDir, os.tmpdir());
+			});
+		});
 	});
 
-	test('writeFile - parallel write on different files works', function (done: () => void) {
+	test('writeFile - parallel write on different files works', function () {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'pfs', id);
@@ -52,106 +45,80 @@ suite('PFS', () => {
 		const testFile4 = path.join(newDir, 'writefile4.txt');
 		const testFile5 = path.join(newDir, 'writefile5.txt');
 
-		const onMkdirp = error => {
-			if (error) {
-				return onError(error, done);
-			}
-
+		return pfs.mkdirp(newDir, 493).then(() => {
 			assert.ok(fs.existsSync(newDir));
 
-			TPromise.join([
+			return TPromise.join([
 				pfs.writeFile(testFile1, 'Hello World 1', null),
 				pfs.writeFile(testFile2, 'Hello World 2', null),
 				pfs.writeFile(testFile3, 'Hello World 3', null),
 				pfs.writeFile(testFile4, 'Hello World 4', null),
 				pfs.writeFile(testFile5, 'Hello World 5', null)
-			]).done(() => {
+			]).then(() => {
 				assert.equal(fs.readFileSync(testFile1), 'Hello World 1');
 				assert.equal(fs.readFileSync(testFile2), 'Hello World 2');
 				assert.equal(fs.readFileSync(testFile3), 'Hello World 3');
 				assert.equal(fs.readFileSync(testFile4), 'Hello World 4');
 				assert.equal(fs.readFileSync(testFile5), 'Hello World 5');
 
-				extfs.del(parentDir, os.tmpdir(), () => { }, done);
-			}, error => onError(error, done));
-		};
-
-		pfs.mkdirp(newDir, 493).done(() => onMkdirp(null), error => onMkdirp(error));
+				return pfs.del(parentDir, os.tmpdir());
+			});
+		});
 	});
 
-	test('writeFile - parallel write on same files works and is sequentalized', function (done: () => void) {
+	test('writeFile - parallel write on same files works and is sequentalized', function () {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'pfs', id);
 		const testFile = path.join(newDir, 'writefile.txt');
 
-		const onMkdirp = error => {
-			if (error) {
-				return onError(error, done);
-			}
-
+		return pfs.mkdirp(newDir, 493).then(() => {
 			assert.ok(fs.existsSync(newDir));
 
-			TPromise.join([
+			return TPromise.join([
 				pfs.writeFile(testFile, 'Hello World 1', null),
 				pfs.writeFile(testFile, 'Hello World 2', null),
-				TPromise.timeout(10).then(() => pfs.writeFile(testFile, 'Hello World 3', null)),
+				timeout(10).then(() => pfs.writeFile(testFile, 'Hello World 3', null)),
 				pfs.writeFile(testFile, 'Hello World 4', null),
-				TPromise.timeout(10).then(() => pfs.writeFile(testFile, 'Hello World 5', null))
-			]).done(() => {
+				timeout(10).then(() => pfs.writeFile(testFile, 'Hello World 5', null))
+			]).then(() => {
 				assert.equal(fs.readFileSync(testFile), 'Hello World 5');
 
-				extfs.del(parentDir, os.tmpdir(), () => { }, done);
-			}, error => onError(error, done));
-		};
-
-		pfs.mkdirp(newDir, 493).done(() => onMkdirp(null), error => onMkdirp(error));
+				return pfs.del(parentDir, os.tmpdir());
+			});
+		});
 	});
 
-	test('rimraf - simple', function (done: () => void) {
+	test('rimraf - simple', function () {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
 
-		const onMkdirp = error => {
-			if (error) {
-				return onError(error, done);
-			}
-
+		return pfs.mkdirp(newDir, 493).then(() => {
 			fs.writeFileSync(path.join(newDir, 'somefile.txt'), 'Contents');
 			fs.writeFileSync(path.join(newDir, 'someOtherFile.txt'), 'Contents');
 
-			pfs.rimraf(newDir).then(() => {
+			return pfs.rimraf(newDir).then(() => {
 				assert.ok(!fs.existsSync(newDir));
-				done();
-			}, error => onError(error, done));
-		};
-
-		pfs.mkdirp(newDir, 493).done(() => onMkdirp(null), error => onMkdirp(error));
+			});
+		});
 	});
 
-	test('rimraf - recursive folder structure', function (done: () => void) {
+	test('rimraf - recursive folder structure', function () {
 		const id = uuid.generateUuid();
 		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
 		const newDir = path.join(parentDir, 'extfs', id);
 
-		const onMkdirp = error => {
-			if (error) {
-				return onError(error, done);
-			}
-
+		return pfs.mkdirp(newDir, 493).then(() => {
 			fs.writeFileSync(path.join(newDir, 'somefile.txt'), 'Contents');
 			fs.writeFileSync(path.join(newDir, 'someOtherFile.txt'), 'Contents');
 
 			fs.mkdirSync(path.join(newDir, 'somefolder'));
 			fs.writeFileSync(path.join(newDir, 'somefolder', 'somefile.txt'), 'Contents');
 
-			pfs.rimraf(newDir).then(() => {
+			return pfs.rimraf(newDir).then(() => {
 				assert.ok(!fs.existsSync(newDir));
-				done();
-			}, error => onError(error, done));
-		};
-
-		pfs.mkdirp(newDir, 493).done(() => onMkdirp(null), error => onMkdirp(error));
+			});
+		});
 	});
 });

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

@@ -7,10 +7,10 @@
 
 import * as assert from 'assert';
 import * as net from 'net';
-import ports = require('vs/base/node/ports');
+import * as ports from 'vs/base/node/ports';
 
 suite('Ports', () => {
-	test('Finds a free port (no timeout)', function (done: () => void) {
+	test('Finds a free port (no timeout)', function (done) {
 		this.timeout(1000 * 10); // higher timeout for this test
 
 		if (process.env['VSCODE_PID']) {
@@ -31,8 +31,8 @@ suite('Ports', () => {
 					server.close();
 
 					done();
-				});
+				}, err => done(err));
 			});
-		});
+		}, err => done(err));
 	});
 });

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

@@ -5,9 +5,9 @@
 
 'use strict';
 
-import processes = require('vs/base/node/processes');
+import * as processes from 'vs/base/node/processes';
 
-const sender = processes.createQueuedSender(process);
+const sender = processes.createQueuedSender(<any>process);
 
 process.on('message', msg => {
 	sender.send(msg);

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

@@ -5,9 +5,9 @@
 
 'use strict';
 
-import processes = require('vs/base/node/processes');
+import * as processes from 'vs/base/node/processes';
 
-const sender = processes.createQueuedSender(process);
+const sender = processes.createQueuedSender(<any>process);
 
 process.on('message', msg => {
 	sender.send(msg);

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

@@ -10,7 +10,7 @@ import * as cp from 'child_process';
 import * as objects from 'vs/base/common/objects';
 import * as platform from 'vs/base/common/platform';
 import URI from 'vs/base/common/uri';
-import processes = require('vs/base/node/processes');
+import * as processes from 'vs/base/node/processes';
 
 function fork(id: string): cp.ChildProcess {
 	const opts: any = {

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

@@ -5,47 +5,42 @@
 
 'use strict';
 
-import assert = require('assert');
+import * as assert from 'assert';
 
-import stream = require('vs/base/node/stream');
+import * as stream from 'vs/base/node/stream';
 
 suite('Stream', () => {
-	test('readExactlyByFile - ANSI', function (done: (err?) => void) {
+	test('readExactlyByFile - ANSI', function () {
 		const file = require.toUrl('./fixtures/file.css');
 
-		stream.readExactlyByFile(file, 10).then(({ buffer, bytesRead }) => {
+		return stream.readExactlyByFile(file, 10).then(({ buffer, bytesRead }) => {
 			assert.equal(bytesRead, 10);
 			assert.equal(buffer.toString(), '/*--------');
-			done();
-		}, done);
+		});
 	});
 
-	test('readExactlyByFile - empty', function (done: (err?: any) => void) {
+	test('readExactlyByFile - empty', function () {
 		const file = require.toUrl('./fixtures/empty.txt');
 
-		stream.readExactlyByFile(file, 10).then(({ bytesRead }) => {
+		return stream.readExactlyByFile(file, 10).then(({ bytesRead }) => {
 			assert.equal(bytesRead, 0);
-			done();
-		}, done);
+		});
 	});
 
-	test('readToMatchingString - ANSI', function (done: (err?: any) => void) {
+	test('readToMatchingString - ANSI', function () {
 		const file = require.toUrl('./fixtures/file.css');
 
-		stream.readToMatchingString(file, '\n', 10, 100).then((result: string) => {
+		return stream.readToMatchingString(file, '\n', 10, 100).then((result: string) => {
 			// \r may be present on Windows
 			assert.equal(result.replace('\r', ''), '/*---------------------------------------------------------------------------------------------');
-			done();
-		}, done);
+		});
 	});
 
-	test('readToMatchingString - empty', function (done: (err?: any) => void) {
+	test('readToMatchingString - empty', function () {
 		const file = require.toUrl('./fixtures/empty.txt');
 
-		stream.readToMatchingString(file, '\n', 10, 100).then((result: string) => {
+		return stream.readToMatchingString(file, '\n', 10, 100).then((result: string) => {
 			assert.equal(result, null);
-
-			done();
-		}, done);
+		});
 	});
 });

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

@@ -0,0 +1,31 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { TPromise } from 'vs/base/common/winjs.base';
+import { generateUuid } from 'vs/base/common/uuid';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { mkdirp, del } from 'vs/base/node/pfs';
+
+export interface ITestFileResult {
+	testFile: string;
+	cleanUp: () => TPromise<void>;
+}
+
+export function testFile(folder: string, file: string): TPromise<ITestFileResult> {
+	const id = generateUuid();
+	const parentDir = join(tmpdir(), 'vsctests', id);
+	const newDir = join(parentDir, 'config', id);
+	const testFile = join(newDir, 'config.json');
+
+	return mkdirp(newDir, 493).then(() => {
+		return {
+			testFile,
+			cleanUp: () => del(parentDir, tmpdir())
+		} as ITestFileResult;
+	});
+}

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

@@ -12,6 +12,7 @@ import URI from 'vs/base/common/uri';
 import { extract } from 'vs/base/node/zip';
 import { generateUuid } from 'vs/base/common/uuid';
 import { rimraf, exists } from 'vs/base/node/pfs';
+import { NullLogService } from '../../../../platform/log/common/log';
 
 const fixtures = URI.parse(require.toUrl('./fixtures')).fsPath;
 
@@ -21,7 +22,7 @@ suite('Zip', () => {
 		const fixture = path.join(fixtures, 'extract.zip');
 		const target = path.join(os.tmpdir(), generateUuid());
 
-		return extract(fixture, target)
+		return extract(fixture, target, {}, new NullLogService())
 			.then(() => exists(path.join(target, 'extension')))
 			.then(exists => assert(exists))
 			.then(() => rimraf(target));