Merge commit 'be3e8236086165e5e45a5a10783823874b3f3ebd' as 'lib/vscode'

lib/vscode/src/vs/base/test/node/buffer.test.ts

@@ -0,0 +1,413 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { VSBuffer, bufferToReadable, readableToBuffer, bufferToStream, streamToBuffer, newWriteableBufferStream, bufferedStreamToBuffer } from 'vs/base/common/buffer';
+import { timeout } from 'vs/base/common/async';
+import { peekStream } from 'vs/base/common/stream';
+
+suite('Buffer', () => {
+
+	test('issue #71993 - VSBuffer#toString returns numbers', () => {
+		const data = new Uint8Array([1, 2, 3, 'h'.charCodeAt(0), 'i'.charCodeAt(0), 4, 5]).buffer;
+		const buffer = VSBuffer.wrap(new Uint8Array(data, 3, 2));
+		assert.deepEqual(buffer.toString(), 'hi');
+	});
+
+	test('bufferToReadable / readableToBuffer', () => {
+		const content = 'Hello World';
+		const readable = bufferToReadable(VSBuffer.fromString(content));
+
+		assert.equal(readableToBuffer(readable).toString(), content);
+	});
+
+	test('bufferToStream / streamToBuffer', async () => {
+		const content = 'Hello World';
+		const stream = bufferToStream(VSBuffer.fromString(content));
+
+		assert.equal((await streamToBuffer(stream)).toString(), content);
+	});
+
+	test('bufferedStreamToBuffer', async () => {
+		const content = 'Hello World';
+		const stream = await peekStream(bufferToStream(VSBuffer.fromString(content)), 1);
+
+		assert.equal((await bufferedStreamToBuffer(stream)).toString(), content);
+	});
+
+	test('bufferWriteableStream - basics (no error)', async () => {
+		const stream = newWriteableBufferStream();
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.end(VSBuffer.fromString('World'));
+
+		assert.equal(chunks.length, 2);
+		assert.equal(chunks[0].toString(), 'Hello');
+		assert.equal(chunks[1].toString(), 'World');
+		assert.equal(ended, true);
+		assert.equal(errors.length, 0);
+	});
+
+	test('bufferWriteableStream - basics (error)', async () => {
+		const stream = newWriteableBufferStream();
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.end(new Error());
+
+		assert.equal(chunks.length, 1);
+		assert.equal(chunks[0].toString(), 'Hello');
+		assert.equal(ended, true);
+		assert.equal(errors.length, 1);
+	});
+
+	test('bufferWriteableStream - buffers data when no listener', async () => {
+		const stream = newWriteableBufferStream();
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.end(VSBuffer.fromString('World'));
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		assert.equal(chunks.length, 1);
+		assert.equal(chunks[0].toString(), 'HelloWorld');
+		assert.equal(ended, true);
+		assert.equal(errors.length, 0);
+	});
+
+	test('bufferWriteableStream - buffers errors when no listener', async () => {
+		const stream = newWriteableBufferStream();
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.error(new Error());
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		stream.end();
+
+		assert.equal(chunks.length, 1);
+		assert.equal(chunks[0].toString(), 'Hello');
+		assert.equal(ended, true);
+		assert.equal(errors.length, 1);
+	});
+
+	test('bufferWriteableStream - buffers end when no listener', async () => {
+		const stream = newWriteableBufferStream();
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.end(VSBuffer.fromString('World'));
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		assert.equal(chunks.length, 1);
+		assert.equal(chunks[0].toString(), 'HelloWorld');
+		assert.equal(ended, true);
+		assert.equal(errors.length, 0);
+	});
+
+	test('bufferWriteableStream - nothing happens after end()', async () => {
+		const stream = newWriteableBufferStream();
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.end(VSBuffer.fromString('World'));
+
+		let dataCalledAfterEnd = false;
+		stream.on('data', data => {
+			dataCalledAfterEnd = true;
+		});
+
+		let errorCalledAfterEnd = false;
+		stream.on('error', error => {
+			errorCalledAfterEnd = true;
+		});
+
+		let endCalledAfterEnd = false;
+		stream.on('end', () => {
+			endCalledAfterEnd = true;
+		});
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.error(new Error());
+		await timeout(0);
+		stream.end(VSBuffer.fromString('World'));
+
+		assert.equal(dataCalledAfterEnd, false);
+		assert.equal(errorCalledAfterEnd, false);
+		assert.equal(endCalledAfterEnd, false);
+
+		assert.equal(chunks.length, 2);
+		assert.equal(chunks[0].toString(), 'Hello');
+		assert.equal(chunks[1].toString(), 'World');
+	});
+
+	test('bufferWriteableStream - pause/resume (simple)', async () => {
+		const stream = newWriteableBufferStream();
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		stream.pause();
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.end(VSBuffer.fromString('World'));
+
+		assert.equal(chunks.length, 0);
+		assert.equal(errors.length, 0);
+		assert.equal(ended, false);
+
+		stream.resume();
+
+		assert.equal(chunks.length, 1);
+		assert.equal(chunks[0].toString(), 'HelloWorld');
+		assert.equal(ended, true);
+		assert.equal(errors.length, 0);
+	});
+
+	test('bufferWriteableStream - pause/resume (pause after first write)', async () => {
+		const stream = newWriteableBufferStream();
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+
+		stream.pause();
+
+		await timeout(0);
+		stream.end(VSBuffer.fromString('World'));
+
+		assert.equal(chunks.length, 1);
+		assert.equal(chunks[0].toString(), 'Hello');
+		assert.equal(errors.length, 0);
+		assert.equal(ended, false);
+
+		stream.resume();
+
+		assert.equal(chunks.length, 2);
+		assert.equal(chunks[0].toString(), 'Hello');
+		assert.equal(chunks[1].toString(), 'World');
+		assert.equal(ended, true);
+		assert.equal(errors.length, 0);
+	});
+
+	test('bufferWriteableStream - pause/resume (error)', async () => {
+		const stream = newWriteableBufferStream();
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		stream.pause();
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.end(new Error());
+
+		assert.equal(chunks.length, 0);
+		assert.equal(ended, false);
+		assert.equal(errors.length, 0);
+
+		stream.resume();
+
+		assert.equal(chunks.length, 1);
+		assert.equal(chunks[0].toString(), 'Hello');
+		assert.equal(ended, true);
+		assert.equal(errors.length, 1);
+	});
+
+	test('bufferWriteableStream - destroy', async () => {
+		const stream = newWriteableBufferStream();
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		stream.destroy();
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.end(VSBuffer.fromString('World'));
+
+		assert.equal(chunks.length, 0);
+		assert.equal(ended, false);
+		assert.equal(errors.length, 0);
+	});
+
+	test('Performance issue with VSBuffer#slice #76076', function () {
+		// Buffer#slice creates a view
+		{
+			const buff = Buffer.from([10, 20, 30, 40]);
+			const b2 = buff.slice(1, 3);
+			assert.equal(buff[1], 20);
+			assert.equal(b2[0], 20);
+
+			buff[1] = 17; // modify buff AND b2
+			assert.equal(buff[1], 17);
+			assert.equal(b2[0], 17);
+		}
+
+		// TypedArray#slice creates a copy
+		{
+			const unit = new Uint8Array([10, 20, 30, 40]);
+			const u2 = unit.slice(1, 3);
+			assert.equal(unit[1], 20);
+			assert.equal(u2[0], 20);
+
+			unit[1] = 17; // modify unit, NOT b2
+			assert.equal(unit[1], 17);
+			assert.equal(u2[0], 20);
+		}
+
+		// TypedArray#subarray creates a view
+		{
+			const unit = new Uint8Array([10, 20, 30, 40]);
+			const u2 = unit.subarray(1, 3);
+			assert.equal(unit[1], 20);
+			assert.equal(u2[0], 20);
+
+			unit[1] = 17; // modify unit AND b2
+			assert.equal(unit[1], 17);
+			assert.equal(u2[0], 17);
+		}
+	});
+});

lib/vscode/src/vs/base/test/node/console.test.ts

@@ -0,0 +1,48 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { getFirstFrame } from 'vs/base/common/console';
+import { normalize } from 'vs/base/common/path';
+
+suite('Console', () => {
+
+	test('getFirstFrame', () => {
+		let stack = 'at vscode.commands.registerCommand (/Users/someone/Desktop/test-ts/out/src/extension.js:18:17)';
+		let frame = getFirstFrame(stack)!;
+
+		assert.equal(frame.uri.fsPath, normalize('/Users/someone/Desktop/test-ts/out/src/extension.js'));
+		assert.equal(frame.line, 18);
+		assert.equal(frame.column, 17);
+
+		stack = 'at /Users/someone/Desktop/test-ts/out/src/extension.js:18:17';
+		frame = getFirstFrame(stack)!;
+
+		assert.equal(frame.uri.fsPath, normalize('/Users/someone/Desktop/test-ts/out/src/extension.js'));
+		assert.equal(frame.line, 18);
+		assert.equal(frame.column, 17);
+
+		stack = 'at c:\\Users\\someone\\Desktop\\end-js\\extension.js:18:17';
+		frame = getFirstFrame(stack)!;
+
+		assert.equal(frame.uri.fsPath, 'c:\\Users\\someone\\Desktop\\end-js\\extension.js');
+		assert.equal(frame.line, 18);
+		assert.equal(frame.column, 17);
+
+		stack = 'at e.$executeContributedCommand(c:\\Users\\someone\\Desktop\\end-js\\extension.js:18:17)';
+		frame = getFirstFrame(stack)!;
+
+		assert.equal(frame.uri.fsPath, 'c:\\Users\\someone\\Desktop\\end-js\\extension.js');
+		assert.equal(frame.line, 18);
+		assert.equal(frame.column, 17);
+
+		stack = 'at /Users/someone/Desktop/test-ts/out/src/extension.js:18:17\nat /Users/someone/Desktop/test-ts/out/src/other.js:28:27\nat /Users/someone/Desktop/test-ts/out/src/more.js:38:37';
+		frame = getFirstFrame(stack)!;
+
+		assert.equal(frame.uri.fsPath, normalize('/Users/someone/Desktop/test-ts/out/src/extension.js'));
+		assert.equal(frame.line, 18);
+		assert.equal(frame.column, 17);
+	});
+});

lib/vscode/src/vs/base/test/node/crypto.test.ts

@@ -0,0 +1,27 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { checksum } from 'vs/base/node/crypto';
+import { generateUuid } from 'vs/base/common/uuid';
+import { join } from 'vs/base/common/path';
+import { tmpdir } from 'os';
+import { mkdirp, rimraf, RimRafMode, writeFile } from 'vs/base/node/pfs';
+
+suite('Crypto', () => {
+
+	test('checksum', async () => {
+		const id = generateUuid();
+		const testDir = join(tmpdir(), 'vsctests', id);
+		const testFile = join(testDir, 'checksum.txt');
+
+		await mkdirp(testDir);
+
+		await writeFile(testFile, 'Hello World');
+
+		await checksum(testFile, '0a4d55a8d778e5022fab701977c5d840bbc486d0');
+
+		await rimraf(testDir, RimRafMode.MOVE);
+	});
+});

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

