Merge from vscode 2c306f762bf9c3db82dc06c7afaa56ef46d72f79 (#14050)

* Merge from vscode 2c306f762bf9c3db82dc06c7afaa56ef46d72f79

* Fix breaks

* Extension management fixes

* Fix breaks in windows bundling

* Fix/skip failing tests

* Update distro

* Add clear to nuget.config

* Add hygiene task

* Bump distro

* Fix hygiene issue

* Add build to hygiene exclusion

* Update distro

* Update hygiene

* Hygiene exclusions

* Update tsconfig

* Bump distro for server breaks

* Update build config

* Update darwin path

* Add done calls to notebook tests

* Skip failing tests

* Disable smoke tests

src/vs/platform/environment/test/node/argv.test.ts

@@ -0,0 +1,68 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { formatOptions, Option } from 'vs/platform/environment/node/argv';
+import { addArg } from 'vs/platform/environment/node/argvHelper';
+
+suite('formatOptions', () => {
+
+	function o(description: string): Option<any> {
+		return {
+			description, type: 'string'
+		};
+	}
+
+	test('Text should display small columns correctly', () => {
+		assert.deepEqual(
+			formatOptions({
+				'add': o('bar')
+			}, 80),
+			['  --add bar']
+		);
+		assert.deepEqual(
+			formatOptions({
+				'add': o('bar'),
+				'wait': o('ba'),
+				'trace': o('b')
+			}, 80),
+			[
+				'  --add   bar',
+				'  --wait  ba',
+				'  --trace b'
+			]);
+	});
+
+	test('Text should wrap', () => {
+		assert.deepEqual(
+			formatOptions({
+				'add': o((<any>'bar ').repeat(9))
+			}, 40),
+			[
+				'  --add bar bar bar bar bar bar bar bar',
+				'        bar'
+			]);
+	});
+
+	test('Text should revert to the condensed view when the terminal is too narrow', () => {
+		assert.deepEqual(
+			formatOptions({
+				'add': o((<any>'bar ').repeat(9))
+			}, 30),
+			[
+				'  --add',
+				'      bar bar bar bar bar bar bar bar bar '
+			]);
+	});
+
+	test('addArg', () => {
+		assert.deepEqual(addArg([], 'foo'), ['foo']);
+		assert.deepEqual(addArg([], 'foo', 'bar'), ['foo', 'bar']);
+		assert.deepEqual(addArg(['foo'], 'bar'), ['foo', 'bar']);
+		assert.deepEqual(addArg(['--wait'], 'bar'), ['--wait', 'bar']);
+		assert.deepEqual(addArg(['--wait', '--', '--foo'], 'bar'), ['--wait', 'bar', '--', '--foo']);
+		assert.deepEqual(addArg(['--', '--foo'], 'bar'), ['bar', '--', '--foo']);
+	});
+});

src/vs/platform/environment/test/node/nativeModules.test.ts

@@ -0,0 +1,105 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { isMacintosh, isWindows } from 'vs/base/common/platform';
+
+function testErrorMessage(module: string): string {
+	return `Unable to load "${module}" dependency. It was probably not compiled for the right operating system architecture or had missing build tools.`;
+}
+
+suite('Native Modules (all platforms)', () => {
+
+	test('native-is-elevated', async () => {
+		const isElevated = await import('native-is-elevated');
+		assert.ok(typeof isElevated === 'function', testErrorMessage('native-is-elevated '));
+	});
+
+	test('native-keymap', async () => {
+		const keyMap = await import('native-keymap');
+		assert.ok(typeof keyMap.getCurrentKeyboardLayout === 'function', testErrorMessage('native-keymap'));
+	});
+
+	test('native-watchdog', async () => {
+		const watchDog = await import('native-watchdog');
+		assert.ok(typeof watchDog.start === 'function', testErrorMessage('native-watchdog'));
+	});
+
+	test('node-pty', async () => {
+		const nodePty = await import('node-pty');
+		assert.ok(typeof nodePty.spawn === 'function', testErrorMessage('node-pty'));
+	});
+
+	test('spdlog', async () => {
+		const spdlog = await import('spdlog');
+		assert.ok(typeof spdlog.createRotatingLogger === 'function', testErrorMessage('spdlog'));
+	});
+
+	test('v8-inspect-profiler', async () => {
+		const profiler = await import('v8-inspect-profiler');
+		assert.ok(typeof profiler.startProfiling === 'function', testErrorMessage('v8-inspect-profiler'));
+	});
+
+	test('vscode-nsfw', async () => {
+		const nsfWatcher = await import('vscode-nsfw');
+		assert.ok(typeof nsfWatcher === 'function', testErrorMessage('vscode-nsfw'));
+	});
+
+	test('vscode-sqlite3', async () => {
+		const sqlite3 = await import('vscode-sqlite3');
+		assert.ok(typeof sqlite3.Database === 'function', testErrorMessage('vscode-sqlite3'));
+	});
+});
+
+(!isMacintosh ? suite.skip : suite)('Native Modules (macOS)', () => {
+
+	test('chokidar (fsevents)', async () => {
+		const chokidar = await import('chokidar');
+		const watcher = chokidar.watch(__dirname);
+		assert.ok(watcher.options.useFsEvents, testErrorMessage('chokidar (fsevents)'));
+
+		return watcher.close();
+	});
+});
+
+(!isWindows ? suite.skip : suite)('Native Modules (Windows)', () => {
+
+	test('windows-mutex', async () => {
+		const mutex = await import('windows-mutex');
+		assert.ok(mutex && typeof mutex.isActive === 'function', testErrorMessage('windows-mutex'));
+		assert.ok(typeof mutex.isActive === 'function', testErrorMessage('windows-mutex'));
+	});
+
+	test('windows-foreground-love', async () => {
+		const foregroundLove = await import('windows-foreground-love');
+		assert.ok(typeof foregroundLove.allowSetForegroundWindow === 'function', testErrorMessage('windows-foreground-love'));
+	});
+
+	test('windows-process-tree', async () => {
+		const processTree = await import('windows-process-tree');
+		assert.ok(typeof processTree.getProcessTree === 'function', testErrorMessage('windows-process-tree'));
+	});
+
+	test('vscode-windows-registry', async () => {
+		const windowsRegistry = await import('vscode-windows-registry');
+		assert.ok(typeof windowsRegistry.GetStringRegKey === 'function', testErrorMessage('vscode-windows-registry'));
+	});
+
+	test('vscode-windows-ca-certs', async () => {
+		// @ts-ignore Windows only
+		const windowsCerts = await import('vscode-windows-ca-certs');
+		const store = windowsCerts();
+		assert.ok(windowsCerts, testErrorMessage('vscode-windows-ca-certs'));
+		let certCount = 0;
+		try {
+			while (store.next()) {
+				certCount++;
+			}
+		} finally {
+			store.done();
+		}
+		assert(certCount > 0);
+	});
+});