@@ -0,0 +1,22 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import * as decoder from 'vs/base/node/decoder';
+
+suite('Decoder', () => {
+
+	test('decoding', () => {
+		const lineDecoder = new decoder.LineDecoder();
+		let res = lineDecoder.write(Buffer.from('hello'));
+		assert.equal(res.length, 0);
+
+		res = lineDecoder.write(Buffer.from('\nworld'));
+		assert.equal(res[0], 'hello');
+		assert.equal(res.length, 1);
+
+		assert.equal(lineDecoder.end(), 'world');
+	});
+});

lib/vscode/src/vs/base/test/node/extpath.test.ts

@@ -0,0 +1,73 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import * as os from 'os';
+import * as path from 'vs/base/common/path';
+import * as uuid from 'vs/base/common/uuid';
+import * as pfs from 'vs/base/node/pfs';
+import { realcaseSync, realpath, realpathSync } from 'vs/base/node/extpath';
+
+suite('Extpath', () => {
+
+	test('realcase', async () => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'extpath', id);
+
+		await pfs.mkdirp(newDir, 493);
+
+		// assume case insensitive file system
+		if (process.platform === 'win32' || process.platform === 'darwin') {
+			const upper = newDir.toUpperCase();
+			const real = realcaseSync(upper);
+
+			if (real) { // can be null in case of permission errors
+				assert.notEqual(real, upper);
+				assert.equal(real.toUpperCase(), upper);
+				assert.equal(real, newDir);
+			}
+		}
+
+		// linux, unix, etc. -> assume case sensitive file system
+		else {
+			const real = realcaseSync(newDir);
+			assert.equal(real, newDir);
+		}
+
+		await pfs.rimraf(parentDir, pfs.RimRafMode.MOVE);
+	});
+
+	test('realpath', async () => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'extpath', id);
+
+		await pfs.mkdirp(newDir, 493);
+
+		const realpathVal = await realpath(newDir);
+		assert.ok(realpathVal);
+
+		await pfs.rimraf(parentDir, pfs.RimRafMode.MOVE);
+	});
+
+	test('realpathSync', async () => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'extpath', id);
+
+		await pfs.mkdirp(newDir, 493);
+
+		let realpath!: string;
+		try {
+			realpath = realpathSync(newDir);
+		} catch (error) {
+			assert.ok(!error);
+		}
+		assert.ok(realpath!);
+
+		await pfs.rimraf(parentDir, pfs.RimRafMode.MOVE);
+	});
+});

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

@@ -0,0 +1,23 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as assert from 'assert';
+import { getMachineId } from 'vs/base/node/id';
+import { getMac } from 'vs/base/node/macAddress';
+
+suite('ID', () => {
+
+	test('getMachineId', function () {
+		this.timeout(20000);
+		return getMachineId().then(id => {
+			assert.ok(id);
+		});
+	});
+
+	test('getMac', () => {
+		return getMac().then(macAddress => {
+			assert.ok(/^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/.test(macAddress), `Expected a MAC address, got: ${macAddress}`);
+		});
+	});
+});

lib/vscode/src/vs/base/test/node/keytar.test.ts

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as assert from 'assert';
+import * as platform from 'vs/base/common/platform';
+
+suite('Keytar', () => {
+
+	test('loads and is functional', function (done) {
+		if (platform.isLinux) {
+			// Skip test due to set up issue with Travis.
+			this.skip();
+			return;
+		}
+		(async () => {
+			const keytar = await import('keytar');
+			const name = `VSCode Test ${Math.floor(Math.random() * 1e9)}`;
+			try {
+				await keytar.setPassword(name, 'foo', 'bar');
+				assert.equal(await keytar.findPassword(name), 'bar');
+				assert.equal((await keytar.findCredentials(name)).length, 1);
+				assert.equal(await keytar.getPassword(name, 'foo'), 'bar');
+				await keytar.deletePassword(name, 'foo');
+				assert.equal(await keytar.getPassword(name, 'foo'), undefined);
+			} catch (err) {
+				// try to clean up
+				try {
+					await keytar.deletePassword(name, 'foo');
+				} finally {
+					// eslint-disable-next-line no-unsafe-finally
+					throw err;
+				}
+			}
+		})().then(done, done);
+	});
+});

lib/vscode/src/vs/base/test/node/path.test.ts

@@ -0,0 +1,819 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// NOTE: VSCode's copy of nodejs path library to be usable in common (non-node) namespace
+// Copied from: https://github.com/nodejs/node/tree/43dd49c9782848c25e5b03448c8a0f923f13c158
+
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+import * as assert from 'assert';
+import * as path from 'vs/base/common/path';
+import { isWindows } from 'vs/base/common/platform';
+import * as process from 'vs/base/common/process';
+
+suite('Paths (Node Implementation)', () => {
+	test('join', () => {
+		const failures = [] as string[];
+		const backslashRE = /\\/g;
+
+		const joinTests: any = [
+			[[path.posix.join, path.win32.join],
+			// arguments                     result
+			[[['.', 'x/b', '..', '/b/c.js'], 'x/b/c.js'],
+			[[], '.'],
+			[['/.', 'x/b', '..', '/b/c.js'], '/x/b/c.js'],
+			[['/foo', '../../../bar'], '/bar'],
+			[['foo', '../../../bar'], '../../bar'],
+			[['foo/', '../../../bar'], '../../bar'],
+			[['foo/x', '../../../bar'], '../bar'],
+			[['foo/x', './bar'], 'foo/x/bar'],
+			[['foo/x/', './bar'], 'foo/x/bar'],
+			[['foo/x/', '.', 'bar'], 'foo/x/bar'],
+			[['./'], './'],
+			[['.', './'], './'],
+			[['.', '.', '.'], '.'],
+			[['.', './', '.'], '.'],
+			[['.', '/./', '.'], '.'],
+			[['.', '/////./', '.'], '.'],
+			[['.'], '.'],
+			[['', '.'], '.'],
+			[['', 'foo'], 'foo'],
+			[['foo', '/bar'], 'foo/bar'],
+			[['', '/foo'], '/foo'],
+			[['', '', '/foo'], '/foo'],
+			[['', '', 'foo'], 'foo'],
+			[['foo', ''], 'foo'],
+			[['foo/', ''], 'foo/'],
+			[['foo', '', '/bar'], 'foo/bar'],
+			[['./', '..', '/foo'], '../foo'],
+			[['./', '..', '..', '/foo'], '../../foo'],
+			[['.', '..', '..', '/foo'], '../../foo'],
+			[['', '..', '..', '/foo'], '../../foo'],
+			[['/'], '/'],
+			[['/', '.'], '/'],
+			[['/', '..'], '/'],
+			[['/', '..', '..'], '/'],
+			[[''], '.'],
+			[['', ''], '.'],
+			[[' /foo'], ' /foo'],
+			[[' ', 'foo'], ' /foo'],
+			[[' ', '.'], ' '],
+			[[' ', '/'], ' /'],
+			[[' ', ''], ' '],
+			[['/', 'foo'], '/foo'],
+			[['/', '/foo'], '/foo'],
+			[['/', '//foo'], '/foo'],
+			[['/', '', '/foo'], '/foo'],
+			[['', '/', 'foo'], '/foo'],
+			[['', '/', '/foo'], '/foo']
+			]
+			]
+		];
+
+		// Windows-specific join tests
+		joinTests.push([
+			path.win32.join,
+			joinTests[0][1].slice(0).concat(
+				[// arguments                     result
+					// UNC path expected
+					[['//foo/bar'], '\\\\foo\\bar\\'],
+					[['\\/foo/bar'], '\\\\foo\\bar\\'],
+					[['\\\\foo/bar'], '\\\\foo\\bar\\'],
+					// UNC path expected - server and share separate
+					[['//foo', 'bar'], '\\\\foo\\bar\\'],
+					[['//foo/', 'bar'], '\\\\foo\\bar\\'],
+					[['//foo', '/bar'], '\\\\foo\\bar\\'],
+					// UNC path expected - questionable
+					[['//foo', '', 'bar'], '\\\\foo\\bar\\'],
+					[['//foo/', '', 'bar'], '\\\\foo\\bar\\'],
+					[['//foo/', '', '/bar'], '\\\\foo\\bar\\'],
+					// UNC path expected - even more questionable
+					[['', '//foo', 'bar'], '\\\\foo\\bar\\'],
+					[['', '//foo/', 'bar'], '\\\\foo\\bar\\'],
+					[['', '//foo/', '/bar'], '\\\\foo\\bar\\'],
+					// No UNC path expected (no double slash in first component)
+					[['\\', 'foo/bar'], '\\foo\\bar'],
+					[['\\', '/foo/bar'], '\\foo\\bar'],
+					[['', '/', '/foo/bar'], '\\foo\\bar'],
+					// No UNC path expected (no non-slashes in first component -
+					// questionable)
+					[['//', 'foo/bar'], '\\foo\\bar'],
+					[['//', '/foo/bar'], '\\foo\\bar'],
+					[['\\\\', '/', '/foo/bar'], '\\foo\\bar'],
+					[['//'], '\\'],
+					// No UNC path expected (share name missing - questionable).
+					[['//foo'], '\\foo'],
+					[['//foo/'], '\\foo\\'],
+					[['//foo', '/'], '\\foo\\'],
+					[['//foo', '', '/'], '\\foo\\'],
+					// No UNC path expected (too many leading slashes - questionable)
+					[['///foo/bar'], '\\foo\\bar'],
+					[['////foo', 'bar'], '\\foo\\bar'],
+					[['\\\\\\/foo/bar'], '\\foo\\bar'],
+					// Drive-relative vs drive-absolute paths. This merely describes the
+					// status quo, rather than being obviously right
+					[['c:'], 'c:.'],
+					[['c:.'], 'c:.'],
+					[['c:', ''], 'c:.'],
+					[['', 'c:'], 'c:.'],
+					[['c:.', '/'], 'c:.\\'],
+					[['c:.', 'file'], 'c:file'],
+					[['c:', '/'], 'c:\\'],
+					[['c:', 'file'], 'c:\\file']
+				]
+			)
+		]);
+		joinTests.forEach((test: any[]) => {
+			if (!Array.isArray(test[0])) {
+				test[0] = [test[0]];
+			}
+			test[0].forEach((join: any) => {
+				test[1].forEach((test: any) => {
+					const actual = join.apply(null, test[0]);
+					const expected = test[1];
+					// For non-Windows specific tests with the Windows join(), we need to try
+					// replacing the slashes since the non-Windows specific tests' `expected`
+					// use forward slashes
+					let actualAlt;
+					let os;
+					if (join === path.win32.join) {
+						actualAlt = actual.replace(backslashRE, '/');
+						os = 'win32';
+					} else {
+						os = 'posix';
+					}
+					const message =
+						`path.${os}.join(${test[0].map(JSON.stringify).join(',')})\n  expect=${JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
+					if (actual !== expected && actualAlt !== expected) {
+						failures.push(`\n${message}`);
+					}
+				});
+			});
+		});
+		assert.strictEqual(failures.length, 0, failures.join(''));
+	});
+
+	test('dirname', () => {
+		assert.strictEqual(path.dirname(path.normalize(__filename)).substr(-9),
+			isWindows ? 'test\\node' : 'test/node');
+
+		assert.strictEqual(path.posix.dirname('/a/b/'), '/a');
+		assert.strictEqual(path.posix.dirname('/a/b'), '/a');
+		assert.strictEqual(path.posix.dirname('/a'), '/');
+		assert.strictEqual(path.posix.dirname(''), '.');
+		assert.strictEqual(path.posix.dirname('/'), '/');
+		assert.strictEqual(path.posix.dirname('////'), '/');
+		assert.strictEqual(path.posix.dirname('//a'), '//');
+		assert.strictEqual(path.posix.dirname('foo'), '.');
+
+		assert.strictEqual(path.win32.dirname('c:\\'), 'c:\\');
+		assert.strictEqual(path.win32.dirname('c:\\foo'), 'c:\\');
+		assert.strictEqual(path.win32.dirname('c:\\foo\\'), 'c:\\');
+		assert.strictEqual(path.win32.dirname('c:\\foo\\bar'), 'c:\\foo');
+		assert.strictEqual(path.win32.dirname('c:\\foo\\bar\\'), 'c:\\foo');
+		assert.strictEqual(path.win32.dirname('c:\\foo\\bar\\baz'), 'c:\\foo\\bar');
+		assert.strictEqual(path.win32.dirname('\\'), '\\');
+		assert.strictEqual(path.win32.dirname('\\foo'), '\\');
+		assert.strictEqual(path.win32.dirname('\\foo\\'), '\\');
+		assert.strictEqual(path.win32.dirname('\\foo\\bar'), '\\foo');
+		assert.strictEqual(path.win32.dirname('\\foo\\bar\\'), '\\foo');
+		assert.strictEqual(path.win32.dirname('\\foo\\bar\\baz'), '\\foo\\bar');
+		assert.strictEqual(path.win32.dirname('c:'), 'c:');
+		assert.strictEqual(path.win32.dirname('c:foo'), 'c:');
+		assert.strictEqual(path.win32.dirname('c:foo\\'), 'c:');
+		assert.strictEqual(path.win32.dirname('c:foo\\bar'), 'c:foo');
+		assert.strictEqual(path.win32.dirname('c:foo\\bar\\'), 'c:foo');
+		assert.strictEqual(path.win32.dirname('c:foo\\bar\\baz'), 'c:foo\\bar');
+		assert.strictEqual(path.win32.dirname('file:stream'), '.');
+		assert.strictEqual(path.win32.dirname('dir\\file:stream'), 'dir');
+		assert.strictEqual(path.win32.dirname('\\\\unc\\share'),
+			'\\\\unc\\share');
+		assert.strictEqual(path.win32.dirname('\\\\unc\\share\\foo'),
+			'\\\\unc\\share\\');
+		assert.strictEqual(path.win32.dirname('\\\\unc\\share\\foo\\'),
+			'\\\\unc\\share\\');
+		assert.strictEqual(path.win32.dirname('\\\\unc\\share\\foo\\bar'),
+			'\\\\unc\\share\\foo');
+		assert.strictEqual(path.win32.dirname('\\\\unc\\share\\foo\\bar\\'),
+			'\\\\unc\\share\\foo');
+		assert.strictEqual(path.win32.dirname('\\\\unc\\share\\foo\\bar\\baz'),
+			'\\\\unc\\share\\foo\\bar');
+		assert.strictEqual(path.win32.dirname('/a/b/'), '/a');
+		assert.strictEqual(path.win32.dirname('/a/b'), '/a');
+		assert.strictEqual(path.win32.dirname('/a'), '/');
+		assert.strictEqual(path.win32.dirname(''), '.');
+		assert.strictEqual(path.win32.dirname('/'), '/');
+		assert.strictEqual(path.win32.dirname('////'), '/');
+		assert.strictEqual(path.win32.dirname('foo'), '.');
+
+		// Tests from VSCode
+
+		function assertDirname(p: string, expected: string, win = false) {
+			const actual = win ? path.win32.dirname(p) : path.posix.dirname(p);
+
+			if (actual !== expected) {
+				assert.fail(`${p}: expected: ${expected}, ours: ${actual}`);
+			}
+		}
+
+		assertDirname('foo/bar', 'foo');
+		assertDirname('foo\\bar', 'foo', true);
+		assertDirname('/foo/bar', '/foo');
+		assertDirname('\\foo\\bar', '\\foo', true);
+		assertDirname('/foo', '/');
+		assertDirname('\\foo', '\\', true);
+		assertDirname('/', '/');
+		assertDirname('\\', '\\', true);
+		assertDirname('foo', '.');
+		assertDirname('f', '.');
+		assertDirname('f/', '.');
+		assertDirname('/folder/', '/');
+		assertDirname('c:\\some\\file.txt', 'c:\\some', true);
+		assertDirname('c:\\some', 'c:\\', true);
+		assertDirname('c:\\', 'c:\\', true);
+		assertDirname('c:', 'c:', true);
+		assertDirname('\\\\server\\share\\some\\path', '\\\\server\\share\\some', true);
+		assertDirname('\\\\server\\share\\some', '\\\\server\\share\\', true);
+		assertDirname('\\\\server\\share\\', '\\\\server\\share\\', true);
+	});
+
+	test('extname', () => {
+		const failures = [] as string[];
+		const slashRE = /\//g;
+
+		[
+			[__filename, '.js'],
+			['', ''],
+			['/path/to/file', ''],
+			['/path/to/file.ext', '.ext'],
+			['/path.to/file.ext', '.ext'],
+			['/path.to/file', ''],
+			['/path.to/.file', ''],
+			['/path.to/.file.ext', '.ext'],
+			['/path/to/f.ext', '.ext'],
+			['/path/to/..ext', '.ext'],
+			['/path/to/..', ''],
+			['file', ''],
+			['file.ext', '.ext'],
+			['.file', ''],
+			['.file.ext', '.ext'],
+			['/file', ''],
+			['/file.ext', '.ext'],
+			['/.file', ''],
+			['/.file.ext', '.ext'],
+			['.path/file.ext', '.ext'],
+			['file.ext.ext', '.ext'],
+			['file.', '.'],
+			['.', ''],
+			['./', ''],
+			['.file.ext', '.ext'],
+			['.file', ''],
+			['.file.', '.'],
+			['.file..', '.'],
+			['..', ''],
+			['../', ''],
+			['..file.ext', '.ext'],
+			['..file', '.file'],
+			['..file.', '.'],
+			['..file..', '.'],
+			['...', '.'],
+			['...ext', '.ext'],
+			['....', '.'],
+			['file.ext/', '.ext'],
+			['file.ext//', '.ext'],
+			['file/', ''],
+			['file//', ''],
+			['file./', '.'],
+			['file.//', '.'],
+		].forEach((test) => {
+			const expected = test[1];
+			[path.posix.extname, path.win32.extname].forEach((extname) => {
+				let input = test[0];
+				let os;
+				if (extname === path.win32.extname) {
+					input = input.replace(slashRE, '\\');
+					os = 'win32';
+				} else {
+					os = 'posix';
+				}
+				const actual = extname(input);
+				const message = `path.${os}.extname(${JSON.stringify(input)})\n  expect=${JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
+				if (actual !== expected) {
+					failures.push(`\n${message}`);
+				}
+			});
+			{
+				const input = `C:${test[0].replace(slashRE, '\\')}`;
+				const actual = path.win32.extname(input);
+				const message = `path.win32.extname(${JSON.stringify(input)})\n  expect=${JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
+				if (actual !== expected) {
+					failures.push(`\n${message}`);
+				}
+			}
+		});
+		assert.strictEqual(failures.length, 0, failures.join(''));
+
+		// On Windows, backslash is a path separator.
+		assert.strictEqual(path.win32.extname('.\\'), '');
+		assert.strictEqual(path.win32.extname('..\\'), '');
+		assert.strictEqual(path.win32.extname('file.ext\\'), '.ext');
+		assert.strictEqual(path.win32.extname('file.ext\\\\'), '.ext');
+		assert.strictEqual(path.win32.extname('file\\'), '');
+		assert.strictEqual(path.win32.extname('file\\\\'), '');
+		assert.strictEqual(path.win32.extname('file.\\'), '.');
+		assert.strictEqual(path.win32.extname('file.\\\\'), '.');
+
+		// On *nix, backslash is a valid name component like any other character.
+		assert.strictEqual(path.posix.extname('.\\'), '');
+		assert.strictEqual(path.posix.extname('..\\'), '.\\');
+		assert.strictEqual(path.posix.extname('file.ext\\'), '.ext\\');
+		assert.strictEqual(path.posix.extname('file.ext\\\\'), '.ext\\\\');
+		assert.strictEqual(path.posix.extname('file\\'), '');
+		assert.strictEqual(path.posix.extname('file\\\\'), '');
+		assert.strictEqual(path.posix.extname('file.\\'), '.\\');
+		assert.strictEqual(path.posix.extname('file.\\\\'), '.\\\\');
+
+		// Tests from VSCode
+		assert.equal(path.extname('far.boo'), '.boo');
+		assert.equal(path.extname('far.b'), '.b');
+		assert.equal(path.extname('far.'), '.');
+		assert.equal(path.extname('far.boo/boo.far'), '.far');
+		assert.equal(path.extname('far.boo/boo'), '');
+	});
+
+	test('resolve', () => {
+		const failures = [] as string[];
+		const slashRE = /\//g;
+		const backslashRE = /\\/g;
+
+		const resolveTests = [
+			[path.win32.resolve,
+			// arguments                               result
+			[[['c:/blah\\blah', 'd:/games', 'c:../a'], 'c:\\blah\\a'],
+			[['c:/ignore', 'd:\\a/b\\c/d', '\\e.exe'], 'd:\\e.exe'],
+			[['c:/ignore', 'c:/some/file'], 'c:\\some\\file'],
+			[['d:/ignore', 'd:some/dir//'], 'd:\\ignore\\some\\dir'],
+			[['.'], process.cwd()],
+			[['//server/share', '..', 'relative\\'], '\\\\server\\share\\relative'],
+			[['c:/', '//'], 'c:\\'],
+			[['c:/', '//dir'], 'c:\\dir'],
+			[['c:/', '//server/share'], '\\\\server\\share\\'],
+			[['c:/', '//server//share'], '\\\\server\\share\\'],
+			[['c:/', '///some//dir'], 'c:\\some\\dir'],
+			[['C:\\foo\\tmp.3\\', '..\\tmp.3\\cycles\\root.js'],
+				'C:\\foo\\tmp.3\\cycles\\root.js']
+			]
+			],
+			[path.posix.resolve,
+			// arguments                    result
+			[[['/var/lib', '../', 'file/'], '/var/file'],
+			[['/var/lib', '/../', 'file/'], '/file'],
+			[['a/b/c/', '../../..'], process.cwd()],
+			[['.'], process.cwd()],
+			[['/some/dir', '.', '/absolute/'], '/absolute'],
+			[['/foo/tmp.3/', '../tmp.3/cycles/root.js'], '/foo/tmp.3/cycles/root.js']
+			]
+			]
+		];
+		resolveTests.forEach((test) => {
+			const resolve = test[0];
+			//@ts-expect-error
+			test[1].forEach((test) => {
+				//@ts-expect-error
+				const actual = resolve.apply(null, test[0]);
+				let actualAlt;
+				const os = resolve === path.win32.resolve ? 'win32' : 'posix';
+				if (resolve === path.win32.resolve && !isWindows) {
+					actualAlt = actual.replace(backslashRE, '/');
+				}
+				else if (resolve !== path.win32.resolve && isWindows) {
+					actualAlt = actual.replace(slashRE, '\\');
+				}
+
+				const expected = test[1];
+				const message =
+					`path.${os}.resolve(${test[0].map(JSON.stringify).join(',')})\n  expect=${JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
+				if (actual !== expected && actualAlt !== expected) {
+					failures.push(`\n${message}`);
+				}
+			});
+		});
+		assert.strictEqual(failures.length, 0, failures.join(''));
+
+		// if (isWindows) {
+		// 	// Test resolving the current Windows drive letter from a spawned process.
+		// 	// See https://github.com/nodejs/node/issues/7215
+		// 	const currentDriveLetter = path.parse(process.cwd()).root.substring(0, 2);
+		// 	const resolveFixture = fixtures.path('path-resolve.js');
+		// 	const spawnResult = child.spawnSync(
+		// 		process.argv[0], [resolveFixture, currentDriveLetter]);
+		// 	const resolvedPath = spawnResult.stdout.toString().trim();
+		// 	assert.strictEqual(resolvedPath.toLowerCase(), process.cwd().toLowerCase());
+		// }
+	});
+
+	test('basename', () => {
+		assert.strictEqual(path.basename(__filename), 'path.test.js');
+		assert.strictEqual(path.basename(__filename, '.js'), 'path.test');
+		assert.strictEqual(path.basename('.js', '.js'), '');
+		assert.strictEqual(path.basename(''), '');
+		assert.strictEqual(path.basename('/dir/basename.ext'), 'basename.ext');
+		assert.strictEqual(path.basename('/basename.ext'), 'basename.ext');
+		assert.strictEqual(path.basename('basename.ext'), 'basename.ext');
+		assert.strictEqual(path.basename('basename.ext/'), 'basename.ext');
+		assert.strictEqual(path.basename('basename.ext//'), 'basename.ext');
+		assert.strictEqual(path.basename('aaa/bbb', '/bbb'), 'bbb');
+		assert.strictEqual(path.basename('aaa/bbb', 'a/bbb'), 'bbb');
+		assert.strictEqual(path.basename('aaa/bbb', 'bbb'), 'bbb');
+		assert.strictEqual(path.basename('aaa/bbb//', 'bbb'), 'bbb');
+		assert.strictEqual(path.basename('aaa/bbb', 'bb'), 'b');
+		assert.strictEqual(path.basename('aaa/bbb', 'b'), 'bb');
+		assert.strictEqual(path.basename('/aaa/bbb', '/bbb'), 'bbb');
+		assert.strictEqual(path.basename('/aaa/bbb', 'a/bbb'), 'bbb');
+		assert.strictEqual(path.basename('/aaa/bbb', 'bbb'), 'bbb');
+		assert.strictEqual(path.basename('/aaa/bbb//', 'bbb'), 'bbb');
+		assert.strictEqual(path.basename('/aaa/bbb', 'bb'), 'b');
+		assert.strictEqual(path.basename('/aaa/bbb', 'b'), 'bb');
+		assert.strictEqual(path.basename('/aaa/bbb'), 'bbb');
+		assert.strictEqual(path.basename('/aaa/'), 'aaa');
+		assert.strictEqual(path.basename('/aaa/b'), 'b');
+		assert.strictEqual(path.basename('/a/b'), 'b');
+		assert.strictEqual(path.basename('//a'), 'a');
+		assert.strictEqual(path.basename('a', 'a'), '');
+
+		// On Windows a backslash acts as a path separator.
+		assert.strictEqual(path.win32.basename('\\dir\\basename.ext'), 'basename.ext');
+		assert.strictEqual(path.win32.basename('\\basename.ext'), 'basename.ext');
+		assert.strictEqual(path.win32.basename('basename.ext'), 'basename.ext');
+		assert.strictEqual(path.win32.basename('basename.ext\\'), 'basename.ext');
+		assert.strictEqual(path.win32.basename('basename.ext\\\\'), 'basename.ext');
+		assert.strictEqual(path.win32.basename('foo'), 'foo');
+		assert.strictEqual(path.win32.basename('aaa\\bbb', '\\bbb'), 'bbb');
+		assert.strictEqual(path.win32.basename('aaa\\bbb', 'a\\bbb'), 'bbb');
+		assert.strictEqual(path.win32.basename('aaa\\bbb', 'bbb'), 'bbb');
+		assert.strictEqual(path.win32.basename('aaa\\bbb\\\\\\\\', 'bbb'), 'bbb');
+		assert.strictEqual(path.win32.basename('aaa\\bbb', 'bb'), 'b');
+		assert.strictEqual(path.win32.basename('aaa\\bbb', 'b'), 'bb');
+		assert.strictEqual(path.win32.basename('C:'), '');
+		assert.strictEqual(path.win32.basename('C:.'), '.');
+		assert.strictEqual(path.win32.basename('C:\\'), '');
+		assert.strictEqual(path.win32.basename('C:\\dir\\base.ext'), 'base.ext');
+		assert.strictEqual(path.win32.basename('C:\\basename.ext'), 'basename.ext');
+		assert.strictEqual(path.win32.basename('C:basename.ext'), 'basename.ext');
+		assert.strictEqual(path.win32.basename('C:basename.ext\\'), 'basename.ext');
+		assert.strictEqual(path.win32.basename('C:basename.ext\\\\'), 'basename.ext');
+		assert.strictEqual(path.win32.basename('C:foo'), 'foo');
+		assert.strictEqual(path.win32.basename('file:stream'), 'file:stream');
+		assert.strictEqual(path.win32.basename('a', 'a'), '');
+
+		// On unix a backslash is just treated as any other character.
+		assert.strictEqual(path.posix.basename('\\dir\\basename.ext'),
+			'\\dir\\basename.ext');
+		assert.strictEqual(path.posix.basename('\\basename.ext'), '\\basename.ext');
+		assert.strictEqual(path.posix.basename('basename.ext'), 'basename.ext');
+		assert.strictEqual(path.posix.basename('basename.ext\\'), 'basename.ext\\');
+		assert.strictEqual(path.posix.basename('basename.ext\\\\'), 'basename.ext\\\\');
+		assert.strictEqual(path.posix.basename('foo'), 'foo');
+
+		// POSIX filenames may include control characters
+		// c.f. http://www.dwheeler.com/essays/fixing-unix-linux-filenames.html
+		const controlCharFilename = `Icon${String.fromCharCode(13)}`;
+		assert.strictEqual(path.posix.basename(`/a/b/${controlCharFilename}`),
+			controlCharFilename);
+
+		// Tests from VSCode
+		assert.equal(path.basename('foo/bar'), 'bar');
+		assert.equal(path.posix.basename('foo\\bar'), 'foo\\bar');
+		assert.equal(path.win32.basename('foo\\bar'), 'bar');
+		assert.equal(path.basename('/foo/bar'), 'bar');
+		assert.equal(path.posix.basename('\\foo\\bar'), '\\foo\\bar');
+		assert.equal(path.win32.basename('\\foo\\bar'), 'bar');
+		assert.equal(path.basename('./bar'), 'bar');
+		assert.equal(path.posix.basename('.\\bar'), '.\\bar');
+		assert.equal(path.win32.basename('.\\bar'), 'bar');
+		assert.equal(path.basename('/bar'), 'bar');
+		assert.equal(path.posix.basename('\\bar'), '\\bar');
+		assert.equal(path.win32.basename('\\bar'), 'bar');
+		assert.equal(path.basename('bar/'), 'bar');
+		assert.equal(path.posix.basename('bar\\'), 'bar\\');
+		assert.equal(path.win32.basename('bar\\'), 'bar');
+		assert.equal(path.basename('bar'), 'bar');
+		assert.equal(path.basename('////////'), '');
+		assert.equal(path.posix.basename('\\\\\\\\'), '\\\\\\\\');
+		assert.equal(path.win32.basename('\\\\\\\\'), '');
+	});
+
+	test('relative', () => {
+		const failures = [] as string[];
+
+		const relativeTests = [
+			[path.win32.relative,
+			// arguments                     result
+			[['c:/blah\\blah', 'd:/games', 'd:\\games'],
+			['c:/aaaa/bbbb', 'c:/aaaa', '..'],
+			['c:/aaaa/bbbb', 'c:/cccc', '..\\..\\cccc'],
+			['c:/aaaa/bbbb', 'c:/aaaa/bbbb', ''],
+			['c:/aaaa/bbbb', 'c:/aaaa/cccc', '..\\cccc'],
+			['c:/aaaa/', 'c:/aaaa/cccc', 'cccc'],
+			['c:/', 'c:\\aaaa\\bbbb', 'aaaa\\bbbb'],
+			['c:/aaaa/bbbb', 'd:\\', 'd:\\'],
+			['c:/AaAa/bbbb', 'c:/aaaa/bbbb', ''],
+			['c:/aaaaa/', 'c:/aaaa/cccc', '..\\aaaa\\cccc'],
+			['C:\\foo\\bar\\baz\\quux', 'C:\\', '..\\..\\..\\..'],
+			['C:\\foo\\test', 'C:\\foo\\test\\bar\\package.json', 'bar\\package.json'],
+			['C:\\foo\\bar\\baz-quux', 'C:\\foo\\bar\\baz', '..\\baz'],
+			['C:\\foo\\bar\\baz', 'C:\\foo\\bar\\baz-quux', '..\\baz-quux'],
+			['\\\\foo\\bar', '\\\\foo\\bar\\baz', 'baz'],
+			['\\\\foo\\bar\\baz', '\\\\foo\\bar', '..'],
+			['\\\\foo\\bar\\baz-quux', '\\\\foo\\bar\\baz', '..\\baz'],
+			['\\\\foo\\bar\\baz', '\\\\foo\\bar\\baz-quux', '..\\baz-quux'],
+			['C:\\baz-quux', 'C:\\baz', '..\\baz'],
+			['C:\\baz', 'C:\\baz-quux', '..\\baz-quux'],
+			['\\\\foo\\baz-quux', '\\\\foo\\baz', '..\\baz'],
+			['\\\\foo\\baz', '\\\\foo\\baz-quux', '..\\baz-quux'],
+			['C:\\baz', '\\\\foo\\bar\\baz', '\\\\foo\\bar\\baz'],
+			['\\\\foo\\bar\\baz', 'C:\\baz', 'C:\\baz']
+			]
+			],
+			[path.posix.relative,
+			// arguments          result
+			[['/var/lib', '/var', '..'],
+			['/var/lib', '/bin', '../../bin'],
+			['/var/lib', '/var/lib', ''],
+			['/var/lib', '/var/apache', '../apache'],
+			['/var/', '/var/lib', 'lib'],
+			['/', '/var/lib', 'var/lib'],
+			['/foo/test', '/foo/test/bar/package.json', 'bar/package.json'],
+			['/Users/a/web/b/test/mails', '/Users/a/web/b', '../..'],
+			['/foo/bar/baz-quux', '/foo/bar/baz', '../baz'],
+			['/foo/bar/baz', '/foo/bar/baz-quux', '../baz-quux'],
+			['/baz-quux', '/baz', '../baz'],
+			['/baz', '/baz-quux', '../baz-quux']
+			]
+			]
+		];
+		relativeTests.forEach((test) => {
+			const relative = test[0];
+			//@ts-expect-error
+			test[1].forEach((test) => {
+				//@ts-expect-error
+				const actual = relative(test[0], test[1]);
+				const expected = test[2];
+				const os = relative === path.win32.relative ? 'win32' : 'posix';
+				const message = `path.${os}.relative(${test.slice(0, 2).map(JSON.stringify).join(',')})\n  expect=${JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
+				if (actual !== expected) {
+					failures.push(`\n${message}`);
+				}
+			});
+		});
+		assert.strictEqual(failures.length, 0, failures.join(''));
+	});
+
+	test('normalize', () => {
+		assert.strictEqual(path.win32.normalize('./fixtures///b/../b/c.js'),
+			'fixtures\\b\\c.js');
+		assert.strictEqual(path.win32.normalize('/foo/../../../bar'), '\\bar');
+		assert.strictEqual(path.win32.normalize('a//b//../b'), 'a\\b');
+		assert.strictEqual(path.win32.normalize('a//b//./c'), 'a\\b\\c');
+		assert.strictEqual(path.win32.normalize('a//b//.'), 'a\\b');
+		assert.strictEqual(path.win32.normalize('//server/share/dir/file.ext'),
+			'\\\\server\\share\\dir\\file.ext');
+		assert.strictEqual(path.win32.normalize('/a/b/c/../../../x/y/z'), '\\x\\y\\z');
+		assert.strictEqual(path.win32.normalize('C:'), 'C:.');
+		assert.strictEqual(path.win32.normalize('C:..\\abc'), 'C:..\\abc');
+		assert.strictEqual(path.win32.normalize('C:..\\..\\abc\\..\\def'),
+			'C:..\\..\\def');
+		assert.strictEqual(path.win32.normalize('C:\\.'), 'C:\\');
+		assert.strictEqual(path.win32.normalize('file:stream'), 'file:stream');
+		assert.strictEqual(path.win32.normalize('bar\\foo..\\..\\'), 'bar\\');
+		assert.strictEqual(path.win32.normalize('bar\\foo..\\..'), 'bar');
+		assert.strictEqual(path.win32.normalize('bar\\foo..\\..\\baz'), 'bar\\baz');
+		assert.strictEqual(path.win32.normalize('bar\\foo..\\'), 'bar\\foo..\\');
+		assert.strictEqual(path.win32.normalize('bar\\foo..'), 'bar\\foo..');
+		assert.strictEqual(path.win32.normalize('..\\foo..\\..\\..\\bar'),
+			'..\\..\\bar');
+		assert.strictEqual(path.win32.normalize('..\\...\\..\\.\\...\\..\\..\\bar'),
+			'..\\..\\bar');
+		assert.strictEqual(path.win32.normalize('../../../foo/../../../bar'),
+			'..\\..\\..\\..\\..\\bar');
+		assert.strictEqual(path.win32.normalize('../../../foo/../../../bar/../../'),
+			'..\\..\\..\\..\\..\\..\\');
+		assert.strictEqual(
+			path.win32.normalize('../foobar/barfoo/foo/../../../bar/../../'),
+			'..\\..\\'
+		);
+		assert.strictEqual(
+			path.win32.normalize('../.../../foobar/../../../bar/../../baz'),
+			'..\\..\\..\\..\\baz'
+		);
+		assert.strictEqual(path.win32.normalize('foo/bar\\baz'), 'foo\\bar\\baz');
+
+		assert.strictEqual(path.posix.normalize('./fixtures///b/../b/c.js'),
+			'fixtures/b/c.js');
+		assert.strictEqual(path.posix.normalize('/foo/../../../bar'), '/bar');
+		assert.strictEqual(path.posix.normalize('a//b//../b'), 'a/b');
+		assert.strictEqual(path.posix.normalize('a//b//./c'), 'a/b/c');
+		assert.strictEqual(path.posix.normalize('a//b//.'), 'a/b');
+		assert.strictEqual(path.posix.normalize('/a/b/c/../../../x/y/z'), '/x/y/z');
+		assert.strictEqual(path.posix.normalize('///..//./foo/.//bar'), '/foo/bar');
+		assert.strictEqual(path.posix.normalize('bar/foo../../'), 'bar/');
+		assert.strictEqual(path.posix.normalize('bar/foo../..'), 'bar');
+		assert.strictEqual(path.posix.normalize('bar/foo../../baz'), 'bar/baz');
+		assert.strictEqual(path.posix.normalize('bar/foo../'), 'bar/foo../');
+		assert.strictEqual(path.posix.normalize('bar/foo..'), 'bar/foo..');
+		assert.strictEqual(path.posix.normalize('../foo../../../bar'), '../../bar');
+		assert.strictEqual(path.posix.normalize('../.../.././.../../../bar'),
+			'../../bar');
+		assert.strictEqual(path.posix.normalize('../../../foo/../../../bar'),
+			'../../../../../bar');
+		assert.strictEqual(path.posix.normalize('../../../foo/../../../bar/../../'),
+			'../../../../../../');
+		assert.strictEqual(
+			path.posix.normalize('../foobar/barfoo/foo/../../../bar/../../'),
+			'../../'
+		);
+		assert.strictEqual(
+			path.posix.normalize('../.../../foobar/../../../bar/../../baz'),
+			'../../../../baz'
+		);
+		assert.strictEqual(path.posix.normalize('foo/bar\\baz'), 'foo/bar\\baz');
+	});
+
+	test('isAbsolute', () => {
+		assert.strictEqual(path.win32.isAbsolute('/'), true);
+		assert.strictEqual(path.win32.isAbsolute('//'), true);
+		assert.strictEqual(path.win32.isAbsolute('//server'), true);
+		assert.strictEqual(path.win32.isAbsolute('//server/file'), true);
+		assert.strictEqual(path.win32.isAbsolute('\\\\server\\file'), true);
+		assert.strictEqual(path.win32.isAbsolute('\\\\server'), true);
+		assert.strictEqual(path.win32.isAbsolute('\\\\'), true);
+		assert.strictEqual(path.win32.isAbsolute('c'), false);
+		assert.strictEqual(path.win32.isAbsolute('c:'), false);
+		assert.strictEqual(path.win32.isAbsolute('c:\\'), true);
+		assert.strictEqual(path.win32.isAbsolute('c:/'), true);
+		assert.strictEqual(path.win32.isAbsolute('c://'), true);
+		assert.strictEqual(path.win32.isAbsolute('C:/Users/'), true);
+		assert.strictEqual(path.win32.isAbsolute('C:\\Users\\'), true);
+		assert.strictEqual(path.win32.isAbsolute('C:cwd/another'), false);
+		assert.strictEqual(path.win32.isAbsolute('C:cwd\\another'), false);
+		assert.strictEqual(path.win32.isAbsolute('directory/directory'), false);
+		assert.strictEqual(path.win32.isAbsolute('directory\\directory'), false);
+
+		assert.strictEqual(path.posix.isAbsolute('/home/foo'), true);
+		assert.strictEqual(path.posix.isAbsolute('/home/foo/..'), true);
+		assert.strictEqual(path.posix.isAbsolute('bar/'), false);
+		assert.strictEqual(path.posix.isAbsolute('./baz'), false);
+
+		// Tests from VSCode:
+
+		// Absolute Paths
+		[
+			'C:/',
+			'C:\\',
+			'C:/foo',
+			'C:\\foo',
+			'z:/foo/bar.txt',
+			'z:\\foo\\bar.txt',
+
+			'\\\\localhost\\c$\\foo',
+
+			'/',
+			'/foo'
+		].forEach(absolutePath => {
+			assert.ok(path.win32.isAbsolute(absolutePath), absolutePath);
+		});
+
+		[
+			'/',
+			'/foo',
+			'/foo/bar.txt'
+		].forEach(absolutePath => {
+			assert.ok(path.posix.isAbsolute(absolutePath), absolutePath);
+		});
+
+		// Relative Paths
+		[
+			'',
+			'foo',
+			'foo/bar',
+			'./foo',
+			'http://foo.com/bar'
+		].forEach(nonAbsolutePath => {
+			assert.ok(!path.win32.isAbsolute(nonAbsolutePath), nonAbsolutePath);
+		});
+
+		[
+			'',
+			'foo',
+			'foo/bar',
+			'./foo',
+			'http://foo.com/bar',
+			'z:/foo/bar.txt',
+		].forEach(nonAbsolutePath => {
+			assert.ok(!path.posix.isAbsolute(nonAbsolutePath), nonAbsolutePath);
+		});
+	});
+
+	test('path', () => {
+		// path.sep tests
+		// windows
+		assert.strictEqual(path.win32.sep, '\\');
+		// posix
+		assert.strictEqual(path.posix.sep, '/');
+
+		// path.delimiter tests
+		// windows
+		assert.strictEqual(path.win32.delimiter, ';');
+		// posix
+		assert.strictEqual(path.posix.delimiter, ':');
+
+		// if (isWindows) {
+		// 	assert.strictEqual(path, path.win32);
+		// } else {
+		// 	assert.strictEqual(path, path.posix);
+		// }
+	});
+
+	// test('perf', () => {
+	// 	const folderNames = [
+	// 		'abc',
+	// 		'Users',
+	// 		'reallylongfoldername',
+	// 		's',
+	// 		'reallyreallyreallylongfoldername',
+	// 		'home'
+	// 	];
+
+	// 	const basePaths = [
+	// 		'C:',
+	// 		'',
+	// 	];
+
+	// 	const separators = [
+	// 		'\\',
+	// 		'/'
+	// 	];
+
+	// 	function randomInt(ciel: number): number {
+	// 		return Math.floor(Math.random() * ciel);
+	// 	}
+
+	// 	let pathsToNormalize = [];
+	// 	let pathsToJoin = [];
+	// 	let i;
+	// 	for (i = 0; i < 1000000; i++) {
+	// 		const basePath = basePaths[randomInt(basePaths.length)];
+	// 		let lengthOfPath = randomInt(10) + 2;
+
+	// 		let pathToNormalize = basePath + separators[randomInt(separators.length)];
+	// 		while (lengthOfPath-- > 0) {
+	// 			pathToNormalize = pathToNormalize + folderNames[randomInt(folderNames.length)] + separators[randomInt(separators.length)];
+	// 		}
+
+	// 		pathsToNormalize.push(pathToNormalize);
+
+	// 		let pathToJoin = '';
+	// 		lengthOfPath = randomInt(10) + 2;
+	// 		while (lengthOfPath-- > 0) {
+	// 			pathToJoin = pathToJoin + folderNames[randomInt(folderNames.length)] + separators[randomInt(separators.length)];
+	// 		}
+
+	// 		pathsToJoin.push(pathToJoin + '.ts');
+	// 	}
+
+	// 	let newTime = 0;
+
+	// 	let j;
+	// 	for(j = 0; j < pathsToJoin.length; j++) {
+	// 		const path1 = pathsToNormalize[j];
+	// 		const path2 = pathsToNormalize[j];
+
+	// 		const newStart = performance.now();
+	// 		path.join(path1, path2);
+	// 		newTime += performance.now() - newStart;
+	// 	}
+
+	// 	assert.ok(false, `Time: ${newTime}ms.`);
+	// });
+});

lib/vscode/src/vs/base/test/node/pfs/fixtures/examples/company.jxs

@@ -0,0 +1,23 @@
+'use strict';
+/// <reference path="employee.ts" />
+var Workforce;
+(function (Workforce_1) {
+    var Company = (function () {
+        function Company() {
+        }
+        return Company;
+    })();
+    (function (property, Workforce, IEmployee) {
+        if (property === undefined) { property = employees; }
+        if (IEmployee === undefined) { IEmployee = []; }
+        property;
+        calculateMonthlyExpenses();
+        {
+            var result = 0;
+            for (var i = 0; i < employees.length; i++) {
+                result += employees[i].calculatePay();
+            }
+            return result;
+        }
+    });
+})(Workforce || (Workforce = {}));

lib/vscode/src/vs/base/test/node/pfs/fixtures/examples/conway.jxs

@@ -0,0 +1,117 @@
+'use strict';
+var Conway;
+(function (Conway) {
+    var Cell = (function () {
+        function Cell() {
+        }
+        return Cell;
+    })();
+    (function (property, number, property, number, property, boolean) {
+        if (property === undefined) { property = row; }
+        if (property === undefined) { property = col; }
+        if (property === undefined) { property = live; }
+    });
+    var GameOfLife = (function () {
+        function GameOfLife() {
+        }
+        return GameOfLife;
+    })();
+    (function () {
+        property;
+        gridSize = 50;
+        property;
+        canvasSize = 600;
+        property;
+        lineColor = '#cdcdcd';
+        property;
+        liveColor = '#666';
+        property;
+        deadColor = '#eee';
+        property;
+        initialLifeProbability = 0.5;
+        property;
+        animationRate = 60;
+        property;
+        cellSize = 0;
+        property;
+        context: ICanvasRenderingContext2D;
+        property;
+        world = createWorld();
+        circleOfLife();
+        function createWorld() {
+            return travelWorld(function (cell) {
+                cell.live = Math.random() < initialLifeProbability;
+                return cell;
+            });
+        }
+        function circleOfLife() {
+            world = travelWorld(function (cell) {
+                cell = world[cell.row][cell.col];
+                draw(cell);
+                return resolveNextGeneration(cell);
+            });
+            setTimeout(function () { circleOfLife(); }, animationRate);
+        }
+        function resolveNextGeneration(cell) {
+            var count = countNeighbors(cell);
+            var newCell = new Cell(cell.row, cell.col, cell.live);
+            if (count < 2 || count > 3)
+                newCell.live = false;
+            else if (count == 3)
+                newCell.live = true;
+            return newCell;
+        }
+        function countNeighbors(cell) {
+            var neighbors = 0;
+            for (var row = -1; row <= 1; row++) {
+                for (var col = -1; col <= 1; col++) {
+                    if (row == 0 && col == 0)
+                        continue;
+                    if (isAlive(cell.row + row, cell.col + col)) {
+                        neighbors++;
+                    }
+                }
+            }
+            return neighbors;
+        }
+        function isAlive(row, col) {
+            // todo - need to guard with world[row] exists?
+            if (row < 0 || col < 0 || row >= gridSize || col >= gridSize)
+                return false;
+            return world[row][col].live;
+        }
+        function travelWorld(callback) {
+            var result = [];
+            for (var row = 0; row < gridSize; row++) {
+                var rowData = [];
+                for (var col = 0; col < gridSize; col++) {
+                    rowData.push(callback(new Cell(row, col, false)));
+                }
+                result.push(rowData);
+            }
+            return result;
+        }
+        function draw(cell) {
+            if (context == null)
+                context = createDrawingContext();
+            if (cellSize == 0)
+                cellSize = canvasSize / gridSize;
+            context.strokeStyle = lineColor;
+            context.strokeRect(cell.row * cellSize, cell.col * cellSize, cellSize, cellSize);
+            context.fillStyle = cell.live ? liveColor : deadColor;
+            context.fillRect(cell.row * cellSize, cell.col * cellSize, cellSize, cellSize);
+        }
+        function createDrawingContext() {
+            var canvas = document.getElementById('conway-canvas');
+            if (canvas == null) {
+                canvas = document.createElement('canvas');
+                canvas.id = "conway-canvas";
+                canvas.width = canvasSize;
+                canvas.height = canvasSize;
+                document.body.appendChild(canvas);
+            }
+            return canvas.getContext('2d');
+        }
+    });
+})(Conway || (Conway = {}));
+var game = new Conway.GameOfLife();

lib/vscode/src/vs/base/test/node/pfs/fixtures/examples/employee.jxs

@@ -0,0 +1,38 @@
+'use strict';
+var Workforce;
+(function (Workforce) {
+    var Employee = (function () {
+        function Employee() {
+        }
+        return Employee;
+    })();
+    (property);
+    name: string, property;
+    basepay: number;
+    implements;
+    IEmployee;
+    {
+        name;
+        basepay;
+    }
+    var SalesEmployee = (function () {
+        function SalesEmployee() {
+        }
+        return SalesEmployee;
+    })();
+    ();
+    Employee(name, basepay);
+    {
+        function calculatePay() {
+            var multiplier = (document.getElementById("mult")), as = any, value;
+            return _super.calculatePay.call(this) * multiplier + bonus;
+        }
+    }
+    var employee = new Employee('Bob', 1000);
+    var salesEmployee = new SalesEmployee('Jim', 800, 400);
+    salesEmployee.calclatePay(); // error: No member 'calclatePay' on SalesEmployee
+})(Workforce || (Workforce = {}));
+extern;
+var $;
+var s = Workforce.salesEmployee.calculatePay();
+$('#results').text(s);

lib/vscode/src/vs/base/test/node/pfs/fixtures/examples/small.jxs

@@ -0,0 +1,24 @@
+'use strict';
+var M;
+(function (M) {
+    var C = (function () {
+        function C() {
+        }
+        return C;
+    })();
+    (function (x, property, number) {
+        if (property === undefined) { property = w; }
+        var local = 1;
+        // unresolved symbol because x is local
+        //self.x++;
+        self.w--; // ok because w is a property
+        property;
+        f = function (y) {
+            return y + x + local + w + self.w;
+        };
+        function sum(z) {
+            return z + f(z) + w + self.w;
+        }
+    });
+})(M || (M = {}));
+var c = new M.C(12, 5);

lib/vscode/src/vs/base/test/node/pfs/fixtures/index.html

@@ -0,0 +1,121 @@
+<!DOCTYPE html>
+<html>
+<head id='headID'>
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <title>Strada </title>
+    <link href="site.css" rel="stylesheet" type="text/css" />
+    <script src="jquery-1.4.1.js"></script>
+    <script src="../compiler/dtree.js" type="text/javascript"></script>
+    <script src="../compiler/typescript.js" type="text/javascript"></script>
+    <script type="text/javascript">
+
+    // Compile strada source into resulting javascript
+    function compile(prog, libText) {
+        var outfile = {
+          source: "",
+          Write: function (s) { this.source += s; },
+          WriteLine: function (s) { this.source += s + "\r"; },
+        }
+
+        var parseErrors = []
+
+        var compiler=new Tools.TypeScriptCompiler(outfile,true);
+        compiler.setErrorCallback(function(start,len, message) { parseErrors.push({start:start, len:len, message:message}); });
+        compiler.addUnit(libText,"lib.ts");
+        compiler.addUnit(prog,"input.ts");
+        compiler.typeCheck();
+        compiler.emit();
+
+        if(parseErrors.length > 0 ) {
+          //throw new Error(parseErrors);
+        }
+
+	while(outfile.source[0] == '/' && outfile.source[1] == '/' && outfile.source[2] == ' ') {
+            outfile.source = outfile.source.slice(outfile.source.indexOf('\r')+1);
+        }
+        var errorPrefix = "";
+	for(var i = 0;i<parseErrors.length;i++) {
+          errorPrefix += "// Error: (" + parseErrors[i].start + "," + parseErrors[i].len + ") " + parseErrors[i].message + "\r";
+        }
+
+        return errorPrefix + outfile.source;
+    }
+    </script>
+    <script type="text/javascript">
+	
+        var libText = "";
+        $.get("../compiler/lib.ts", function(newLibText) {
+            libText = newLibText;
+        });	
+        
+
+        // execute the javascript in the compiledOutput pane
+        function execute() {
+          $('#compilation').text("Running...");
+          var txt = $('#compiledOutput').val();
+          var res;
+          try {
+             var ret = eval(txt);
+             res = "Ran successfully!";
+          } catch(e) { 
+             res = "Exception thrown: " + e;
+          }
+          $('#compilation').text(String(res));
+        }
+
+        // recompile the stradaSrc and populate the compiledOutput pane
+        function srcUpdated() {
+            var newText = $('#stradaSrc').val();
+            var compiledSource;
+            try {
+                compiledSource = compile(newText, libText);
+            } catch (e) {
+                compiledSource = "//Parse error"
+                for(var i in e) 
+                  compiledSource += "\r// " + e[i];
+            }
+            $('#compiledOutput').val(compiledSource);
+        }
+
+        // Populate the stradaSrc pane with one of the built in samples
+        function exampleSelectionChanged() {
+            var examples = document.getElementById('examples');
+            var selectedExample = examples.options[examples.selectedIndex].value;
+            if (selectedExample != "") {
+                $.get('examples/' + selectedExample, function (srcText) {
+                    $('#stradaSrc').val(srcText);
+                    setTimeout(srcUpdated,100);
+                }, function (err) {
+                    console.log(err);
+                });
+            }
+        }
+
+    </script>
+</head>
+<body>
+    <h1>TypeScript</h1>
+    <br />
+    <select id="examples" onchange='exampleSelectionChanged()'>
+        <option value="">Select...</option>
+        <option value="small.ts">Small</option>
+        <option value="employee.ts">Employees</option>
+        <option value="conway.ts">Conway Game of Life</option>
+        <option value="typescript.ts">TypeScript Compiler</option>
+    </select>
+
+    <div>
+        <textarea id='stradaSrc' rows='40' cols='80' onchange='srcUpdated()' onkeyup='srcUpdated()' spellcheck="false">
+//Type your TypeScript here...
+      </textarea>
+      <textarea id='compiledOutput' rows='40' cols='80' spellcheck="false">
+//Compiled code will show up here...
+      </textarea>
+      <br />
+      <button onclick='execute()'/>Run</button> 
+      <div id='compilation'>Press 'run' to execute code...</div>
+      <div id='results'>...write your results into #results...</div>
+    </div>
+    <div id='bod' style='display:none'></div>
+</body>
+</html>

lib/vscode/src/vs/base/test/node/pfs/fixtures/site.css

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------
+The base color for this template is #5c87b2. If you'd like
+to use a different color start by replacing all instances of
+#5c87b2 with your new color.
+----------------------------------------------------------*/
+body
+{
+    background-color: #5c87b2;
+    font-size: .75em;
+    font-family: Segoe UI, Verdana, Helvetica, Sans-Serif;
+    margin: 8px;
+    padding: 0;
+    color: #696969;
+}
+
+h1, h2, h3, h4, h5, h6
+{
+    color: #000;
+    font-size: 40px;
+    margin: 0px;
+}
+
+textarea 
+{
+   font-family: Consolas
+}
+
+#results 
+{
+    margin-top: 2em;
+    margin-left: 2em;
+    color: black;
+    font-size: medium;
+}
+

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

@@ -0,0 +1,480 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import * as os from 'os';
+import * as path from 'vs/base/common/path';
+import * as fs from 'fs';
+import * as uuid from 'vs/base/common/uuid';
+import * as pfs from 'vs/base/node/pfs';
+import { timeout } from 'vs/base/common/async';
+import { getPathFromAmdModule } from 'vs/base/common/amd';
+import { isWindows } from 'vs/base/common/platform';
+import { canNormalize } from 'vs/base/common/normalization';
+import { VSBuffer } from 'vs/base/common/buffer';
+
+suite('PFS', function () {
+
+	// Given issues such as https://github.com/microsoft/vscode/issues/84066
+	// we see random test failures when accessing the native file system. To
+	// diagnose further, we retry node.js file access tests up to 3 times to
+	// rule out any random disk issue.
+	this.retries(3);
+
+	test('writeFile', async () => {
+		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');
+
+		await pfs.mkdirp(newDir, 493);
+		assert.ok(fs.existsSync(newDir));
+
+		await pfs.writeFile(testFile, 'Hello World', (null!));
+		assert.equal(fs.readFileSync(testFile), 'Hello World');
+
+		await pfs.rimraf(parentDir, pfs.RimRafMode.MOVE);
+	});
+
+	test('writeFile - parallel write on different files works', async () => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'pfs', id);
+		const testFile1 = path.join(newDir, 'writefile1.txt');
+		const testFile2 = path.join(newDir, 'writefile2.txt');
+		const testFile3 = path.join(newDir, 'writefile3.txt');
+		const testFile4 = path.join(newDir, 'writefile4.txt');
+		const testFile5 = path.join(newDir, 'writefile5.txt');
+
+		await pfs.mkdirp(newDir, 493);
+		assert.ok(fs.existsSync(newDir));
+
+		await Promise.all([
+			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!))
+		]);
+		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');
+
+		await pfs.rimraf(parentDir, pfs.RimRafMode.MOVE);
+	});
+
+	test('writeFile - parallel write on same files works and is sequentalized', async () => {
+		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');
+
+		await pfs.mkdirp(newDir, 493);
+		assert.ok(fs.existsSync(newDir));
+
+		await Promise.all([
+			pfs.writeFile(testFile, 'Hello World 1', undefined),
+			pfs.writeFile(testFile, 'Hello World 2', undefined),
+			timeout(10).then(() => pfs.writeFile(testFile, 'Hello World 3', undefined)),
+			pfs.writeFile(testFile, 'Hello World 4', undefined),
+			timeout(10).then(() => pfs.writeFile(testFile, 'Hello World 5', undefined))
+		]);
+		assert.equal(fs.readFileSync(testFile), 'Hello World 5');
+
+		await pfs.rimraf(parentDir, pfs.RimRafMode.MOVE);
+	});
+
+	test('rimraf - simple - unlink', async () => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'pfs', id);
+
+		await pfs.mkdirp(newDir, 493);
+		fs.writeFileSync(path.join(newDir, 'somefile.txt'), 'Contents');
+		fs.writeFileSync(path.join(newDir, 'someOtherFile.txt'), 'Contents');
+
+		await pfs.rimraf(newDir);
+		assert.ok(!fs.existsSync(newDir));
+	});
+
+	test('rimraf - simple - move', async () => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'pfs', id);
+
+		await pfs.mkdirp(newDir, 493);
+		fs.writeFileSync(path.join(newDir, 'somefile.txt'), 'Contents');
+		fs.writeFileSync(path.join(newDir, 'someOtherFile.txt'), 'Contents');
+
+		await pfs.rimraf(newDir, pfs.RimRafMode.MOVE);
+		assert.ok(!fs.existsSync(newDir));
+	});
+
+	test('rimraf - recursive folder structure - unlink', async () => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'pfs', id);
+
+		await pfs.mkdirp(newDir, 493);
+		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');
+
+		await pfs.rimraf(newDir);
+		assert.ok(!fs.existsSync(newDir));
+	});
+
+	test('rimraf - recursive folder structure - move', async () => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'pfs', id);
+
+		await pfs.mkdirp(newDir, 493);
+		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');
+
+		await pfs.rimraf(newDir, pfs.RimRafMode.MOVE);
+		assert.ok(!fs.existsSync(newDir));
+	});
+
+	test('rimraf - simple ends with dot - move', async () => {
+		const id = `${uuid.generateUuid()}.`;
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'pfs', id);
+
+		await pfs.mkdirp(newDir, 493);
+		fs.writeFileSync(path.join(newDir, 'somefile.txt'), 'Contents');
+		fs.writeFileSync(path.join(newDir, 'someOtherFile.txt'), 'Contents');
+
+		await pfs.rimraf(newDir, pfs.RimRafMode.MOVE);
+		assert.ok(!fs.existsSync(newDir));
+	});
+
+	test('rimraf - simple ends with dot slash/backslash - move', async () => {
+		const id = `${uuid.generateUuid()}.`;
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'pfs', id);
+
+		await pfs.mkdirp(newDir, 493);
+		fs.writeFileSync(path.join(newDir, 'somefile.txt'), 'Contents');
+		fs.writeFileSync(path.join(newDir, 'someOtherFile.txt'), 'Contents');
+
+		await pfs.rimraf(`${newDir}${path.sep}`, pfs.RimRafMode.MOVE);
+		assert.ok(!fs.existsSync(newDir));
+	});
+
+	test('rimrafSync - swallows file not found error', function () {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'pfs', id);
+
+		pfs.rimrafSync(newDir);
+
+		assert.ok(!fs.existsSync(newDir));
+	});
+
+	test('rimrafSync - simple', async () => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'pfs', id);
+
+		await pfs.mkdirp(newDir, 493);
+
+		fs.writeFileSync(path.join(newDir, 'somefile.txt'), 'Contents');
+		fs.writeFileSync(path.join(newDir, 'someOtherFile.txt'), 'Contents');
+
+		pfs.rimrafSync(newDir);
+
+		assert.ok(!fs.existsSync(newDir));
+	});
+
+	test('rimrafSync - recursive folder structure', async () => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'pfs', id);
+
+		await pfs.mkdirp(newDir, 493);
+		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.rimrafSync(newDir);
+
+		assert.ok(!fs.existsSync(newDir));
+	});
+
+	test('moveIgnoreError', async () => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'pfs', id);
+
+		await pfs.mkdirp(newDir, 493);
+		try {
+			await pfs.renameIgnoreError(path.join(newDir, 'foo'), path.join(newDir, 'bar'));
+			return pfs.rimraf(parentDir, pfs.RimRafMode.MOVE);
+		}
+		catch (error) {
+			assert.fail(error);
+		}
+	});
+
+	test('copy, move and delete', async () => {
+		const id = uuid.generateUuid();
+		const id2 = uuid.generateUuid();
+		const sourceDir = getPathFromAmdModule(require, './fixtures');
+		const parentDir = path.join(os.tmpdir(), 'vsctests', 'pfs');
+		const targetDir = path.join(parentDir, id);
+		const targetDir2 = path.join(parentDir, id2);
+
+		await pfs.copy(sourceDir, targetDir);
+
+		assert.ok(fs.existsSync(targetDir));
+		assert.ok(fs.existsSync(path.join(targetDir, 'index.html')));
+		assert.ok(fs.existsSync(path.join(targetDir, 'site.css')));
+		assert.ok(fs.existsSync(path.join(targetDir, 'examples')));
+		assert.ok(fs.statSync(path.join(targetDir, 'examples')).isDirectory());
+		assert.ok(fs.existsSync(path.join(targetDir, 'examples', 'small.jxs')));
+
+		await pfs.move(targetDir, targetDir2);
+
+		assert.ok(!fs.existsSync(targetDir));
+		assert.ok(fs.existsSync(targetDir2));
+		assert.ok(fs.existsSync(path.join(targetDir2, 'index.html')));
+		assert.ok(fs.existsSync(path.join(targetDir2, 'site.css')));
+		assert.ok(fs.existsSync(path.join(targetDir2, 'examples')));
+		assert.ok(fs.statSync(path.join(targetDir2, 'examples')).isDirectory());
+		assert.ok(fs.existsSync(path.join(targetDir2, 'examples', 'small.jxs')));
+
+		await pfs.move(path.join(targetDir2, 'index.html'), path.join(targetDir2, 'index_moved.html'));
+
+		assert.ok(!fs.existsSync(path.join(targetDir2, 'index.html')));
+		assert.ok(fs.existsSync(path.join(targetDir2, 'index_moved.html')));
+
+		await pfs.rimraf(parentDir, pfs.RimRafMode.MOVE);
+
+		assert.ok(!fs.existsSync(parentDir));
+	});
+
+	test('mkdirp', async () => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'pfs', id);
+
+		await pfs.mkdirp(newDir, 493);
+
+		assert.ok(fs.existsSync(newDir));
+
+		return pfs.rimraf(parentDir, pfs.RimRafMode.MOVE);
+	});
+
+	test('readDirsInDir', async () => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'pfs', id);
+
+		await pfs.mkdirp(newDir, 493);
+
+		fs.mkdirSync(path.join(newDir, 'somefolder1'));
+		fs.mkdirSync(path.join(newDir, 'somefolder2'));
+		fs.mkdirSync(path.join(newDir, 'somefolder3'));
+		fs.writeFileSync(path.join(newDir, 'somefile.txt'), 'Contents');
+		fs.writeFileSync(path.join(newDir, 'someOtherFile.txt'), 'Contents');
+
+		const result = await pfs.readDirsInDir(newDir);
+		assert.equal(result.length, 3);
+		assert.ok(result.indexOf('somefolder1') !== -1);
+		assert.ok(result.indexOf('somefolder2') !== -1);
+		assert.ok(result.indexOf('somefolder3') !== -1);
+
+		await pfs.rimraf(newDir);
+	});
+
+	test('stat link', async () => {
+		if (isWindows) {
+			return; // Symlinks are not the same on win, and we can not create them programitically without admin privileges
+		}
+
+		const id1 = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id1);
+		const directory = path.join(parentDir, 'pfs', id1);
+
+		const id2 = uuid.generateUuid();
+		const symbolicLink = path.join(parentDir, 'pfs', id2);
+
+		await pfs.mkdirp(directory, 493);
+
+		fs.symlinkSync(directory, symbolicLink);
+
+		let statAndIsLink = await pfs.statLink(directory);
+		assert.ok(!statAndIsLink?.symbolicLink);
+
+		statAndIsLink = await pfs.statLink(symbolicLink);
+		assert.ok(statAndIsLink?.symbolicLink);
+		assert.ok(!statAndIsLink?.symbolicLink?.dangling);
+
+		pfs.rimrafSync(directory);
+	});
+
+	test('stat link (non existing target)', async () => {
+		if (isWindows) {
+			return; // Symlinks are not the same on win, and we can not create them programitically without admin privileges
+		}
+
+		const id1 = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id1);
+		const directory = path.join(parentDir, 'pfs', id1);
+
+		const id2 = uuid.generateUuid();
+		const symbolicLink = path.join(parentDir, 'pfs', id2);
+
+		await pfs.mkdirp(directory, 493);
+
+		fs.symlinkSync(directory, symbolicLink);
+
+		pfs.rimrafSync(directory);
+
+		const statAndIsLink = await pfs.statLink(symbolicLink);
+		assert.ok(statAndIsLink?.symbolicLink);
+		assert.ok(statAndIsLink?.symbolicLink?.dangling);
+	});
+
+	test('readdir', async () => {
+		if (canNormalize && typeof process.versions['electron'] !== 'undefined' /* needs electron */) {
+			const id = uuid.generateUuid();
+			const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+			const newDir = path.join(parentDir, 'pfs', id, 'öäü');
+
+			await pfs.mkdirp(newDir, 493);
+
+			assert.ok(fs.existsSync(newDir));
+
+			const children = await pfs.readdir(path.join(parentDir, 'pfs', id));
+			assert.equal(children.some(n => n === 'öäü'), true); // Mac always converts to NFD, so
+
+			await pfs.rimraf(parentDir);
+		}
+	});
+
+	test('readdirWithFileTypes', async () => {
+		if (canNormalize && typeof process.versions['electron'] !== 'undefined' /* needs electron */) {
+			const id = uuid.generateUuid();
+			const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+			const testDir = path.join(parentDir, 'pfs', id);
+
+			const newDir = path.join(testDir, 'öäü');
+			await pfs.mkdirp(newDir, 493);
+
+			await pfs.writeFile(path.join(testDir, 'somefile.txt'), 'contents');
+
+			assert.ok(fs.existsSync(newDir));
+
+			const children = await pfs.readdirWithFileTypes(testDir);
+
+			assert.equal(children.some(n => n.name === 'öäü'), true); // Mac always converts to NFD, so
+			assert.equal(children.some(n => n.isDirectory()), true);
+
+			assert.equal(children.some(n => n.name === 'somefile.txt'), true);
+			assert.equal(children.some(n => n.isFile()), true);
+
+			await pfs.rimraf(parentDir);
+		}
+	});
+
+	test('writeFile (string)', async () => {
+		const smallData = 'Hello World';
+		const bigData = (new Array(100 * 1024)).join('Large String\n');
+
+		return testWriteFileAndFlush(smallData, smallData, bigData, bigData);
+	});
+
+	test('writeFile (Buffer)', async () => {
+		const smallData = 'Hello World';
+		const bigData = (new Array(100 * 1024)).join('Large String\n');
+
+		return testWriteFileAndFlush(Buffer.from(smallData), smallData, Buffer.from(bigData), bigData);
+	});
+
+	test('writeFile (UInt8Array)', async () => {
+		const smallData = 'Hello World';
+		const bigData = (new Array(100 * 1024)).join('Large String\n');
+
+		return testWriteFileAndFlush(VSBuffer.fromString(smallData).buffer, smallData, VSBuffer.fromString(bigData).buffer, bigData);
+	});
+
+	async function testWriteFileAndFlush(
+		smallData: string | Buffer | Uint8Array,
+		smallDataValue: string,
+		bigData: string | Buffer | Uint8Array,
+		bigDataValue: string
+	): Promise<void> {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'pfs', id);
+		const testFile = path.join(newDir, 'flushed.txt');
+
+		await pfs.mkdirp(newDir, 493);
+		assert.ok(fs.existsSync(newDir));
+
+		await pfs.writeFile(testFile, smallData);
+		assert.equal(fs.readFileSync(testFile), smallDataValue);
+
+		await pfs.writeFile(testFile, bigData);
+		assert.equal(fs.readFileSync(testFile), bigDataValue);
+
+		await pfs.rimraf(parentDir);
+	}
+
+	test('writeFile (string, error handling)', async () => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'pfs', id);
+		const testFile = path.join(newDir, 'flushed.txt');
+
+		await pfs.mkdirp(newDir, 493);
+
+		assert.ok(fs.existsSync(newDir));
+
+		fs.mkdirSync(testFile); // this will trigger an error because testFile is now a directory!
+
+		let expectedError: Error | undefined;
+		try {
+			await pfs.writeFile(testFile, 'Hello World');
+		} catch (error) {
+			expectedError = error;
+		}
+
+		assert.ok(expectedError);
+
+		await pfs.rimraf(parentDir);
+	});
+
+	test('writeFileSync', async () => {
+		const id = uuid.generateUuid();
+		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
+		const newDir = path.join(parentDir, 'pfs', id);
+		const testFile = path.join(newDir, 'flushed.txt');
+
+		await pfs.mkdirp(newDir, 493);
+
+		assert.ok(fs.existsSync(newDir));
+
+		pfs.writeFileSync(testFile, 'Hello World');
+		assert.equal(fs.readFileSync(testFile), 'Hello World');
+
+		const largeString = (new Array(100 * 1024)).join('Large String\n');
+
+		pfs.writeFileSync(testFile, largeString);
+		assert.equal(fs.readFileSync(testFile), largeString);
+
+		await pfs.rimraf(parentDir);
+	});
+});

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

@@ -0,0 +1,36 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import * as net from 'net';
+import * as ports from 'vs/base/node/ports';
+
+suite('Ports', () => {
+	test('Finds a free port (no timeout)', function (done) {
+		this.timeout(1000 * 10); // higher timeout for this test
+
+		if (process.env['VSCODE_PID']) {
+			return done(); // this test fails when run from within VS Code
+		}
+
+		// get an initial freeport >= 7000
+		ports.findFreePort(7000, 100, 300000).then(initialPort => {
+			assert.ok(initialPort >= 7000);
+
+			// create a server to block this port
+			const server = net.createServer();
+			server.listen(initialPort, undefined, undefined, () => {
+
+				// once listening, find another free port and assert that the port is different from the opened one
+				ports.findFreePort(7000, 50, 300000).then(freePort => {
+					assert.ok(freePort >= 7000 && freePort !== initialPort);
+					server.close();
+
+					done();
+				}, err => done(err));
+			});
+		}, err => done(err));
+	});
+});

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

@@ -0,0 +1,14 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as processes from 'vs/base/node/processes';
+
+const sender = processes.createQueuedSender(<any>process);
+
+process.on('message', msg => {
+	sender.send(msg);
+});
+
+sender.send('ready');

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

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as processes from 'vs/base/node/processes';
+
+const sender = processes.createQueuedSender(<any>process);
+
+process.on('message', msg => {
+	sender.send(msg);
+	sender.send(msg);
+	sender.send(msg);
+	sender.send('done');
+});
+
+sender.send('ready');

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

@@ -0,0 +1,87 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import * as cp from 'child_process';
+import * as objects from 'vs/base/common/objects';
+import * as platform from 'vs/base/common/platform';
+import * as processes from 'vs/base/node/processes';
+import { getPathFromAmdModule } from 'vs/base/common/amd';
+
+function fork(id: string): cp.ChildProcess {
+	const opts: any = {
+		env: objects.mixin(objects.deepClone(process.env), {
+			AMD_ENTRYPOINT: id,
+			PIPE_LOGGING: 'true',
+			VERBOSE_LOGGING: true
+		})
+	};
+
+	return cp.fork(getPathFromAmdModule(require, 'bootstrap-fork'), ['--type=processTests'], opts);
+}
+
+suite('Processes', () => {
+	test('buffered sending - simple data', function (done: () => void) {
+		if (process.env['VSCODE_PID']) {
+			return done(); // this test fails when run from within VS Code
+		}
+
+		const child = fork('vs/base/test/node/processes/fixtures/fork');
+		const sender = processes.createQueuedSender(child);
+
+		let counter = 0;
+
+		const msg1 = 'Hello One';
+		const msg2 = 'Hello Two';
+		const msg3 = 'Hello Three';
+
+		child.on('message', msgFromChild => {
+			if (msgFromChild === 'ready') {
+				sender.send(msg1);
+				sender.send(msg2);
+				sender.send(msg3);
+			} else {
+				counter++;
+
+				if (counter === 1) {
+					assert.equal(msgFromChild, msg1);
+				} else if (counter === 2) {
+					assert.equal(msgFromChild, msg2);
+				} else if (counter === 3) {
+					assert.equal(msgFromChild, msg3);
+
+					child.kill();
+					done();
+				}
+			}
+		});
+	});
+
+	test('buffered sending - lots of data (potential deadlock on win32)', function (done: () => void) {
+		if (!platform.isWindows || process.env['VSCODE_PID']) {
+			return done(); // test is only relevant for Windows and seems to crash randomly on some Linux builds
+		}
+
+		const child = fork('vs/base/test/node/processes/fixtures/fork_large');
+		const sender = processes.createQueuedSender(child);
+
+		const largeObj = Object.create(null);
+		for (let i = 0; i < 10000; i++) {
+			largeObj[i] = 'some data';
+		}
+
+		const msg = JSON.stringify(largeObj);
+		child.on('message', msgFromChild => {
+			if (msgFromChild === 'ready') {
+				sender.send(msg);
+				sender.send(msg);
+				sender.send(msg);
+			} else if (msgFromChild === 'done') {
+				child.kill();
+				done();
+			}
+		});
+	});
+});

lib/vscode/src/vs/base/test/node/testUtils.ts

@@ -0,0 +1,11 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { join } from 'vs/base/common/path';
+import { generateUuid } from 'vs/base/common/uuid';
+
+export function getRandomTestPath(tmpdir: string, ...segments: string[]): string {
+	return join(tmpdir, ...segments, generateUuid());
+}

lib/vscode/src/vs/base/test/node/uri.test.perf.ts

@@ -0,0 +1,61 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { URI } from 'vs/base/common/uri';
+import { readFileSync } from 'fs';
+import { getPathFromAmdModule } from 'vs/base/common/amd';
+
+suite('URI - perf', function () {
+
+	let manyFileUris: URI[];
+	setup(function () {
+		manyFileUris = [];
+		let data = readFileSync(getPathFromAmdModule(require, './uri.test.data.txt')).toString();
+		let lines = data.split('\n');
+		for (let line of lines) {
+			manyFileUris.push(URI.file(line));
+		}
+	});
+
+	function perfTest(name: string, callback: Function) {
+		test(name, _done => {
+			let t1 = Date.now();
+			callback();
+			let d = Date.now() - t1;
+			console.log(`${name} took ${d}ms (${(d / manyFileUris.length).toPrecision(3)} ms/uri)`);
+			_done();
+		});
+	}
+
+	perfTest('toString', function () {
+		for (const uri of manyFileUris) {
+			let data = uri.toString();
+			assert.ok(data);
+		}
+	});
+
+	perfTest('toString(skipEncoding)', function () {
+		for (const uri of manyFileUris) {
+			let data = uri.toString(true);
+			assert.ok(data);
+		}
+	});
+
+	perfTest('fsPath', function () {
+		for (const uri of manyFileUris) {
+			let data = uri.fsPath;
+			assert.ok(data);
+		}
+	});
+
+	perfTest('toJSON', function () {
+		for (const uri of manyFileUris) {
+			let data = uri.toJSON();
+			assert.ok(data);
+		}
+	});
+
+});

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

@@ -0,0 +1,28 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import * as path from 'vs/base/common/path';
+import * as os from 'os';
+import { extract } from 'vs/base/node/zip';
+import { generateUuid } from 'vs/base/common/uuid';
+import { rimraf, exists } from 'vs/base/node/pfs';
+import { getPathFromAmdModule } from 'vs/base/common/amd';
+import { createCancelablePromise } from 'vs/base/common/async';
+
+const fixtures = getPathFromAmdModule(require, './fixtures');
+
+suite('Zip', () => {
+
+	test('extract should handle directories', () => {
+		const fixture = path.join(fixtures, 'extract.zip');
+		const target = path.join(os.tmpdir(), generateUuid());
+
+		return createCancelablePromise(token => extract(fixture, target, {}, token)
+			.then(() => exists(path.join(target, 'extension')))
+			.then(exists => assert(exists))
+			.then(() => rimraf(target)));
+	});
+});