From 74172d0df08a805031d2a4cb834b45a62f38cf0e Mon Sep 17 00:00:00 2001
From: Rich Chiodo <rchiodo@users.noreply.github.com>
Date: Tue, 1 Oct 2019 09:30:24 -0700
Subject: [PATCH 01/36] Expand variable explorer tests to work for native
 editor too. (#7699)

* Expand variable explorer tests to work for native editor too.

* Add comment about async fix for editor open

* Review feedback
---
 news/3 Code Health/7369.md | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 news/3 Code Health/7369.md

diff --git a/news/3 Code Health/7369.md b/news/3 Code Health/7369.md
new file mode 100644
index 000000000000..58e65e615c03
--- /dev/null
+++ b/news/3 Code Health/7369.md	
@@ -0,0 +1 @@
+Add functional tests for notebook editor's use of the variable list.

From e8347e7ea9e33ef755e888dbc68041d7bbb69bc2 Mon Sep 17 00:00:00 2001
From: Ian Huff <ianhu@microsoft.com>
Date: Tue, 1 Oct 2019 15:19:28 -0700
Subject: [PATCH 02/36] Allow connection to servers with no token and no
 password (#7708)

---
 news/2 Fixes/7137.md | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 news/2 Fixes/7137.md

diff --git a/news/2 Fixes/7137.md b/news/2 Fixes/7137.md
new file mode 100644
index 000000000000..952440c7f342
--- /dev/null
+++ b/news/2 Fixes/7137.md	
@@ -0,0 +1 @@
+Fix regression to allow connection to servers with no token and no password and add functional test for this scenario
\ No newline at end of file

From 456167b5e76e5e25592dbdb3862fa5718c380365 Mon Sep 17 00:00:00 2001
From: Rich Chiodo <rchiodo@users.noreply.github.com>
Date: Wed, 2 Oct 2019 12:32:08 -0700
Subject: [PATCH 03/36] Add capability to support current file path for
 notebook root (#7724)

* Add capability to support current file path for notebook root

* Put launch.json back

* Use system variables instead of creating separate resolver

* Fix mistake in config settings with passing in a uri instead of a string

* Make arguments more explicit

* Fix IS_WINDOWS to work on unit tests
---
 news/1 Enhancements/4441.md | 1 +
 news/2 Fixes/7688.md        | 1 +
 2 files changed, 2 insertions(+)
 create mode 100644 news/1 Enhancements/4441.md
 create mode 100644 news/2 Fixes/7688.md

diff --git a/news/1 Enhancements/4441.md b/news/1 Enhancements/4441.md
new file mode 100644
index 000000000000..b3671783354c
--- /dev/null
+++ b/news/1 Enhancements/4441.md	
@@ -0,0 +1 @@
+Support other variables for notebookFileRoot besides ${workspaceRoot}. Specifically allow things like ${fileDirName} so that the dir of the first file run in the interactive window is used for the current directory.
diff --git a/news/2 Fixes/7688.md b/news/2 Fixes/7688.md
new file mode 100644
index 000000000000..9c7cea856132
--- /dev/null
+++ b/news/2 Fixes/7688.md	
@@ -0,0 +1 @@
+When there's no workspace open, use the directory of the opened file as the root directory for a jupyter session.

From b4b4d2d87bd1a77fa8fb886d7948722b280ed3a1 Mon Sep 17 00:00:00 2001
From: Don Jayamanne <don.jayamanne@yahoo.com>
Date: Wed, 2 Oct 2019 15:09:54 -0700
Subject: [PATCH 04/36] Better cancellations (#7714)

---
 src/client/common/cancellation.ts             | 43 +++++++++++++++----
 .../jupyter/jupyterCommandFinder.ts           | 39 +++++++++++++++--
 2 files changed, 69 insertions(+), 13 deletions(-)

diff --git a/src/client/common/cancellation.ts b/src/client/common/cancellation.ts
index b325c2ff106a..fc30619df3fc 100644
--- a/src/client/common/cancellation.ts
+++ b/src/client/common/cancellation.ts
@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 'use strict';
-import { CancellationToken } from 'vscode-jsonrpc';
+import { CancellationToken } from 'vscode';
 
 import { createDeferred } from './utils/async';
 import * as localize from './utils/localize';
@@ -10,20 +10,46 @@ import * as localize from './utils/localize';
  * Error type thrown when canceling.
  */
 export class CancellationError extends Error {
-
     constructor() {
         super(localize.Common.canceled());
     }
 }
+/**
+ * Create a promise that will either resolve with a default value or reject when the token is cancelled.
+ *
+ * @export
+ * @template T
+ * @param {({ defaultValue: T; token: CancellationToken; cancelAction: 'reject' | 'resolve' })} options
+ * @returns {Promise<T>}
+ */
+export function createPromiseFromCancellation<T>(options: { defaultValue: T; token?: CancellationToken; cancelAction: 'reject' | 'resolve' }): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+        // Never resolve.
+        if (!options.token) {
+            return;
+        }
+        const complete = () => {
+            if (options.token!.isCancellationRequested) {
+                if (options.cancelAction === 'resolve') {
+                    return resolve(options.defaultValue);
+                }
+                if (options.cancelAction === 'reject') {
+                    return reject(new CancellationError());
+                }
+            }
+        };
 
-export namespace Cancellation {
+        options.token.onCancellationRequested(complete);
+    });
+}
 
+export namespace Cancellation {
     /**
      * Races a promise and cancellation. Promise can take a cancellation token too in order to listen to cancellation.
      * @param work function returning a promise to race
      * @param token token used for cancellation
      */
-    export function race<T>(work : (token?: CancellationToken) => Promise<T>, token?: CancellationToken) : Promise<T> {
+    export function race<T>(work: (token?: CancellationToken) => Promise<T>, token?: CancellationToken): Promise<T> {
         if (token) {
             // Use a deferred promise. Resolves when the work finishes
             const deferred = createDeferred<T>();
@@ -43,12 +69,12 @@ export namespace Cancellation {
                 // Not canceled yet. When the work finishes
                 // either resolve our promise or cancel.
                 work(token)
-                    .then((v) => {
+                    .then(v => {
                         if (!deferred.completed) {
                             deferred.resolve(v);
                         }
                     })
-                    .catch((e) => {
+                    .catch(e => {
                         if (!deferred.completed) {
                             deferred.reject(e);
                         }
@@ -66,7 +92,7 @@ export namespace Cancellation {
      * isCanceled returns a boolean indicating if the cancel token has been canceled.
      * @param cancelToken
      */
-    export function isCanceled(cancelToken?: CancellationToken) : boolean {
+    export function isCanceled(cancelToken?: CancellationToken): boolean {
         return cancelToken ? cancelToken.isCancellationRequested : false;
     }
 
@@ -74,10 +100,9 @@ export namespace Cancellation {
      * throws a CancellationError if the token is canceled.
      * @param cancelToken
      */
-    export function throwIfCanceled(cancelToken?: CancellationToken) : void {
+    export function throwIfCanceled(cancelToken?: CancellationToken): void {
         if (isCanceled(cancelToken)) {
             throw new CancellationError();
         }
     }
-
 }
diff --git a/src/client/datascience/jupyter/jupyterCommandFinder.ts b/src/client/datascience/jupyter/jupyterCommandFinder.ts
index 7ae172b21d4c..28175ef4616f 100644
--- a/src/client/datascience/jupyter/jupyterCommandFinder.ts
+++ b/src/client/datascience/jupyter/jupyterCommandFinder.ts
@@ -6,7 +6,7 @@
 import * as path from 'path';
 import { CancellationToken } from 'vscode';
 import { IWorkspaceService } from '../../common/application/types';
-import { Cancellation } from '../../common/cancellation';
+import { Cancellation, createPromiseFromCancellation } from '../../common/cancellation';
 import { traceInfo, traceWarning } from '../../common/logger';
 import { IFileSystem } from '../../common/platform/types';
 import { IProcessService, IProcessServiceFactory, IPythonExecutionFactory, SpawnOptions } from '../../common/process/types';
@@ -33,6 +33,18 @@ export interface IFindCommandResult extends IModuleExistsResult {
     command?: IJupyterCommand;
 }
 
+const cancelledResult: IFindCommandResult = {
+    status: ModuleExistsStatus.NotFound,
+    error: localize.DataScience.noInterpreter()
+};
+
+function isCommandFinderCancelled(command: JupyterCommands, token?: CancellationToken) {
+    if (Cancellation.isCanceled(token)) {
+        traceInfo(`Command finder cancelled for ${command}.`);
+        return true;
+    }
+    return false;
+}
 export class JupyterCommandFinder {
     private readonly processServicePromise: Promise<IProcessService>;
     private jupyterPath?: string;
@@ -152,7 +164,7 @@ export class JupyterCommandFinder {
     // - Look for module in current interpreter, if found create something with python path and -m module
     // - Look in other interpreters, if found create something with python path and -m module
     // - Look on path for jupyter, if found create something with jupyter path and args
-    // tslint:disable:cyclomatic-complexity
+    // tslint:disable:cyclomatic-complexity max-func-body-length
     private async findBestCommandImpl(command: JupyterCommands, cancelToken?: CancellationToken): Promise<IFindCommandResult> {
         let found: IFindCommandResult = {
             status: ModuleExistsStatus.NotFound
@@ -165,6 +177,11 @@ export class JupyterCommandFinder {
 
             // First we look in the current interpreter
             const current = await this.interpreterService.getActiveInterpreter();
+
+            if (isCommandFinderCancelled(command, cancelToken)) {
+                return cancelledResult;
+            }
+
             found = current ? await this.findInterpreterCommand(command, current, cancelToken) : found;
             if (found.status === ModuleExistsStatus.NotFound) {
                 traceInfo(`Active interpreter does not support ${command} because of error ${found.error}. Interpreter is ${current ? current.displayName : 'undefined'}.`);
@@ -174,14 +191,24 @@ export class JupyterCommandFinder {
             }
             if (found.status === ModuleExistsStatus.NotFound && this.supportsSearchingForCommands()) {
                 // Look through all of our interpreters (minus the active one at the same time)
-                const all = await this.interpreterService.getInterpreters();
+                const cancelGetInterpreters = createPromiseFromCancellation<PythonInterpreter[]>({ defaultValue: [], cancelAction: 'resolve', token: cancelToken });
+                const all = await Promise.race([this.interpreterService.getInterpreters(), cancelGetInterpreters]);
+
+                if (isCommandFinderCancelled(command, cancelToken)) {
+                    return cancelledResult;
+                }
 
                 if (!all || all.length === 0) {
                     traceWarning('No interpreters found. Jupyter cannot run.');
                 }
 
+                const cancelFind = createPromiseFromCancellation<IFindCommandResult[]>({ defaultValue: [], cancelAction: 'resolve', token: cancelToken });
                 const promises = all.filter(i => i !== current).map(i => this.findInterpreterCommand(command, i, cancelToken));
-                const foundList = await Promise.all(promises);
+                const foundList = await Promise.race([Promise.all(promises), cancelFind]);
+
+                if (isCommandFinderCancelled(command, cancelToken)) {
+                    return cancelledResult;
+                }
 
                 // Then go through all of the found ones and pick the closest python match
                 if (current && current.version) {
@@ -192,6 +219,10 @@ export class JupyterCommandFinder {
                             continue;
                         }
                         const interpreter = await entry.command.interpreter();
+                        if (isCommandFinderCancelled(command, cancelToken)) {
+                            return cancelledResult;
+                        }
+
                         const version = interpreter ? interpreter.version : undefined;
                         if (version) {
                             if (version.major === current.version.major) {

From 50f8461ab831e7d5dea4a40dac9720716ff33612 Mon Sep 17 00:00:00 2001
From: Rich Chiodo <rchiodo@users.noreply.github.com>
Date: Thu, 3 Oct 2019 08:16:54 -0700
Subject: [PATCH 05/36] Variable explorer and mime test fixes for tests (#7740)

* Change variable explorer tests to wait for variable explorer complete

* Fix native mime test

* Review feedback

* Try to make 2.7 tests pass
---
 .../datascience/getJupyterVariableValue.py    |  6 +--
 .../interactiveWindowTypes.ts                 |  2 +
 .../interactive-common/mainStateController.ts |  7 +++
 .../nativeEditor.functional.test.tsx          |  2 +-
 .../variableexplorer.functional.test.tsx      | 50 +++++++++----------
 5 files changed, 37 insertions(+), 30 deletions(-)

diff --git a/pythonFiles/datascience/getJupyterVariableValue.py b/pythonFiles/datascience/getJupyterVariableValue.py
index d483eb5cba89..a302cf6df673 100644
--- a/pythonFiles/datascience/getJupyterVariableValue.py
+++ b/pythonFiles/datascience/getJupyterVariableValue.py
@@ -84,9 +84,9 @@ def __call__(self, obj):
                 return ''.join((x.encode('utf-8') if isinstance(x, unicode) else x) for x in self._repr(obj, 0))
             else:
                 return ''.join(self._repr(obj, 0))
-        except Exception:
+        except Exception as e:
             try:
-                return 'An exception was raised: %r' % sys.exc_info()[1]
+                return 'An exception was raised: ' + str(e)
             except Exception:
                 return 'An exception was raised'
 
@@ -373,7 +373,7 @@ def _bytes_as_unicode_if_possible(self, obj_repr):
         # locale.getpreferredencoding() and 'utf-8). If no encoding can decode
         # the input, we return the original bytes.
         try_encodings = []
-        encoding = self.sys_stdout_encoding or getattr(sys.stdout, 'encoding', '')
+        encoding = self.sys_stdout_encoding or getattr(VC_sys.stdout, 'encoding', '')
         if encoding:
             try_encodings.append(encoding.lower())
 
diff --git a/src/client/datascience/interactive-common/interactiveWindowTypes.ts b/src/client/datascience/interactive-common/interactiveWindowTypes.ts
index 59b3be5b9fae..446563bcb4de 100644
--- a/src/client/datascience/interactive-common/interactiveWindowTypes.ts
+++ b/src/client/datascience/interactive-common/interactiveWindowTypes.ts
@@ -69,6 +69,7 @@ export namespace InteractiveWindowMessages {
     export const NotebookClean = 'clean';
     export const SaveAll = 'save_all';
     export const NativeCommand = 'native_command';
+    export const VariablesComplete = 'variables_complete';
 
 }
 
@@ -301,4 +302,5 @@ export class IInteractiveWindowMapping {
     public [InteractiveWindowMessages.NotebookClean]: never | undefined;
     public [InteractiveWindowMessages.SaveAll]: ISaveAll;
     public [InteractiveWindowMessages.NativeCommand]: INativeCommand;
+    public [InteractiveWindowMessages.VariablesComplete]: never | undefined;
 }
diff --git a/src/datascience-ui/interactive-common/mainStateController.ts b/src/datascience-ui/interactive-common/mainStateController.ts
index 361ca744b3ae..a0b7cab178f7 100644
--- a/src/datascience-ui/interactive-common/mainStateController.ts
+++ b/src/datascience-ui/interactive-common/mainStateController.ts
@@ -640,6 +640,8 @@ export class MainStateController implements IMessageHandler {
     }
 
     public renderUpdate(newState: {}) {
+        const oldCount = this.state.pendingVariableCount;
+
         // This method should be called during the render stage of anything
         // using this state Controller. That's because after shouldComponentUpdate
         // render is next and at this point the state has been set.
@@ -652,6 +654,11 @@ export class MainStateController implements IMessageHandler {
         if ('cellVMs' in newState) {
             this.sendInfo();
         }
+
+        // If the new state includes pendingVariableCount and it's gone to zero, send a message
+        if (this.state.pendingVariableCount === 0 && oldCount !== 0) {
+            setTimeout(() => this.sendMessage(InteractiveWindowMessages.VariablesComplete), 1);
+        }
     }
 
     public getState(): IMainState {
diff --git a/src/test/datascience/nativeEditor.functional.test.tsx b/src/test/datascience/nativeEditor.functional.test.tsx
index a57af32ccc32..b2eb2bb71053 100644
--- a/src/test/datascience/nativeEditor.functional.test.tsx
+++ b/src/test/datascience/nativeEditor.functional.test.tsx
@@ -127,7 +127,7 @@ for _ in range(50):
         await addCell(wrapper, matPlotLib, true, 5);
         verifyHtmlOnCell(wrapper, 'NativeCell', matPlotLibResults, CellPosition.Last);
 
-        await addCell(wrapper, spinningCursor, true, 3 + (ioc.mockJupyter ? (cursors.length * 3) : 0));
+        await addCell(wrapper, spinningCursor, true, 3 + (ioc.mockJupyter ? (cursors.length * 3) : 50));
         verifyHtmlOnCell(wrapper, 'NativeCell', '<div>', CellPosition.Last);
     }, () => { return ioc; });
 
diff --git a/src/test/datascience/variableexplorer.functional.test.tsx b/src/test/datascience/variableexplorer.functional.test.tsx
index 55c230c0f265..421a6a7effc8 100644
--- a/src/test/datascience/variableexplorer.functional.test.tsx
+++ b/src/test/datascience/variableexplorer.functional.test.tsx
@@ -8,6 +8,7 @@ import { parse } from 'node-html-parser';
 import * as React from 'react';
 import { Disposable } from 'vscode';
 
+import { InteractiveWindowMessages } from '../../client/datascience/interactive-common/interactiveWindowTypes';
 import { IJupyterVariable } from '../../client/datascience/types';
 import { InteractivePanel } from '../../datascience-ui/history-react/interactivePanel';
 import { VariableExplorer } from '../../datascience-ui/interactive-common/variableExplorer';
@@ -16,7 +17,7 @@ import { DataScienceIocContainer } from './dataScienceIocContainer';
 import { addCode } from './interactiveWindowTestHelpers';
 import { addCell, createNewEditor } from './nativeEditorTestHelpers';
 import { waitForUpdate } from './reactHelpers';
-import { runDoubleTest } from './testHelpers';
+import { runDoubleTest, waitForMessage } from './testHelpers';
 
 // tslint:disable:max-func-body-length trailing-comma no-any no-multiline-string
 suite('DataScience Interactive Window variable explorer tests', () => {
@@ -60,10 +61,17 @@ suite('DataScience Interactive Window variable explorer tests', () => {
     //      asyncDump();
     //});
 
-    async function addCodeImpartial(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, code: string, expectedRenderCount: number = 4, expectError: boolean = false): Promise<ReactWrapper<any, Readonly<{}>, React.Component>> {
+    async function waitForVariablesUpdated(): Promise<void> {
+        return waitForMessage(ioc, InteractiveWindowMessages.VariablesComplete);
+    }
+
+    async function addCodeImpartial(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, code: string, waitForVariables: boolean = true, expectedRenderCount: number = 4, expectError: boolean = false): Promise<ReactWrapper<any, Readonly<{}>, React.Component>> {
+        const variablesUpdated = waitForVariables ? waitForVariablesUpdated() : Promise.resolve();
         const nodes = wrapper.find('InteractivePanel');
         if (nodes.length > 0) {
-            return addCode(ioc, wrapper, code, expectedRenderCount, expectError);
+            const result = await addCode(ioc, wrapper, code, expectedRenderCount, expectError);
+            await variablesUpdated;
+            return result;
         } else {
             // For the native editor case, we need to create an editor before hand.
             if (!createdNotebook) {
@@ -72,6 +80,7 @@ suite('DataScience Interactive Window variable explorer tests', () => {
                 expectedRenderCount += 1;
             }
             await addCell(wrapper, code, true, expectedRenderCount);
+            await variablesUpdated;
             return wrapper;
         }
     }
@@ -85,8 +94,7 @@ value = 'hello world'`;
         openVariableExplorer(wrapper);
 
         await addCodeImpartial(wrapper, 'a=1\na');
-        await addCodeImpartial(wrapper, basicCode, 4);
-        await waitForUpdate(wrapper, VariableExplorer, 3);
+        await addCodeImpartial(wrapper, basicCode, true, 4);
 
         // We should show a string and show an int, the modules should be hidden
         let targetVariables: IJupyterVariable[] = [
@@ -100,8 +108,7 @@ value = 'hello world'`;
         ioc.getSettings().datascience.variableExplorerExclude = `${ioc.getSettings().datascience.variableExplorerExclude};str`;
 
         // Add another string and check our vars, strings should be hidden
-        await addCodeImpartial(wrapper, basicCode2, 4);
-        await waitForUpdate(wrapper, VariableExplorer, 2);
+        await addCodeImpartial(wrapper, basicCode2, true, 4);
 
         targetVariables = [
             {name: 'a', value: '1', supportsDataExplorer: false, type: 'int', size: 54, shape: '', count: 0, truncated: false}
@@ -116,7 +123,6 @@ value = 'hello world'`;
         openVariableExplorer(wrapper);
 
         await addCodeImpartial(wrapper, 'a=1\na');
-        await waitForUpdate(wrapper, VariableExplorer, 2);
 
         // Check that we have just the 'a' variable
         let targetVariables: IJupyterVariable[] = [
@@ -125,8 +131,7 @@ value = 'hello world'`;
         verifyVariables(wrapper, targetVariables);
 
         // Add another variable and check it
-        await addCodeImpartial(wrapper, basicCode, 4);
-        await waitForUpdate(wrapper, VariableExplorer, 3);
+        await addCodeImpartial(wrapper, basicCode, true, 4);
 
         targetVariables = [
             {name: 'a', value: '1', supportsDataExplorer: false, type: 'int', size: 54, shape: '', count: 0, truncated: false},
@@ -136,8 +141,7 @@ value = 'hello world'`;
         verifyVariables(wrapper, targetVariables);
 
         // Add a second variable and check it
-        await addCodeImpartial(wrapper, basicCode2, 4);
-        await waitForUpdate(wrapper, VariableExplorer, 4);
+        await addCodeImpartial(wrapper, basicCode2, true, 4);
 
         targetVariables = [
             {name: 'a', value: '1', supportsDataExplorer: false, type: 'int', size: 54, shape: '', count: 0, truncated: false},
@@ -155,7 +159,7 @@ value = 'hello world'`;
         openVariableExplorer(wrapper);
 
         await addCodeImpartial(wrapper, 'a=1\na');
-        await addCodeImpartial(wrapper, basicCode, 4);
+        await addCodeImpartial(wrapper, basicCode, false, 4);
 
         // Here we are only going to wait for two renders instead of the needed three
         // a should have the value updated, but value should still be loading
@@ -187,11 +191,7 @@ myDict = {'a': 1}`;
         openVariableExplorer(wrapper);
 
         await addCodeImpartial(wrapper, 'a=1\na');
-        await addCodeImpartial(wrapper, basicCode, 4);
-
-        // Verify that we actually update the variable explorer
-        // Count here is our main render + a render for each variable row as they come in
-        await waitForUpdate(wrapper, VariableExplorer, 5);
+        await addCodeImpartial(wrapper, basicCode, true, 4);
 
         const targetVariables: IJupyterVariable[] = [
             {name: 'a', value: '1', supportsDataExplorer: false, type: 'int', size: 54, shape: '', count: 0, truncated: false},
@@ -219,11 +219,7 @@ myTuple = 1,2,3,4,5,6,7,8,9
         openVariableExplorer(wrapper);
 
         await addCodeImpartial(wrapper, 'a=1\na');
-        await addCodeImpartial(wrapper, basicCode, 4);
-
-        // Verify that we actually update the variable explorer
-        // Count here is our main render + a render for each variable row as they come in
-        await waitForUpdate(wrapper, VariableExplorer, 9);
+        await addCodeImpartial(wrapper, basicCode, true, 4);
 
         const targetVariables: IJupyterVariable[] = [
             {name: 'a', value: '1', supportsDataExplorer: false, type: 'int', size: 54, shape: '', count: 0, truncated: false},
@@ -255,9 +251,7 @@ strc = 'c'`;
         openVariableExplorer(wrapper);
 
         await addCodeImpartial(wrapper, 'a=1\na');
-        await addCodeImpartial(wrapper, basicCode, 4);
-
-        await waitForUpdate(wrapper, VariableExplorer, 7);
+        await addCodeImpartial(wrapper, basicCode, true, 4);
 
         let targetVariables: IJupyterVariable[] = [
             {name: 'a', value: '1', supportsDataExplorer: false, type: 'int', size: 54, shape: '', count: 0, truncated: false},
@@ -318,6 +312,10 @@ function sortVariableExplorer(wrapper: ReactWrapper<any, Readonly<{}>, React.Com
 
 // Verify a set of rows versus a set of expected variables
 function verifyVariables(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, targetVariables: IJupyterVariable[]) {
+    // Force an update so we render whatever the current state is
+    wrapper.update();
+
+    // Then search for results.
     const foundRows = wrapper.find('div.react-grid-Row');
 
     expect(foundRows.length).to.be.equal(targetVariables.length, 'Different number of variable explorer rows and target variables');

From fd547753e0aaa3d6094e23a25a502c1d7c1d4e44 Mon Sep 17 00:00:00 2001
From: Ian Huff <ianhu@microsoft.com>
Date: Thu, 3 Oct 2019 18:38:05 -0700
Subject: [PATCH 06/36] Fix liveshare guest hang issue (#7764)

* initial changes

* update notebooks on server session change and add test

* await correctly
---
 news/2 Fixes/7638.md | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 news/2 Fixes/7638.md

diff --git a/news/2 Fixes/7638.md b/news/2 Fixes/7638.md
new file mode 100644
index 000000000000..dea499b65438
--- /dev/null
+++ b/news/2 Fixes/7638.md	
@@ -0,0 +1 @@
+Fix a hang in the Interactive window when connecting guest to host after the host has already started the interactive window.
\ No newline at end of file

From 899add9d1c035e52a42a562703ca233462992f2c Mon Sep 17 00:00:00 2001
From: Rich Chiodo <rchiodo@users.noreply.github.com>
Date: Fri, 4 Oct 2019 14:54:54 -0700
Subject: [PATCH 07/36] Fix jupyter server startup hang when xeus-cling is
 installed (#7773)

---
 news/2 Fixes/7569.md                       |  1 +
 src/client/common/process/pythonProcess.ts | 21 +++++++++++++++++----
 2 files changed, 18 insertions(+), 4 deletions(-)
 create mode 100644 news/2 Fixes/7569.md

diff --git a/news/2 Fixes/7569.md b/news/2 Fixes/7569.md
new file mode 100644
index 000000000000..20e5e8a45853
--- /dev/null
+++ b/news/2 Fixes/7569.md	
@@ -0,0 +1 @@
+Fix jupyter server startup hang when xeus-cling kernel is installed.
diff --git a/src/client/common/process/pythonProcess.ts b/src/client/common/process/pythonProcess.ts
index 6030df4a6e11..9d7d15333768 100644
--- a/src/client/common/process/pythonProcess.ts
+++ b/src/client/common/process/pythonProcess.ts
@@ -1,17 +1,26 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
-
 import { injectable } from 'inversify';
 import * as path from 'path';
+
 import { IServiceContainer } from '../../ioc/types';
 import { EXTENSION_ROOT_DIR } from '../constants';
 import { ErrorUtils } from '../errors/errorUtils';
 import { ModuleNotInstalledError } from '../errors/moduleNotInstalledError';
 import { traceError } from '../logger';
 import { IFileSystem } from '../platform/types';
+import { waitForPromise } from '../utils/async';
 import { Architecture } from '../utils/platform';
 import { parsePythonVersion } from '../utils/version';
-import { ExecutionResult, InterpreterInfomation, IProcessService, IPythonExecutionService, ObservableExecutionResult, PythonVersionInfo, SpawnOptions } from './types';
+import {
+    ExecutionResult,
+    InterpreterInfomation,
+    IProcessService,
+    IPythonExecutionService,
+    ObservableExecutionResult,
+    PythonVersionInfo,
+    SpawnOptions
+} from './types';
 
 @injectable()
 export class PythonExecutionService implements IPythonExecutionService {
@@ -28,8 +37,12 @@ export class PythonExecutionService implements IPythonExecutionService {
     public async getInterpreterInformation(): Promise<InterpreterInfomation | undefined> {
         const file = path.join(EXTENSION_ROOT_DIR, 'pythonFiles', 'interpreterInfo.py');
         try {
-            const jsonValue = await this.procService.exec(this.pythonPath, [file], { mergeStdOutErr: true })
-                .then(output => output.stdout.trim());
+            // Sometimes the python path isn't valid, timeout if that's the case.
+            // See these two bugs:
+            // https://github.com/microsoft/vscode-python/issues/7569
+            // https://github.com/microsoft/vscode-python/issues/7760
+            const jsonValue = await waitForPromise(this.procService.exec(this.pythonPath, [file], { mergeStdOutErr: true }), 5000)
+                .then(output => output ? output.stdout.trim() : '--timed out--'); // --timed out-- should cause an exception
 
             let json: { versionInfo: PythonVersionInfo; sysPrefix: string; sysVersion: string; is64Bit: boolean };
             try {

From 14cd95f7cd9234b97a8f3138899bcb920cab0cc9 Mon Sep 17 00:00:00 2001
From: David Kutugata <dakutuga@microsoft.com>
Date: Fri, 4 Oct 2019 18:11:44 -0700
Subject: [PATCH 08/36] Make interactive window and native editor take their
 fontSize and fontFamily from the settings in VS Code. (#7746)

* Make interactive window and native editor take
their fontSize and fontFamily from the settings in VS Code.

We get them in nativeEditor.tsx and in interactivePanel.tsx
to apply them as styles, but we also need to send them
as props to eventually assign them in the monaco editor.

* Moved style from react code to common.css

We now get the VS Code styles from the state of the
component, instead of computing a style from an element.

* Removed getting the font from nativeEditor and
interactivePanel, and put it in the mainStateController

* Made the interactiveWindow and the nativeEditor
react and change their fonts when the user changes them
in VS Code, instead of having to reload.

* Changed the font props to be an object instead of
two separate props to make it easier to maintain.

React Context was not used to avoid making the reuse of
components more difficult.

* Removed some unnecesary passing around of the
font prop

* removed unnecesary comments

* fixed a failing test
---
 news/2 Fixes/7624.md | 1 +
 package-lock.json    | 6 +++---
 2 files changed, 4 insertions(+), 3 deletions(-)
 create mode 100644 news/2 Fixes/7624.md

diff --git a/news/2 Fixes/7624.md b/news/2 Fixes/7624.md
new file mode 100644
index 000000000000..1875f4ca313b
--- /dev/null
+++ b/news/2 Fixes/7624.md	
@@ -0,0 +1 @@
+Make interactive window and native take their fontSize and fontFamily from the settings in VS Code.
diff --git a/package-lock.json b/package-lock.json
index 6a0b36e78cdb..d42ce97da8ad 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -13770,7 +13770,7 @@
             "dependencies": {
                 "buffer": {
                     "version": "4.9.1",
-                    "resolved": "https://registry.npmjs.org/buffer/-/buffer-4.9.1.tgz",
+                    "resolved": "http://registry.npmjs.org/buffer/-/buffer-4.9.1.tgz",
                     "integrity": "sha1-bRu2AbB6TvztlwlBMgkwJ8lbwpg=",
                     "dev": true,
                     "requires": {
@@ -13793,7 +13793,7 @@
                 },
                 "readable-stream": {
                     "version": "2.3.6",
-                    "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz",
+                    "resolved": "http://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz",
                     "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==",
                     "dev": true,
                     "requires": {
@@ -18754,7 +18754,7 @@
             "dependencies": {
                 "json5": {
                     "version": "1.0.1",
-                    "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.1.tgz",
+                    "resolved": "http://registry.npmjs.org/json5/-/json5-1.0.1.tgz",
                     "integrity": "sha512-aKS4WQjPenRxiQsC93MNfjx+nbF4PAdYzmd/1JIj8HYzqfbu86beTuNgXDzPknWk0n0uARlyewZo4s++ES36Ow==",
                     "dev": true,
                     "requires": {

From 17ee45a5a4880c4e5c574fafce607914ed00ba91 Mon Sep 17 00:00:00 2001
From: Rich Chiodo <rchiodo@users.noreply.github.com>
Date: Mon, 7 Oct 2019 11:45:29 -0700
Subject: [PATCH 09/36] Fix a number of perf issues with large notebooks
 (#7778)

* First idea - load cells all at once.
Change updates to not update full cell
Change global properties to be per cell
Change cells to check for updates before rendering

* Fix delete to not select at the same time

* Make a pending state and a rendered state to use for rendering
Some perf fixes for monaco editor. Skip laying out parent
etc until necessary

* Refactor intellisense to not take so much time on load

* More delete and move fixes for intellisense

* Fix markdown not switching
Fix markdown editor background

* Fix some of the time on first render

* Add some more unit tests and fix intellisense issue

* Add news entry and fix variable explorer open

* Remove unnecessary state change

* Remove unnecessary merge

* Comment change

* Postpone widget parent changes

* Add new dependency

* Update some comments and names to be clearer
---
 news/2 Fixes/7483.md                          |   1 +
 package-lock.json                             |   4 +-
 package.datascience-ui.dependencies.json      |   1 +
 .../intellisense/baseIntellisenseProvider.ts  |  89 +++--
 .../intellisense/intellisenseDocument.ts      | 372 ++++++++++--------
 .../interactiveWindowTypes.ts                 |  15 +
 .../history-react/interactiveCell.tsx         |  17 +-
 .../history-react/interactivePanel.tsx        |   2 -
 .../interactive-common/mainState.ts           |  22 +-
 .../interactive-common/mainStateController.ts | 355 ++++++++++-------
 .../interactive-common/markdown.tsx           |   4 +
 .../native-editor/nativeCell.tsx              |  81 ++--
 .../native-editor/nativeEditor.less           |  10 +
 .../native-editor/nativeEditor.tsx            |  19 +-
 .../nativeEditorStateController.ts            |  13 +-
 .../react-common/monacoEditor.tsx             |  36 +-
 .../datascience/intellisense.unit.test.ts     | 133 ++++++-
 .../nativeEditor.functional.test.tsx          |   8 +-
 18 files changed, 741 insertions(+), 441 deletions(-)
 create mode 100644 news/2 Fixes/7483.md

diff --git a/news/2 Fixes/7483.md b/news/2 Fixes/7483.md
new file mode 100644
index 000000000000..c8b22aada88f
--- /dev/null
+++ b/news/2 Fixes/7483.md	
@@ -0,0 +1 @@
+Perf improvements for opening notebooks with more than 100 cells.
diff --git a/package-lock.json b/package-lock.json
index d42ce97da8ad..2c4fd706f33d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -14145,7 +14145,7 @@
                 },
                 "os-locale": {
                     "version": "3.1.0",
-                    "resolved": "https://registry.npmjs.org/os-locale/-/os-locale-3.1.0.tgz",
+                    "resolved": false,
                     "integrity": "sha512-Z8l3R4wYWM40/52Z+S265okfFj8Kt2cC2MKY+xNi3kFs+XGI7WXu/I309QQQYbRW4ijiZ+yxs9pqEhJh0DqW3Q==",
                     "dev": true,
                     "requires": {
@@ -14162,7 +14162,7 @@
                 },
                 "resolve-from": {
                     "version": "4.0.0",
-                    "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+                    "resolved": false,
                     "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
                     "dev": true
                 },
diff --git a/package.datascience-ui.dependencies.json b/package.datascience-ui.dependencies.json
index 41f0d9ff43e2..1916cd4904a5 100644
--- a/package.datascience-ui.dependencies.json
+++ b/package.datascience-ui.dependencies.json
@@ -85,6 +85,7 @@
     "escape-carriage",
     "extend",
     "fast-plist",
+    "immutable",
     "inherits",
     "is-alphabetical",
     "is-alphanumerical",
diff --git a/src/client/datascience/interactive-common/intellisense/baseIntellisenseProvider.ts b/src/client/datascience/interactive-common/intellisense/baseIntellisenseProvider.ts
index cd79d8b090bd..eed2dc888ff4 100644
--- a/src/client/datascience/interactive-common/intellisense/baseIntellisenseProvider.ts
+++ b/src/client/datascience/interactive-common/intellisense/baseIntellisenseProvider.ts
@@ -24,17 +24,12 @@ import { IFileSystem, TemporaryFile } from '../../../common/platform/types';
 import { createDeferred, Deferred, waitForPromise } from '../../../common/utils/async';
 import { concatMultilineString } from '../../common';
 import { Identifiers, Settings } from '../../constants';
-import {
-    IInteractiveWindowInfo,
-    IInteractiveWindowListener,
-    IInteractiveWindowProvider,
-    IJupyterExecution,
-    INotebook
-} from '../../types';
+import { IInteractiveWindowListener, IInteractiveWindowProvider, IJupyterExecution, INotebook } from '../../types';
 import {
     IAddCell,
     ICancelIntellisenseRequest,
     IEditCell,
+    IInsertCell,
     IInteractiveWindowMapping,
     ILoadAllCells,
     INotebookIdentity,
@@ -42,7 +37,8 @@ import {
     IProvideCompletionItemsRequest,
     IProvideHoverRequest,
     IProvideSignatureHelpRequest,
-    IRemoveCell
+    IRemoveCell,
+    ISwapCells
 } from '../interactiveWindowTypes';
 import { convertStringsToSuggestions } from './conversion';
 import { IntellisenseDocument } from './intellisenseDocument';
@@ -110,10 +106,18 @@ export abstract class BaseIntellisenseProvider implements IInteractiveWindowList
                 this.dispatchMessage(message, payload, this.addCell);
                 break;
 
+            case InteractiveWindowMessages.InsertCell:
+                this.dispatchMessage(message, payload, this.insertCell);
+                break;
+
             case InteractiveWindowMessages.RemoveCell:
                 this.dispatchMessage(message, payload, this.removeCell);
                 break;
 
+            case InteractiveWindowMessages.SwapCells:
+                this.dispatchMessage(message, payload, this.swapCells);
+                break;
+
             case InteractiveWindowMessages.DeleteAllCells:
                 this.dispatchMessage(message, payload, this.removeAllCells);
                 break;
@@ -130,10 +134,6 @@ export abstract class BaseIntellisenseProvider implements IInteractiveWindowList
                 this.dispatchMessage(message, payload, this.loadAllCells);
                 break;
 
-            case InteractiveWindowMessages.SendInfo:
-                this.dispatchMessage(message, payload, this.handleNativeEditorChanges);
-                break;
-
             default:
                 break;
         }
@@ -337,6 +337,15 @@ export abstract class BaseIntellisenseProvider implements IInteractiveWindowList
         }
     }
 
+    private async insertCell(request: IInsertCell): Promise<void> {
+        // Get the document and then pass onto the sub class
+        const document = await this.getDocument();
+        if (document) {
+            const changes = document.insertCell(request.id, request.code, request.codeCellAbove);
+            return this.handleChanges(undefined, document, changes);
+        }
+    }
+
     private async editCell(request: IEditCell): Promise<void> {
         // First get the document
         const document = await this.getDocument();
@@ -346,47 +355,45 @@ export abstract class BaseIntellisenseProvider implements IInteractiveWindowList
         }
     }
 
-    private removeCell(_request: IRemoveCell): Promise<void> {
-        // Skip this request. The logic here being that
-        // a user can remove a cell from the UI, but it's still loaded into the Jupyter kernel.
-        return Promise.resolve();
+    private async removeCell(request: IRemoveCell): Promise<void> {
+        // First get the document
+        const document = await this.getDocument();
+        if (document) {
+            const changes = document.remove(request.id);
+            return this.handleChanges(undefined, document, changes);
+        }
     }
 
-    private removeAllCells(): Promise<void> {
-        // Skip this request. The logic here being that
-        // a user can remove a cell from the UI, but it's still loaded into the Jupyter kernel.
-        return Promise.resolve();
+    private async swapCells(request: ISwapCells): Promise<void> {
+        // First get the document
+        const document = await this.getDocument();
+        if (document) {
+            const changes = document.swap(request.firstCellId, request.secondCellId);
+            return this.handleChanges(undefined, document, changes);
+        }
     }
 
-    private async loadAllCells(payload: ILoadAllCells) {
+    private async removeAllCells(): Promise<void> {
+        // First get the document
         const document = await this.getDocument();
         if (document) {
-            document.switchToEditMode();
-            await Promise.all(payload.cells.map(async cell => {
-                if (cell.data.cell_type === 'code') {
-                    const text = concatMultilineString(cell.data.source);
-                    const addCell: IAddCell = {
-                        fullText: text,
-                        currentText: text,
-                        file: cell.file,
-                        id: cell.id
-                    };
-                    await this.addCell(addCell);
-                }
-            }));
+            const changes = document.removeAll();
+            return this.handleChanges(undefined, document, changes);
         }
     }
 
-    private async handleNativeEditorChanges(payload: IInteractiveWindowInfo) {
+    private async loadAllCells(payload: ILoadAllCells) {
         const document = await this.getDocument();
-        let changes: TextDocumentContentChangeEvent[][] = [];
-        const file = payload.visibleCells[0] ? payload.visibleCells[0].file : undefined;
-
         if (document) {
-            changes = document.handleNativeEditorCellChanges(payload.visibleCells);
-        }
+            const changes = document.loadAllCells(payload.cells.filter(c => c.data.cell_type === 'code').map(cell => {
+                return {
+                    code: concatMultilineString(cell.data.source),
+                    id: cell.id
+                };
+            }));
 
-        await Promise.all(changes.map(c => this.handleChanges(file, document, c)));
+            await this.handleChanges(Identifiers.EmptyFileName, document, changes);
+        }
     }
 
     private async restartKernel(): Promise<void> {
diff --git a/src/client/datascience/interactive-common/intellisense/intellisenseDocument.ts b/src/client/datascience/interactive-common/intellisense/intellisenseDocument.ts
index 14ac6495a19a..fc07f5a37cff 100644
--- a/src/client/datascience/interactive-common/intellisense/intellisenseDocument.ts
+++ b/src/client/datascience/interactive-common/intellisense/intellisenseDocument.ts
@@ -8,9 +8,7 @@ import { EndOfLine, Position, Range, TextDocument, TextDocumentContentChangeEven
 import * as vscodeLanguageClient from 'vscode-languageclient';
 
 import { PYTHON_LANGUAGE } from '../../../common/constants';
-import { concatMultilineString } from '../../common';
 import { Identifiers } from '../../constants';
-import { ICell } from '../../types';
 import { DefaultWordPattern, ensureValidWordDefinition, getWordAtText, regExpLeadsToEndlessLoop } from './wordHelper';
 
 class IntellisenseLine implements TextLine {
@@ -118,10 +116,6 @@ export class IntellisenseDocument implements TextDocument {
         return this._lines.length;
     }
 
-    public switchToEditMode() {
-        this.inEditMode = true;
-    }
-
     public lineAt(position: Position | number): TextLine {
         if (typeof position === 'number') {
             return this._lines[position as number];
@@ -198,46 +192,56 @@ export class IntellisenseDocument implements TextDocument {
         };
     }
 
-    public handleNativeEditorCellChanges(cells: ICell[]): TextDocumentContentChangeEvent[][] {
-        const changes: TextDocumentContentChangeEvent[][] = [];
-
-        if (this.inEditMode) {
-            const incomingCells = cells.filter(c => c.data.cell_type === 'code');
-            const currentCellCount = this._cellRanges.length - 1;
-
-            if (currentCellCount < incomingCells.length) { // Cell was added
-                incomingCells.forEach((cell, i) => {
-                    if (!this.hasCell(cell.id)) {
-                        const text = concatMultilineString(cell.data.source);
-
-                        // addCell to the end of the document, or if adding in the middle,
-                        // send the id of the next cell to get its offset in the document
-                        if (i + 1 > incomingCells.length - 1) {
-                            changes.push(this.addCell(text, text, cell.id));
-                        } else {
-                            changes.push(this.addCell(text, text, cell.id, incomingCells[i + 1].id));
-                        }
-                    }
-                });
-            } else if (currentCellCount > incomingCells.length) { // Cell was deleted
-                const change = this.lookForCellToDelete(incomingCells);
-
-                if (change.length > 0) {
-                    changes.push(change);
-                }
-            } else { // Cell might have moved
-                const change = this.lookForCellMovement(incomingCells);
+    public loadAllCells(cells: { code: string; id: string }[]): TextDocumentContentChangeEvent[] {
+        let changes: TextDocumentContentChangeEvent[] = [];
+        if (!this.inEditMode) {
+            this.inEditMode = true;
+            this._version += 1;
 
-                if (change.length > 0) {
-                    changes.push(change);
+            // Normalize all of the cells, removing \r and separating each
+            // with a newline
+            const normalized = cells.map(c => {
+                return {
+                    id: c.id,
+                    code: `${c.code.replace(/\r/g, '')}\n`
+                };
+            });
+
+            // Contents are easy, just load all of the code in a row
+            this._contents = normalized.map(c => c.code).reduce((p, c) => {
+                return `${p}${c}`;
+            });
+
+            // Cell ranges are slightly more complicated
+            let prev: number = 0;
+            this._cellRanges = normalized.map(c => {
+                const result = {
+                    id: c.id,
+                    start: prev,
+                    fullEnd: prev + c.code.length,
+                    currentEnd: prev + c.code.length
+                };
+                prev += c.code.length;
+                return result;
+            });
+
+            // Then create the lines.
+            this._lines = this.createLines();
+
+            // Return our changes
+            changes = [
+                {
+                    range: this.createSerializableRange(new Position(0, 0), new Position(0, 0)),
+                    rangeOffset: 0,
+                    rangeLength: 0, // Adds are always zero
+                    text: this._contents
                 }
-            }
+            ];
         }
-
         return changes;
     }
 
-    public addCell(fullCode: string, currentCode: string, id: string, cellId?: string): TextDocumentContentChangeEvent[] {
+    public addCell(fullCode: string, currentCode: string, id: string): TextDocumentContentChangeEvent[] {
         // This should only happen once for each cell.
         this._version += 1;
 
@@ -251,51 +255,66 @@ export class IntellisenseDocument implements TextDocument {
         const newCode = `${normalized}\n`;
         const newCurrentCode = `${normalizedCurrent}\n`;
 
-        // We should start just before the last cell for the interactive window
-        // But return the start of the next cell for the native editor,
-        // in case we add a cell at the end in the native editor,
-        // just don't send a cellId to get an offset at the end of the document
-        const fromOffset = this.getEditCellOffset(cellId);
+        // We should start just before the last cell.
+        const fromOffset = this.getEditCellOffset();
 
         // Split our text between the edit text and the cells above
         const before = this._contents.substr(0, fromOffset);
         const after = this._contents.substr(fromOffset);
         const fromPosition = this.positionAt(fromOffset);
 
-        // for the interactive window or if the cell was added last,
-        // add cell to the end
-        let splicePosition = this._cellRanges.length - 1;
+        // Save the range for this cell ()
+        this._cellRanges.splice(this._cellRanges.length - 1, 0,
+            { id, start: fromOffset, fullEnd: fromOffset + newCode.length, currentEnd: fromOffset + newCurrentCode.length });
 
-        // for the native editor, find the index to add the cell to
-        if (cellId) {
-            const index = this._cellRanges.findIndex(c => c.id === cellId);
+        // Update our entire contents and recompute our lines
+        this._contents = `${before}${newCode}${after}`;
+        this._lines = this.createLines();
+        this._cellRanges[this._cellRanges.length - 1].start += newCode.length;
+        this._cellRanges[this._cellRanges.length - 1].fullEnd += newCode.length;
+        this._cellRanges[this._cellRanges.length - 1].currentEnd += newCode.length;
 
-            if (index > -1) {
-                splicePosition = index;
+        return [
+            {
+                range: this.createSerializableRange(fromPosition, fromPosition),
+                rangeOffset: fromOffset,
+                rangeLength: 0, // Adds are always zero
+                text: newCode
             }
-        }
+        ];
+    }
 
-        // Save the range for this cell ()
-        this._cellRanges.splice(splicePosition, 0,
-            { id, start: fromOffset, fullEnd: fromOffset + newCode.length, currentEnd: fromOffset + newCurrentCode.length });
+    public insertCell(id: string, code: string, codeCellAbove: string | undefined): TextDocumentContentChangeEvent[] {
+        // This should only happen once for each cell.
+        this._version += 1;
+
+        // Make sure to put a newline between this code and the next code
+        const newCode = `${code.replace(/\r/g, '')}\n`;
+
+        // Figure where this goes
+        const aboveIndex = this._cellRanges.findIndex(r => r.id === codeCellAbove);
+        const insertIndex = aboveIndex + 1;
+
+        // Compute where we start from.
+        const fromOffset = insertIndex < this._cellRanges.length ? this._cellRanges[insertIndex].start : this._contents.length;
+
+        // Split our text between the text and the cells above
+        const before = this._contents.substr(0, fromOffset);
+        const after = this._contents.substr(fromOffset);
+        const fromPosition = this.positionAt(fromOffset);
 
         // Update our entire contents and recompute our lines
         this._contents = `${before}${newCode}${after}`;
         this._lines = this.createLines();
 
-        if (cellId) {
-            // With the native editor, we fix all the positions that changed after adding
-            for (let i = splicePosition + 1; i < this._cellRanges.length; i += 1) {
-                this._cellRanges[i].start += newCode.length;
-                this._cellRanges[i].fullEnd += newCode.length;
-                this._cellRanges[i].currentEnd += newCode.length;
-            }
-        } else {
-            // with the interactive window, we just fix the positon of the last cell
-            this._cellRanges[this._cellRanges.length - 1].start += newCode.length;
-            this._cellRanges[this._cellRanges.length - 1].fullEnd += newCode.length;
-            this._cellRanges[this._cellRanges.length - 1].currentEnd += newCode.length;
+        // Move all the other cell ranges down
+        for (let i = insertIndex; i <= this._cellRanges.length - 1; i += 1) {
+            this._cellRanges[i].start += newCode.length;
+            this._cellRanges[i].fullEnd += newCode.length;
+            this._cellRanges[i].currentEnd += newCode.length;
         }
+        this._cellRanges.splice(insertIndex, 0,
+            { id, start: fromOffset, fullEnd: fromOffset + newCode.length, currentEnd: fromOffset + newCode.length });
 
         return [
             {
@@ -308,12 +327,12 @@ export class IntellisenseDocument implements TextDocument {
     }
 
     public removeAllCells(): TextDocumentContentChangeEvent[] {
-        // Remove everything up to the edit cell
-        if (this._cellRanges.length > 1) {
+        // Remove everything
+        if (this.inEditMode) {
             this._version += 1;
 
             // Compute the offset for the edit cell
-            const toOffset = this._cellRanges[this._cellRanges.length - 1].start;
+            const toOffset = this._cellRanges[this._cellRanges.length - 1].fullEnd;
             const from = this.positionAt(0);
             const to = this.positionAt(toOffset);
 
@@ -321,12 +340,7 @@ export class IntellisenseDocument implements TextDocument {
             const result = this.removeRange('', from, to, 0);
 
             // Update our cell range
-            this._cellRanges = [{
-                id: Identifiers.EditCellId,
-                start: 0,
-                fullEnd: this._cellRanges[this._cellRanges.length - 1].fullEnd - toOffset,
-                currentEnd: this._cellRanges[this._cellRanges.length - 1].fullEnd - toOffset
-            }];
+            this._cellRanges = [];
 
             return result;
         }
@@ -362,6 +376,123 @@ export class IntellisenseDocument implements TextDocument {
         return [];
     }
 
+    public remove(id: string): TextDocumentContentChangeEvent[] {
+        let change: TextDocumentContentChangeEvent[] = [];
+
+        const index = this._cellRanges.findIndex(c => c.id === id);
+        // Ignore unless in edit mode. For non edit mode, cells are still there.
+        if (index >= 0 && this.inEditMode) {
+            this._version += 1;
+
+            const found = this._cellRanges[index];
+            const foundLength = found.currentEnd - found.start;
+            const from = new Position(this.getLineFromOffset(found.start), 0);
+            const to = this.positionAt(found.currentEnd);
+
+            // Remove from the cell ranges.
+            for (let i = index + 1; i <= this._cellRanges.length - 1; i += 1) {
+                this._cellRanges[i].start -= foundLength;
+                this._cellRanges[i].fullEnd -= foundLength;
+                this._cellRanges[i].currentEnd -= foundLength;
+            }
+            this._cellRanges.splice(index, 1);
+
+            // Recreate the contents
+            const before = this._contents.substr(0, found.start);
+            const after = this._contents.substr(found.currentEnd);
+            this._contents = `${before}${after}`;
+            this._lines = this.createLines();
+
+            change = [
+                {
+                    range: this.createSerializableRange(from, to),
+                    rangeOffset: found.start,
+                    rangeLength: foundLength,
+                    text: ''
+                }
+            ];
+        }
+
+        return change;
+    }
+
+    public swap(first: string, second: string): TextDocumentContentChangeEvent[] {
+        let change: TextDocumentContentChangeEvent[] = [];
+
+        const firstIndex = this._cellRanges.findIndex(c => c.id === first);
+        const secondIndex = this._cellRanges.findIndex(c => c.id === second);
+        if (firstIndex >= 0 && secondIndex >= 0 && firstIndex !== secondIndex && this.inEditMode) {
+            this._version += 1;
+
+            const topIndex = firstIndex < secondIndex ? firstIndex : secondIndex;
+            const bottomIndex = firstIndex > secondIndex ? firstIndex : secondIndex;
+            const top = { ...this._cellRanges[topIndex] };
+            const bottom = { ...this._cellRanges[bottomIndex] };
+
+            const from = new Position(this.getLineFromOffset(top.start), 0);
+            const to = this.positionAt(bottom.currentEnd);
+
+            // Swap everything
+            this._cellRanges[topIndex].id = bottom.id;
+            this._cellRanges[topIndex].fullEnd = top.start + (bottom.fullEnd - bottom.start);
+            this._cellRanges[topIndex].currentEnd = top.start + (bottom.currentEnd - bottom.start);
+            this._cellRanges[bottomIndex].id = top.id;
+            this._cellRanges[bottomIndex].start = this._cellRanges[topIndex].fullEnd;
+            this._cellRanges[bottomIndex].fullEnd = this._cellRanges[topIndex].fullEnd + (top.fullEnd - top.start);
+            this._cellRanges[bottomIndex].currentEnd = this._cellRanges[topIndex].fullEnd + (top.currentEnd - top.start);
+
+            const fromOffset = this.convertToOffset(from);
+            const toOffset = this.convertToOffset(to);
+
+            // Recreate our contents, and then recompute all of our lines
+            const before = this._contents.substr(0, fromOffset);
+            const topText = this._contents.substr(top.start, top.fullEnd - top.start);
+            const bottomText = this._contents.substr(bottom.start, bottom.fullEnd - bottom.start);
+            const after = this._contents.substr(toOffset);
+            const replacement = `${bottomText}${topText}`;
+            this._contents = `${before}${replacement}${after}`;
+            this._lines = this.createLines();
+
+            // Change is a full replacement
+            change = [
+                {
+                    range: this.createSerializableRange(from, to),
+                    rangeOffset: fromOffset,
+                    rangeLength: toOffset - fromOffset,
+                    text: replacement
+                }
+            ];
+        }
+
+        return change;
+    }
+
+    public removeAll(): TextDocumentContentChangeEvent[] {
+        let change: TextDocumentContentChangeEvent[] = [];
+        // Ignore unless in edit mode.
+        if (this._lines.length > 0 && this.inEditMode) {
+            this._version += 1;
+
+            const from = this._lines[0].range.start;
+            const to = this._lines[this._lines.length - 1].rangeIncludingLineBreak.end;
+            const length = this._contents.length;
+            this._cellRanges = [];
+            this._contents = '';
+            this._lines = [];
+
+            change = [
+                {
+                    range: this.createSerializableRange(from, to),
+                    rangeOffset: 0,
+                    rangeLength: length,
+                    text: ''
+                }
+            ];
+        }
+
+        return change;
+    }
+
     public convertToDocumentPosition(id: string, line: number, ch: number): Position {
         // Monaco is 1 based, and we need to add in our cell offset.
         const cellIndex = this._cellRanges.findIndex(c => c.id === id);
@@ -405,11 +536,6 @@ export class IntellisenseDocument implements TextDocument {
         return this._cellRanges[this._cellRanges.length - 1].start;
     }
 
-    private hasCell(cellId: string) {
-        const foundIt = this._cellRanges.find(c => c.id === cellId);
-        return foundIt ? true : false;
-    }
-
     private getLineFromOffset(offset: number) {
         let lineCounter = 0;
 
@@ -422,83 +548,6 @@ export class IntellisenseDocument implements TextDocument {
         return lineCounter;
     }
 
-    private lookForCellToDelete(incomingCells: ICell[]): TextDocumentContentChangeEvent[] {
-        let change: TextDocumentContentChangeEvent[] = [];
-
-        this._cellRanges.forEach((cell, i) => {
-            const foundIt = incomingCells.find(c => c.id === cell.id);
-
-            // if cell is not found in the document and its not the last edit cell, we remove it
-            if (!foundIt && i !== this._cellRanges.length - 1) {
-                const from = new Position(this.getLineFromOffset(cell.start), 0);
-                const to = this.positionAt(cell.currentEnd);
-
-                // for some reason, start for the next cell isn't updated on removeRange,
-                // so we update it here
-                this._cellRanges[i + 1].start = cell.start;
-                this._cellRanges.splice(i, 1);
-                change = this.removeRange('', from, to, i);
-            }
-        });
-
-        return change;
-    }
-
-    private lookForCellMovement(incomingCells: ICell[]): TextDocumentContentChangeEvent[] {
-        for (let i = 0; i < incomingCells.length && this._cellRanges.length > 1; i += 1) {
-
-            if (incomingCells[i].id !== this._cellRanges[i].id) {
-                const lineBreak = '\n';
-                const text = this._contents.substr(this._cellRanges[i].start, this._cellRanges[i].currentEnd - this._cellRanges[i].start - 1);
-                const newText = concatMultilineString(incomingCells[i].data.source) + lineBreak + text + lineBreak;
-
-                // swap contents
-                this._contents = this._contents.substring(0, this._cellRanges[i].start)
-                    + this._contents.substring(this._cellRanges[i + 1].start, this._cellRanges[i + 1].fullEnd)
-                    + this._contents.substring(this._cellRanges[i].start, this._cellRanges[i].fullEnd)
-                    + this._contents.substring(this._cellRanges[i + 1].fullEnd);
-
-                // create lines
-                this._lines = this.createLines();
-
-                // swap cell ranges
-                const temp1Id = this._cellRanges[i].id;
-                const temp1Start = this._cellRanges[i].start;
-                const temp1End = this._cellRanges[i].fullEnd;
-                const temp1Length = temp1End - temp1Start;
-
-                const temp2Id = this._cellRanges[i + 1].id;
-                const temp2Start = this._cellRanges[i + 1].start;
-                const temp2End = this._cellRanges[i + 1].fullEnd;
-                const temp2Length = temp2End - temp2Start;
-
-                this._cellRanges[i].id = temp2Id;
-                this._cellRanges[i].start = temp1Start;
-                this._cellRanges[i].currentEnd = temp1Start + temp2Length;
-                this._cellRanges[i].fullEnd = temp1Start + temp2Length;
-
-                this._cellRanges[i + 1].id = temp1Id;
-                this._cellRanges[i + 1].start = temp1Start + temp2Length;
-                this._cellRanges[i + 1].currentEnd = temp1Start + temp2Length + temp1Length;
-                this._cellRanges[i + 1].fullEnd = temp1Start + temp2Length + temp1Length;
-
-                const from = new Position(this.getLineFromOffset(temp1Start), 0);
-                const to = new Position(this.getLineFromOffset(temp2End - 1), temp2End - temp2Start);
-                const fromOffset = temp1Start;
-                const toOffset = temp2End;
-
-                return [{
-                    range: this.createSerializableRange(from, to),
-                    rangeOffset: fromOffset,
-                    rangeLength: toOffset - fromOffset,
-                    text: newText
-                }];
-            }
-        }
-
-        return [];
-    }
-
     private removeRange(newText: string, from: Position, to: Position, cellIndex: number): TextDocumentContentChangeEvent[] {
         const fromOffset = this.convertToOffset(from);
         const toOffset = this.convertToOffset(to);
@@ -552,6 +601,9 @@ export class IntellisenseDocument implements TextDocument {
     }
 
     private createSerializableRange(start: Position, end: Position): Range {
+        // This funciton is necessary so that the Range can be passed back
+        // over a remote connection without including all of the extra fields that
+        // VS code puts into a Range object.
         const result = {
             start: {
                 line: start.line,
diff --git a/src/client/datascience/interactive-common/interactiveWindowTypes.ts b/src/client/datascience/interactive-common/interactiveWindowTypes.ts
index 446563bcb4de..c46a6bad5dd3 100644
--- a/src/client/datascience/interactive-common/interactiveWindowTypes.ts
+++ b/src/client/datascience/interactive-common/interactiveWindowTypes.ts
@@ -51,6 +51,8 @@ export namespace InteractiveWindowMessages {
     export const AddCell = 'add_cell';
     export const EditCell = 'edit_cell';
     export const RemoveCell = 'remove_cell';
+    export const SwapCells = 'swap_cells';
+    export const InsertCell = 'insert_cell';
     export const LoadOnigasmAssemblyRequest = 'load_onigasm_assembly_request';
     export const LoadOnigasmAssemblyResponse = 'load_onigasm_assembly_response';
     export const LoadTmLanguageRequest = 'load_tmlanguage_request';
@@ -210,6 +212,17 @@ export interface IRemoveCell {
     id: string;
 }
 
+export interface ISwapCells {
+    firstCellId: string;
+    secondCellId: string;
+}
+
+export interface IInsertCell {
+    id: string;
+    code: string;
+    codeCellAbove: string | undefined;
+}
+
 export interface IShowDataViewer {
     variableName: string;
     columnSize: number;
@@ -284,6 +297,8 @@ export class IInteractiveWindowMapping {
     public [InteractiveWindowMessages.AddCell]: IAddCell;
     public [InteractiveWindowMessages.EditCell]: IEditCell;
     public [InteractiveWindowMessages.RemoveCell]: IRemoveCell;
+    public [InteractiveWindowMessages.SwapCells]: ISwapCells;
+    public [InteractiveWindowMessages.InsertCell]: IInsertCell;
     public [InteractiveWindowMessages.LoadOnigasmAssemblyRequest]: never | undefined;
     public [InteractiveWindowMessages.LoadOnigasmAssemblyResponse]: Buffer;
     public [InteractiveWindowMessages.LoadTmLanguageRequest]: never | undefined;
diff --git a/src/datascience-ui/history-react/interactiveCell.tsx b/src/datascience-ui/history-react/interactiveCell.tsx
index e5ba31e99266..1e1284a41319 100644
--- a/src/datascience-ui/history-react/interactiveCell.tsx
+++ b/src/datascience-ui/history-react/interactiveCell.tsx
@@ -4,6 +4,7 @@
 import '../../client/common/extensions';
 
 import { nbformat } from '@jupyterlab/coreutils';
+import * as fastDeepEqual from 'fast-deep-equal';
 import * as monacoEditor from 'monaco-editor/esm/vs/editor/editor.api';
 import * as React from 'react';
 
@@ -35,10 +36,6 @@ interface IInteractiveCellProps {
     editorOptions?: monacoEditor.editor.IEditorOptions;
     editExecutionCount?: string;
     editorMeasureClassName?: string;
-    selectedCell?: string;
-    focusedCell?: string;
-    hideOutput?: boolean;
-    showLineNumbers?: boolean;
     font: IFont;
     onCodeChange(changes: monacoEditor.editor.IModelContentChange[], cellId: string, modelId: string): void;
     onCodeCreated(code: string, file: string, cellId: string, modelId: string): void;
@@ -72,11 +69,15 @@ export class InteractiveCell extends React.Component<IInteractiveCellProps> {
     }
 
     public componentDidUpdate(prevProps: IInteractiveCellProps) {
-        if (this.props.selectedCell === this.props.cellVM.cell.id && prevProps.selectedCell !== this.props.selectedCell) {
-            this.giveFocus(this.props.focusedCell === this.props.cellVM.cell.id);
+        if (this.props.cellVM.selected && !prevProps.cellVM.selected) {
+            this.giveFocus(this.props.cellVM.focused);
         }
     }
 
+    public shouldComponentUpdate(nextProps: IInteractiveCellProps): boolean {
+        return !fastDeepEqual(this.props, nextProps);
+    }
+
     public scrollAndFlash() {
         if (this.wrapperRef && this.wrapperRef.current) {
             this.wrapperRef.current.scrollIntoView({ behavior: 'auto', block: 'nearest', inline: 'nearest' });
@@ -211,7 +212,7 @@ export class InteractiveCell extends React.Component<IInteractiveCellProps> {
                     focused={this.onCodeFocused}
                     unfocused={this.onCodeUnfocused}
                     keyDown={this.props.keyDown}
-                    showLineNumbers={this.props.showLineNumbers}
+                    showLineNumbers={this.props.cellVM.showLineNumbers}
                     font={this.props.font}
                 />
             );
@@ -240,7 +241,7 @@ export class InteractiveCell extends React.Component<IInteractiveCellProps> {
     }
 
     private shouldRenderResults(): boolean {
-        return this.isCodeCell() && this.hasOutput() && this.getCodeCell().outputs && this.getCodeCell().outputs.length > 0 && !this.props.hideOutput;
+        return this.isCodeCell() && this.hasOutput() && this.getCodeCell().outputs && this.getCodeCell().outputs.length > 0 && !this.props.cellVM.hideOutput;
     }
 
     private onCellKeyDown = (event: React.KeyboardEvent<HTMLDivElement>) => {
diff --git a/src/datascience-ui/history-react/interactivePanel.tsx b/src/datascience-ui/history-react/interactivePanel.tsx
index 5038823a0730..46a0adf7c7d5 100644
--- a/src/datascience-ui/history-react/interactivePanel.tsx
+++ b/src/datascience-ui/history-react/interactivePanel.tsx
@@ -350,8 +350,6 @@ export class InteractivePanel extends React.Component<IInteractivePanelProps, IM
                         openLink={this.stateController.openLink}
                         expandImage={this.stateController.showPlot}
                         renderCellToolbar={this.renderCellToolbar}
-                        showLineNumbers={cellVM.showLineNumbers}
-                        hideOutput={cellVM.hideOutput}
                         font={this.state.font}
                     />
                 </ErrorBoundary>
diff --git a/src/datascience-ui/interactive-common/mainState.ts b/src/datascience-ui/interactive-common/mainState.ts
index 67bd7ed57ac4..49ca98e6a586 100644
--- a/src/datascience-ui/interactive-common/mainState.ts
+++ b/src/datascience-ui/interactive-common/mainState.ts
@@ -26,6 +26,8 @@ export interface ICellViewModel {
     showLineNumbers?: boolean;
     hideOutput?: boolean;
     useQuickEdit?: boolean;
+    selected: boolean;
+    focused: boolean;
     inputBlockToggled(id: string): void;
 }
 
@@ -53,11 +55,11 @@ export interface IMainState {
     pendingVariableCount: number;
     debugging: boolean;
     dirty?: boolean;
-    selectedCell?: string;
-    focusedCell?: string;
+    selectedCellId?: string;
+    focusedCellId?: string;
     enableGather: boolean;
     isAtBottom: boolean;
-    newCell?: string;
+    newCellId?: string;
     loadTotal?: number;
 }
 
@@ -145,7 +147,9 @@ export function createEditableCellVM(executionCount: number): ICellViewModel {
         inputBlockShow: true,
         inputBlockText: '',
         inputBlockCollapseNeeded: false,
-        inputBlockToggled: noop
+        inputBlockToggled: noop,
+        selected: false,
+        focused: false
     };
 }
 
@@ -186,12 +190,14 @@ export function createCellVM(inputCell: ICell, settings: IDataScienceSettings |
         inputBlockShow: true,
         inputBlockText: inputText,
         inputBlockCollapseNeeded: (inputLinesCount > 1),
-        inputBlockToggled: inputBlockToggled
+        inputBlockToggled: inputBlockToggled,
+        selected: false,
+        focused: false
     };
 }
 
 function generateVMs(inputBlockToggled: (id: string) => void, filePath: string, editable: boolean): ICellViewModel[] {
-    const cells = generateCells(filePath);
+    const cells = generateCells(filePath, 10);
     return cells.map((cell: ICell) => {
         const vm = createCellVM(cell, undefined, inputBlockToggled, editable);
         vm.useQuickEdit = false;
@@ -199,10 +205,10 @@ function generateVMs(inputBlockToggled: (id: string) => void, filePath: string,
     });
 }
 
-function generateCells(filePath: string): ICell[] {
+export function generateCells(filePath: string, repetitions: number): ICell[] {
     // Dupe a bunch times for perf reasons
     let cellData: (nbformat.ICodeCell | nbformat.IMarkdownCell | nbformat.IRawCell | IMessageCell)[] = [];
-    for (let i = 0; i < 10; i += 1) {
+    for (let i = 0; i < repetitions; i += 1) {
         cellData = [...cellData, ...generateCellData()];
     }
     return cellData.map((data: nbformat.ICodeCell | nbformat.IMarkdownCell | nbformat.IRawCell | IMessageCell, key: number) => {
diff --git a/src/datascience-ui/interactive-common/mainStateController.ts b/src/datascience-ui/interactive-common/mainStateController.ts
index a0b7cab178f7..328d0cf00a34 100644
--- a/src/datascience-ui/interactive-common/mainStateController.ts
+++ b/src/datascience-ui/interactive-common/mainStateController.ts
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 'use strict';
 import * as fastDeepEqual from 'fast-deep-equal';
+import * as immutable from 'immutable';
 import { min } from 'lodash';
 // tslint:disable-next-line: no-require-imports
 import cloneDeep = require('lodash/cloneDeep');
@@ -31,7 +32,14 @@ import { getSettings, updateSettings } from '../react-common/settingsReactSide';
 import { detectBaseTheme } from '../react-common/themeDetector';
 import { InputHistory } from './inputHistory';
 import { IntellisenseProvider } from './intellisenseProvider';
-import { createCellVM, createEditableCellVM, extractInputText, generateTestState, ICellViewModel, IMainState } from './mainState';
+import {
+    createCellVM,
+    createEditableCellVM,
+    extractInputText,
+    generateTestState,
+    ICellViewModel,
+    IMainState
+} from './mainState';
 import { initializeTokenizer, registerMonacoLanguage } from './tokenizer';
 
 export interface IMainStateControllerProps {
@@ -49,7 +57,8 @@ export interface IMainStateControllerProps {
 // tslint:disable-next-line: max-func-body-length
 export class MainStateController implements IMessageHandler {
     private stackLimit = 10;
-    private state: IMainState;
+    private pendingState: IMainState;
+    private renderedState: IMainState;
     private postOffice: PostOffice = new PostOffice();
     private intellisenseProvider: IntellisenseProvider;
     private onigasmPromise: Deferred<ArrayBuffer> | undefined;
@@ -60,7 +69,7 @@ export class MainStateController implements IMessageHandler {
 
     // tslint:disable-next-line:max-func-body-length
     constructor(private props: IMainStateControllerProps) {
-        this.state = {
+        this.renderedState = {
             editorOptions: this.computeEditorOptions(),
             cellVMs: [],
             busy: true,
@@ -85,7 +94,7 @@ export class MainStateController implements IMessageHandler {
 
         // Add test state if necessary
         if (!this.props.skipDefault) {
-            this.state = generateTestState(this.inputBlockToggled, '', this.props.defaultEditable);
+            this.renderedState = generateTestState(this.inputBlockToggled, '', this.props.defaultEditable);
         }
 
         // Setup the completion provider for monaco. We only need one
@@ -95,7 +104,7 @@ export class MainStateController implements IMessageHandler {
         if (this.props.skipDefault) {
             if (this.props.testMode) {
                 // Running a test, skip the tokenizer. We want the UI to display synchronously
-                this.state = { tokenizerLoaded: true, ...this.state };
+                this.renderedState = { tokenizerLoaded: true, ...this.renderedState };
 
                 // However we still need to register python as a language
                 registerMonacoLanguage();
@@ -104,6 +113,9 @@ export class MainStateController implements IMessageHandler {
             }
         }
 
+        // Copy the rendered state
+        this.pendingState = { ...this.renderedState };
+
         // Add ourselves as a handler for the post office
         this.postOffice.addHandler(this);
 
@@ -247,16 +259,16 @@ export class MainStateController implements IMessageHandler {
     }
 
     public stopBusy = () => {
-        if (this.state.busy) {
+        if (this.pendingState.busy) {
             this.setState({ busy: false });
         }
     }
 
     public redo = () => {
         // Pop one off of our redo stack and update our undo
-        const cells = this.state.redoStack[this.state.redoStack.length - 1];
-        const redoStack = this.state.redoStack.slice(0, this.state.redoStack.length - 1);
-        const undoStack = this.pushStack(this.state.undoStack, this.state.cellVMs);
+        const cells = this.pendingState.redoStack[this.pendingState.redoStack.length - 1];
+        const redoStack = this.pendingState.redoStack.slice(0, this.pendingState.redoStack.length - 1);
+        const undoStack = this.pushStack(this.pendingState.undoStack, this.pendingState.cellVMs);
         this.sendMessage(InteractiveWindowMessages.Redo);
         this.setState({
             cellVMs: cells,
@@ -268,9 +280,9 @@ export class MainStateController implements IMessageHandler {
 
     public undo = () => {
         // Pop one off of our undo stack and update our redo
-        const cells = this.state.undoStack[this.state.undoStack.length - 1];
-        const undoStack = this.state.undoStack.slice(0, this.state.undoStack.length - 1);
-        const redoStack = this.pushStack(this.state.redoStack, this.state.cellVMs);
+        const cells = this.pendingState.undoStack[this.pendingState.undoStack.length - 1];
+        const undoStack = this.pendingState.undoStack.slice(0, this.pendingState.undoStack.length - 1);
+        const redoStack = this.pushStack(this.pendingState.redoStack, this.pendingState.cellVMs);
         this.sendMessage(InteractiveWindowMessages.Undo);
         this.setState({
             cellVMs: cells,
@@ -281,15 +293,30 @@ export class MainStateController implements IMessageHandler {
     }
 
     public deleteCell = (cellId: string) => {
-        const cellVM = this.state.cellVMs.find(c => c.cell.id === cellId);
-        if (cellVM) {
+        const index = this.findCellIndex(cellId);
+        if (index >= 0) {
             this.sendMessage(InteractiveWindowMessages.DeleteCell);
-            this.sendMessage(InteractiveWindowMessages.RemoveCell, { id: cellVM.cell.id });
+            this.sendMessage(InteractiveWindowMessages.RemoveCell, { id: cellId });
+
+            // Recompute select/focus if this item has either
+            let newSelection = this.pendingState.selectedCellId;
+            let newFocused = this.pendingState.focusedCellId;
+            const newVMs = [...this.pendingState.cellVMs.filter(c => c.cell.id !== cellId)];
+            const nextOrPrev = index === this.pendingState.cellVMs.length - 1 ? index - 1 : index;
+            if (this.pendingState.selectedCellId === cellId || this.pendingState.focusedCellId === cellId) {
+                if (nextOrPrev >= 0) {
+                    newVMs[nextOrPrev] = { ...newVMs[nextOrPrev], selected: true, focused: this.pendingState.focusedCellId === cellId };
+                    newSelection = newVMs[nextOrPrev].cell.id;
+                    newFocused = newVMs[nextOrPrev].focused ? newVMs[nextOrPrev].cell.id : undefined;
+                }
+            }
 
             // Update our state
             this.setState({
-                cellVMs: this.state.cellVMs.filter(c => c.cell.id !== cellId),
-                undoStack: this.pushStack(this.state.undoStack, this.state.cellVMs),
+                cellVMs: newVMs,
+                selectedCell: newSelection,
+                focusedCell: newFocused,
+                undoStack: this.pushStack(this.pendingState.undoStack, this.pendingState.cellVMs),
                 skipNextScroll: true
             });
         }
@@ -326,7 +353,7 @@ export class MainStateController implements IMessageHandler {
 
     public save = () => {
         // We have to take the current value of each cell to make sure we have the correct text.
-        this.state.cellVMs.forEach(c => this.updateCellSource(c.cell.id));
+        this.pendingState.cellVMs.forEach(c => this.updateCellSource(c.cell.id));
 
         // Then send the save with the new state.
         this.sendMessage(InteractiveWindowMessages.SaveAll, { cells: this.getNonEditCellVMs().map(cvm => cvm.cell) });
@@ -357,11 +384,11 @@ export class MainStateController implements IMessageHandler {
     }
 
     public canRedo = () => {
-        return this.state.redoStack.length > 0;
+        return this.pendingState.redoStack.length > 0;
     }
 
     public canUndo = () => {
-        return this.state.undoStack.length > 0;
+        return this.pendingState.undoStack.length > 0;
     }
 
     public canClearAllOutputs = () => {
@@ -369,10 +396,8 @@ export class MainStateController implements IMessageHandler {
     }
 
     public clearAllOutputs = () => {
-        const newList = this.state.cellVMs.map(cellVM => {
-            const newVM = cloneDeep(cellVM);
-            newVM.cell.data.outputs = [];
-            return newVM;
+        const newList = this.pendingState.cellVMs.map(cellVM => {
+            return immutable.updateIn(cellVM, ['cell', 'data', 'outputs'], () => []);
         });
         this.setState({
             cellVMs: newList
@@ -381,7 +406,7 @@ export class MainStateController implements IMessageHandler {
 
     public gotoCellCode = (cellId: string) => {
         // Find our cell
-        const cellVM = this.state.cellVMs.find(c => c.cell.id === cellId);
+        const cellVM = this.pendingState.cellVMs.find(c => c.cell.id === cellId);
 
         // Send a message to the other side to jump to a particular cell
         if (cellVM) {
@@ -391,9 +416,9 @@ export class MainStateController implements IMessageHandler {
 
     public copyCellCode = (cellId: string) => {
         // Find our cell. This is also supported on the edit cell
-        let cellVM = this.state.cellVMs.find(c => c.cell.id === cellId);
-        if (!cellVM && this.state.editCellVM && cellId === this.state.editCellVM.cell.id) {
-            cellVM = this.state.editCellVM;
+        let cellVM = this.pendingState.cellVMs.find(c => c.cell.id === cellId);
+        if (!cellVM && this.pendingState.editCellVM && cellId === this.pendingState.editCellVM.cell.id) {
+            cellVM = this.pendingState.editCellVM;
         }
 
         // Send a message to the other side to jump to a particular cell
@@ -420,19 +445,19 @@ export class MainStateController implements IMessageHandler {
 
     public export = () => {
         // Send a message to the other side to export our current list
-        const cellContents: ICell[] = this.state.cellVMs.map((cellVM: ICellViewModel, _index: number) => { return cellVM.cell; });
+        const cellContents: ICell[] = this.pendingState.cellVMs.map((cellVM: ICellViewModel, _index: number) => { return cellVM.cell; });
         this.sendMessage(InteractiveWindowMessages.Export, cellContents);
     }
 
     // When the variable explorer wants to refresh state (say if it was expanded)
     public refreshVariables = (newExecutionCount?: number) => {
-        this.sendMessage(InteractiveWindowMessages.GetVariablesRequest, newExecutionCount === undefined ? this.state.currentExecutionCount : newExecutionCount);
+        this.sendMessage(InteractiveWindowMessages.GetVariablesRequest, newExecutionCount === undefined ? this.pendingState.currentExecutionCount : newExecutionCount);
     }
 
     public toggleVariableExplorer = () => {
-        this.sendMessage(InteractiveWindowMessages.VariableExplorerToggle, !this.state.variablesVisible);
-        this.setState({ variablesVisible: !this.state.variablesVisible });
-        if (!this.state.variablesVisible) {
+        this.sendMessage(InteractiveWindowMessages.VariableExplorerToggle, !this.pendingState.variablesVisible);
+        this.setState({ variablesVisible: !this.pendingState.variablesVisible });
+        if (this.pendingState.variablesVisible) {
             this.refreshVariables();
         }
     }
@@ -452,7 +477,7 @@ export class MainStateController implements IMessageHandler {
     }
 
     public readOnlyCodeCreated = (_text: string, file: string, id: string, monacoId: string) => {
-        const cell = this.state.cellVMs.find(c => c.cell.id === id);
+        const cell = this.pendingState.cellVMs.find(c => c.cell.id === id);
         if (cell) {
             // Pass this onto the completion provider running in the extension
             this.sendMessage(InteractiveWindowMessages.AddCell, {
@@ -476,28 +501,67 @@ export class MainStateController implements IMessageHandler {
 
     public codeLostFocus = (cellId: string) => {
         this.onCodeLostFocus(cellId);
-        if (this.state.focusedCell === cellId) {
+        if (this.pendingState.focusedCellId === cellId) {
+            const newVMs = [...this.pendingState.cellVMs];
+            // Switch the old vm
+            const oldSelect = this.findCellIndex(cellId);
+            if (oldSelect >= 0) {
+                newVMs[oldSelect] = { ...newVMs[oldSelect], focused: false };
+            }
             // Only unfocus if we haven't switched somewhere else yet
-            this.setState({ focusedCell: undefined });
+            this.setState({ focusedCell: undefined, cellVMs: newVMs });
         }
     }
 
     public codeGotFocus = (cellId: string | undefined) => {
-        this.setState({ selectedCell: cellId, focusedCell: cellId });
+        // Skip if already has focus
+        if (cellId !== this.pendingState.focusedCellId) {
+            const newVMs = [...this.pendingState.cellVMs];
+            // Switch the old vm
+            const oldSelect = this.findCellIndex(this.pendingState.selectedCellId);
+            if (oldSelect >= 0) {
+                newVMs[oldSelect] = { ...newVMs[oldSelect], selected: false, focused: false };
+            }
+            const newSelect = this.findCellIndex(cellId);
+            if (newSelect >= 0) {
+                newVMs[newSelect] = { ...newVMs[newSelect], selected: true, focused: true };
+            }
+
+            // Save the whole thing in our state.
+            this.setState({ selectedCell: cellId, focusedCell: cellId, cellVMs: newVMs });
+        }
     }
 
     public selectCell = (cellId: string, focusedCell?: string) => {
-        this.setState({ selectedCell: cellId, focusedCell });
+        // Skip if already the same cell
+        if (this.pendingState.selectedCellId !== cellId || this.pendingState.focusedCellId !== focusedCell) {
+            const newVMs = [...this.pendingState.cellVMs];
+            // Switch the old vm
+            const oldSelect = this.findCellIndex(this.pendingState.selectedCellId);
+            if (oldSelect >= 0) {
+                newVMs[oldSelect] = { ...newVMs[oldSelect], selected: false, focused: false };
+            }
+            const newSelect = this.findCellIndex(cellId);
+            if (newSelect >= 0) {
+                newVMs[newSelect] = { ...newVMs[newSelect], selected: true, focused: focusedCell === newVMs[newSelect].cell.id };
+            }
+
+            // Save the whole thing in our state.
+            this.setState({ selectedCell: cellId, focusedCell, cellVMs: newVMs });
+        }
     }
 
     public changeCellType = (cellId: string, newType: 'code' | 'markdown') => {
-        const index = this.state.cellVMs.findIndex(c => c.cell.id === cellId);
-        if (index >= 0 && this.state.cellVMs[index].cell.data.cell_type !== newType) {
-            const newVM = cloneDeep(this.state.cellVMs[index]);
-            newVM.cell.data.cell_type = newType;
-            const cellVMs = [...this.state.cellVMs];
-            cellVMs.splice(index, 1, newVM);
+        const index = this.pendingState.cellVMs.findIndex(c => c.cell.id === cellId);
+        if (index >= 0 && this.pendingState.cellVMs[index].cell.data.cell_type !== newType) {
+            const cellVMs = [...this.pendingState.cellVMs];
+            cellVMs[index] = immutable.updateIn(this.pendingState.cellVMs[index], ['cell', 'data', 'cell_type'], () => newType);
             this.setState({ cellVMs });
+            if (newType === 'code') {
+                this.sendMessage(InteractiveWindowMessages.InsertCell, { id: cellId, code: concatMultilineString(cellVMs[index].cell.data.source), codeCellAbove: this.firstCodeCellAbove(cellId) });
+            } else {
+                this.sendMessage(InteractiveWindowMessages.RemoveCell, { id: cellId });
+            }
         }
     }
 
@@ -552,9 +616,9 @@ export class MainStateController implements IMessageHandler {
             // Stick in a new cell at the bottom that's editable and update our state
             // so that the last cell becomes busy
             this.setState({
-                cellVMs: [...this.state.cellVMs, newCell],
-                undoStack: this.pushStack(this.state.undoStack, this.state.cellVMs),
-                redoStack: this.state.redoStack,
+                cellVMs: [...this.pendingState.cellVMs, newCell],
+                undoStack: this.pushStack(this.pendingState.undoStack, this.pendingState.cellVMs),
+                redoStack: this.pendingState.redoStack,
                 skipNextScroll: false,
                 submittedText: true
             });
@@ -564,74 +628,79 @@ export class MainStateController implements IMessageHandler {
                 this.sendMessage(InteractiveWindowMessages.SubmitNewCell, { code, id: newCell.cell.id });
             }
         } else if (inputCell.cell.data.cell_type === 'code') {
-            // Update our input cell to be in progress again
-            inputCell.cell.state = CellState.executing;
-
-            // Clear our outputs
-            inputCell.cell.data.outputs = [];
-
-            // Update our state to display the new status
-            this.setState({
-                cellVMs: [...this.state.cellVMs]
-            });
+            const index = this.findCellIndex(inputCell.cell.id);
+            if (index >= 0) {
+                // Update our input cell to be in progress again and clear outputs
+                const newVMs = [...this.pendingState.cellVMs];
+                newVMs[index] = { ...inputCell, cell: { ...inputCell.cell, state: CellState.executing, data: { ...inputCell.cell.data, outputs: [] } } };
+                this.setState({
+                    cellVMs: newVMs
+                });
+            }
 
             // Send a message to rexecute this code
             this.sendMessage(InteractiveWindowMessages.ReExecuteCell, { code, id: inputCell.cell.id });
         } else if (inputCell.cell.data.cell_type === 'markdown') {
-            // Change the input on the cell
-            inputCell.cell.data.source = code;
-            inputCell.inputBlockText = code;
-
-            // Update our state to display the new status
-            this.setState({
-                cellVMs: [...this.state.cellVMs]
-            });
+            const index = this.findCellIndex(inputCell.cell.id);
+            if (index >= 0) {
+                // Change the input on the cell
+                const newVMs = [...this.pendingState.cellVMs];
+                newVMs[index] = { ...inputCell, inputBlockText: code, cell: { ...inputCell.cell, data: { ...inputCell.cell.data, source: code } } };
+                this.setState({
+                    cellVMs: newVMs
+                });
+            }
         }
     }
 
     public findCell(cellId?: string): ICellViewModel | undefined {
-        const nonEdit = this.state.cellVMs.find(cvm => cvm.cell.id === cellId);
+        const nonEdit = this.pendingState.cellVMs.find(cvm => cvm.cell.id === cellId);
         if (!nonEdit && cellId === Identifiers.EditCellId) {
-            return this.state.editCellVM;
+            return this.pendingState.editCellVM;
         }
         return nonEdit;
     }
 
+    public findCellIndex(cellId?: string): number {
+        return this.pendingState.cellVMs.findIndex(cvm => cvm.cell.id === cellId);
+    }
+
     public getMonacoId(cellId: string): string | undefined {
         return this.cellIdToMonacoId.get(cellId);
     }
 
     public toggleLineNumbers = (cellId: string) => {
-        const index = this.state.cellVMs.findIndex(c => c.cell.id === cellId);
+        const index = this.pendingState.cellVMs.findIndex(c => c.cell.id === cellId);
         if (index >= 0) {
-            const newVMs = [...this.state.cellVMs];
-            newVMs[index] = cloneDeep(newVMs[index]);
-            newVMs[index].showLineNumbers = !newVMs[index].showLineNumbers;
+            const newVMs = [...this.pendingState.cellVMs];
+            newVMs[index] = immutable.merge(newVMs[index], { showLineNumbers: !newVMs[index].showLineNumbers });
             this.setState({ cellVMs: newVMs });
         }
     }
 
     public toggleOutput = (cellId: string) => {
-        const index = this.state.cellVMs.findIndex(c => c.cell.id === cellId);
+        const index = this.pendingState.cellVMs.findIndex(c => c.cell.id === cellId);
         if (index >= 0) {
-            const newVMs = [...this.state.cellVMs];
-            newVMs[index] = cloneDeep(newVMs[index]);
-            newVMs[index].hideOutput = !newVMs[index].hideOutput;
+            const newVMs = [...this.pendingState.cellVMs];
+            newVMs[index] = immutable.merge(newVMs[index], { hideOutput: !newVMs[index].hideOutput });
             this.setState({ cellVMs: newVMs });
         }
     }
 
     public setState(newState: {}, callback?: () => void) {
+        // Add to writable state (it should always reflect the current conditions)
+        this.pendingState = { ...this.pendingState, ...newState };
+
         if (this.suspendUpdateCount > 0) {
             // Just save our new state
-            this.state = { ...this.state, ...newState };
+            this.renderedState = { ...this.renderedState, ...newState };
             if (callback) {
                 callback();
             }
         } else {
             // Send a UI update
             this.props.setState(newState, () => {
-                this.state = { ...this.state, ...newState };
+                this.renderedState = { ...this.renderedState, ...newState };
                 if (callback) {
                     callback();
                 }
@@ -640,7 +709,7 @@ export class MainStateController implements IMessageHandler {
     }
 
     public renderUpdate(newState: {}) {
-        const oldCount = this.state.pendingVariableCount;
+        const oldCount = this.renderedState.pendingVariableCount;
 
         // This method should be called during the render stage of anything
         // using this state Controller. That's because after shouldComponentUpdate
@@ -648,7 +717,7 @@ export class MainStateController implements IMessageHandler {
         // See https://reactjs.org/docs/react-component.html
         // Otherwise we set the state in the callback during setState and this can be
         // too late for any render code to use the stateController.
-        this.state = { ...this.state, ...newState };
+        this.renderedState = { ...this.renderedState, ...newState };
 
         // If the new state includes any cellVM changes, send an update to the other side
         if ('cellVMs' in newState) {
@@ -656,13 +725,13 @@ export class MainStateController implements IMessageHandler {
         }
 
         // If the new state includes pendingVariableCount and it's gone to zero, send a message
-        if (this.state.pendingVariableCount === 0 && oldCount !== 0) {
+        if (this.renderedState.pendingVariableCount === 0 && oldCount !== 0) {
             setTimeout(() => this.sendMessage(InteractiveWindowMessages.VariablesComplete), 1);
         }
     }
 
     public getState(): IMainState {
-        return this.state;
+        return this.pendingState;
     }
 
     // Adjust the visibility or collapsed state of a cell
@@ -730,37 +799,38 @@ export class MainStateController implements IMessageHandler {
         this.insertCell(cell);
     }
 
-    protected insertCell(cell: ICell, position?: number, isMonaco?: boolean): ICellViewModel | undefined {
-        if (cell) {
-            const showInputs = getSettings().showCellInputCode;
-            const collapseInputs = getSettings().collapseCellInputCodeByDefault;
-            let cellVM: ICellViewModel = createCellVM(cell, getSettings(), this.inputBlockToggled, this.props.defaultEditable);
+    protected prepareCellVM(cell: ICell, isMonaco?: boolean): ICellViewModel {
+        const showInputs = getSettings().showCellInputCode;
+        const collapseInputs = getSettings().collapseCellInputCodeByDefault;
+        let cellVM: ICellViewModel = createCellVM(cell, getSettings(), this.inputBlockToggled, this.props.defaultEditable);
 
-            // Set initial cell visibility and collapse
-            cellVM = this.alterCellVM(cellVM, showInputs, !collapseInputs);
+        // Set initial cell visibility and collapse
+        cellVM = this.alterCellVM(cellVM, showInputs, !collapseInputs);
 
-            if (cellVM) {
-                if (isMonaco) {
-                    cellVM.useQuickEdit = false;
-                }
+        if (isMonaco) {
+            cellVM.useQuickEdit = false;
+        }
 
-                const newList = [...this.state.cellVMs];
-                // Make sure to use the same array so our entire state doesn't update
-                if (position !== undefined && position >= 0) {
-                    newList.splice(position, 0, cellVM);
-                } else {
-                    newList.push(cellVM);
-                }
-                this.setState({
-                    cellVMs: newList,
-                    undoStack: this.pushStack(this.state.undoStack, this.state.cellVMs),
-                    redoStack: this.state.redoStack,
-                    skipNextScroll: false
-                });
+        return cellVM;
+    }
 
-                return cellVM;
-            }
+    protected insertCell(cell: ICell, position?: number, isMonaco?: boolean): ICellViewModel {
+        const cellVM = this.prepareCellVM(cell, isMonaco);
+        const newList = [...this.pendingState.cellVMs];
+        // Make sure to use the same array so our entire state doesn't update
+        if (position !== undefined && position >= 0) {
+            newList.splice(position, 0, cellVM);
+        } else {
+            newList.push(cellVM);
         }
+        this.setState({
+            cellVMs: newList,
+            undoStack: this.pushStack(this.pendingState.undoStack, this.pendingState.cellVMs),
+            redoStack: this.pendingState.redoStack,
+            skipNextScroll: false
+        });
+
+        return cellVM;
     }
 
     protected suspendUpdates() {
@@ -771,7 +841,7 @@ export class MainStateController implements IMessageHandler {
         if (this.suspendUpdateCount > 0) {
             this.suspendUpdateCount -= 1;
             if (this.suspendUpdateCount === 0) {
-                this.setState(this.state); // This should cause an update
+                this.setState(this.pendingState); // This should cause an update
             }
         }
 
@@ -790,6 +860,15 @@ export class MainStateController implements IMessageHandler {
         return [...slicedUndo, copy];
     }
 
+    protected firstCodeCellAbove(cellId: string): string | undefined {
+        const codeCells = this.pendingState.cellVMs.filter(c => c.cell.data.cell_type === 'code');
+        const index = codeCells.findIndex(c => c.cell.id === cellId);
+        if (index > 0) {
+            return codeCells[index - 1].cell.id;
+        }
+        return undefined;
+    }
+
     private computeEditorOptions(): monacoEditor.editor.IEditorOptions {
         const intellisenseOptions = getSettings().intellisenseOptions;
         const extraSettings = getSettings().extraSettings;
@@ -826,12 +905,12 @@ export class MainStateController implements IMessageHandler {
             // Turn off updates so we generate all of the cell vms without rendering.
             this.suspendUpdates();
 
-            // Update all of the vms
+            // Generate all of the VMs
             const cells = payload.cells as ICell[];
-            cells.forEach(c => this.finishCell(c));
+            const vms = cells.map(c => this.prepareCellVM(c, true));
 
             // Set our state to not being busy anymore. Clear undo stack as this can't be undone.
-            this.setState({ busy: false, loadTotal: payload.cells.length, undoStack: [] });
+            this.setState({ busy: false, loadTotal: payload.cells.length, undoStack: [], cellVMs: vms });
 
             // Turn updates back on and resend the state.
             this.resumeUpdates();
@@ -842,15 +921,14 @@ export class MainStateController implements IMessageHandler {
         this.suspendUpdates();
 
         // When we restart, make sure to turn off all executing cells. They aren't executing anymore
-        const executingCells = this.state.cellVMs
+        const executingCells = this.pendingState.cellVMs
             .map((cvm, i) => { return { cvm, i }; })
             .filter(s => s.cvm.cell.state !== CellState.error && s.cvm.cell.state !== CellState.finished);
 
         if (executingCells && executingCells.length) {
-            const newVMs = [...this.state.cellVMs];
+            const newVMs = [...this.pendingState.cellVMs];
             executingCells.forEach(s => {
-                newVMs[s.i] = cloneDeep(s.cvm);
-                newVMs[s.i].cell.state = CellState.finished;
+                newVMs[s.i] = immutable.updateIn(s.cvm, ['cell', 'state'], () => CellState.finished);
             });
             this.setState({ cellVMs: newVMs });
         }
@@ -902,7 +980,7 @@ export class MainStateController implements IMessageHandler {
             // Update theme if necessary
             const newSettings = JSON.parse(payload as string);
             const dsSettings = newSettings as IDataScienceExtraSettings;
-            if (dsSettings && dsSettings.extraSettings && dsSettings.extraSettings.theme !== this.state.theme) {
+            if (dsSettings && dsSettings.extraSettings && dsSettings.extraSettings.theme !== this.pendingState.theme) {
                 // User changed the current theme. Rerender
                 this.postOffice.sendUnsafeMessage(CssMessages.GetCssRequest, { isDark: this.computeKnownDark() });
                 this.postOffice.sendUnsafeMessage(CssMessages.GetMonacoThemeRequest, { isDark: this.computeKnownDark() });
@@ -928,7 +1006,7 @@ export class MainStateController implements IMessageHandler {
 
     private getAllCells = () => {
         // Send all of our cells back to the other side
-        const cells = this.state.cellVMs.map((cellVM: ICellViewModel) => {
+        const cells = this.pendingState.cellVMs.map((cellVM: ICellViewModel) => {
             return cellVM.cell;
         });
 
@@ -936,14 +1014,14 @@ export class MainStateController implements IMessageHandler {
     }
 
     private getNonEditCellVMs(): ICellViewModel[] {
-        return this.state.cellVMs;
+        return this.pendingState.cellVMs;
     }
 
     private clearAllSilent = () => {
         // Update our state
         this.setState({
             cellVMs: [],
-            undoStack: this.pushStack(this.state.undoStack, this.state.cellVMs),
+            undoStack: this.pushStack(this.pendingState.undoStack, this.pendingState.cellVMs),
             skipNextScroll: true,
             busy: false // No more progress on delete all
         });
@@ -951,7 +1029,7 @@ export class MainStateController implements IMessageHandler {
 
     private inputBlockToggled = (id: string) => {
         // Create a shallow copy of the array, let not const as this is the shallow array copy that we will be changing
-        const cellVMArray: ICellViewModel[] = [...this.state.cellVMs];
+        const cellVMArray: ICellViewModel[] = [...this.pendingState.cellVMs];
         const cellVMIndex = cellVMArray.findIndex((value: ICellViewModel) => {
             return value.cell.id === id;
         });
@@ -987,7 +1065,7 @@ export class MainStateController implements IMessageHandler {
     }
 
     private alterAllCellVMs = (visible: boolean, expanded: boolean) => {
-        const newCells = this.state.cellVMs.map((value: ICellViewModel) => {
+        const newCells = this.pendingState.cellVMs.map((value: ICellViewModel) => {
             return this.alterCellVM(value, visible, expanded);
         });
 
@@ -1001,14 +1079,14 @@ export class MainStateController implements IMessageHandler {
         const info: IInteractiveWindowInfo = {
             visibleCells: this.getNonEditCellVMs().map(cvm => cvm.cell),
             cellCount: this.getNonEditCellVMs().length,
-            undoCount: this.state.undoStack.length,
-            redoCount: this.state.redoStack.length
+            undoCount: this.pendingState.undoStack.length,
+            redoCount: this.pendingState.redoStack.length
         };
         this.sendMessage(InteractiveWindowMessages.SendInfo, info);
     }
 
     private updateOrAdd = (cell: ICell, allowAdd?: boolean) => {
-        const index = this.state.cellVMs.findIndex((c: ICellViewModel) => {
+        const index = this.pendingState.cellVMs.findIndex((c: ICellViewModel) => {
             return c.cell.id === cell.id &&
                 c.cell.line === cell.line &&
                 c.cell.file === cell.file;
@@ -1017,9 +1095,9 @@ export class MainStateController implements IMessageHandler {
             // This means the cell existed already so it was actual executed code.
             // Use its execution count to update our execution count.
             const newExecutionCount = cell.data.execution_count ?
-                Math.max(this.state.currentExecutionCount, parseInt(cell.data.execution_count.toString(), 10)) :
-                this.state.currentExecutionCount;
-            if (newExecutionCount !== this.state.currentExecutionCount && this.state.variablesVisible) {
+                Math.max(this.pendingState.currentExecutionCount, parseInt(cell.data.execution_count.toString(), 10)) :
+                this.pendingState.currentExecutionCount;
+            if (newExecutionCount !== this.pendingState.currentExecutionCount && this.pendingState.variablesVisible) {
                 // We also need to update our variable explorer when the execution count changes
                 // Use the ref here to maintain var explorer independence
                 this.refreshVariables(newExecutionCount);
@@ -1027,17 +1105,16 @@ export class MainStateController implements IMessageHandler {
 
             // Have to make a copy of the cell VM array or
             // we won't actually update.
-            const newVMs = [...this.state.cellVMs];
-            newVMs[index] = cloneDeep(newVMs[index]);
+            const newVMs = [...this.pendingState.cellVMs];
 
             // Check to see if our code still matches for the cell (in liveshare it might be updated from the other side)
-            if (concatMultilineString(newVMs[index].cell.data.source) !== concatMultilineString(cell.data.source)) {
+            if (concatMultilineString(this.pendingState.cellVMs[index].cell.data.source) !== concatMultilineString(cell.data.source)) {
                 const newText = extractInputText(cell, getSettings());
-                newVMs[index].inputBlockText = newText;
+                newVMs[index] = { ...newVMs[index], cell: cell, inputBlockText: newText };
+            } else {
+                newVMs[index] = { ...newVMs[index], cell: cell };
             }
 
-            newVMs[index].cell = cell;
-
             this.setState({
                 cellVMs: newVMs,
                 currentExecutionCount: newExecutionCount
@@ -1095,14 +1172,14 @@ export class MainStateController implements IMessageHandler {
             const variable = payload as IJupyterVariable;
 
             // Only send the updated variable data if we are on the same execution count as when we requested it
-            if (variable && variable.executionCount !== undefined && variable.executionCount === this.state.currentExecutionCount) {
-                const stateVariable = this.state.variables.findIndex(v => v.name === variable.name);
+            if (variable && variable.executionCount !== undefined && variable.executionCount === this.pendingState.currentExecutionCount) {
+                const stateVariable = this.pendingState.variables.findIndex(v => v.name === variable.name);
                 if (stateVariable >= 0) {
-                    const newState = [...this.state.variables];
+                    const newState = [...this.pendingState.variables];
                     newState.splice(stateVariable, 1, variable);
                     this.setState({
                         variables: newState,
-                        pendingVariableCount: Math.max(0, this.state.pendingVariableCount - 1)
+                        pendingVariableCount: Math.max(0, this.pendingState.pendingVariableCount - 1)
                     });
                 }
             }
@@ -1116,7 +1193,7 @@ export class MainStateController implements IMessageHandler {
             const variablesResponse = payload as IJupyterVariablesResponse;
 
             // Check to see if we have moved to a new execution count only send our update if we are on the same count as the request
-            if (variablesResponse.executionCount === this.state.currentExecutionCount) {
+            if (variablesResponse.executionCount === this.pendingState.currentExecutionCount) {
                 this.setState({
                     variables: variablesResponse.variables,
                     pendingVariableCount: variablesResponse.variables.length
@@ -1182,7 +1259,7 @@ export class MainStateController implements IMessageHandler {
             // We also get this in our response, but computing is more reliable
             // than searching for it.
 
-            if (this.state.knownDark !== computedKnownDark) {
+            if (this.pendingState.knownDark !== computedKnownDark) {
                 this.darkChanged(computedKnownDark);
             }
 
diff --git a/src/datascience-ui/interactive-common/markdown.tsx b/src/datascience-ui/interactive-common/markdown.tsx
index 708a0c920ff7..7e7f5daf617f 100644
--- a/src/datascience-ui/interactive-common/markdown.tsx
+++ b/src/datascience-ui/interactive-common/markdown.tsx
@@ -36,7 +36,10 @@ export class Markdown extends React.Component<IMarkdownProps> {
     }
 
     public render() {
+        const classes = 'markdown-editor-area';
+
         return (
+            <div className={classes}>
                 <Editor
                     codeTheme={this.props.codeTheme}
                     autoFocus={this.props.autoFocus}
@@ -60,6 +63,7 @@ export class Markdown extends React.Component<IMarkdownProps> {
                     useQuickEdit={this.props.useQuickEdit}
                     font={this.props.font}
                 />
+            </div>
         );
     }
 
diff --git a/src/datascience-ui/native-editor/nativeCell.tsx b/src/datascience-ui/native-editor/nativeCell.tsx
index eed7222c1cc4..75c6cc58ad7b 100644
--- a/src/datascience-ui/native-editor/nativeCell.tsx
+++ b/src/datascience-ui/native-editor/nativeCell.tsx
@@ -4,6 +4,7 @@
 import '../../client/common/extensions';
 
 import { nbformat } from '@jupyterlab/coreutils';
+import * as fastDeepEqual from 'fast-deep-equal';
 import * as React from 'react';
 
 import { concatMultilineString } from '../../client/datascience/common';
@@ -32,20 +33,14 @@ interface INativeCellProps {
     maxTextSize?: number;
     stateController: NativeEditorStateController;
     monacoTheme: string | undefined;
-    hideOutput?: boolean;
-    showLineNumbers?: boolean;
-    selectedCell?: string;
-    focusedCell?: string;
+    lastCell: boolean;
     font: IFont;
     focusCell(cellId: string, focusCode: boolean): void;
     selectCell(cellId: string): void;
 }
 
-interface INativeCellState {
-    showingMarkdownEditor: boolean;
-}
 // tslint:disable: react-this-binding-issue
-export class NativeCell extends React.Component<INativeCellProps, INativeCellState> {
+export class NativeCell extends React.Component<INativeCellProps> {
     private inputRef: React.RefObject<CellInput> = React.createRef<CellInput>();
     private wrapperRef: React.RefObject<HTMLDivElement> = React.createRef<HTMLDivElement>();
     private lastKeyPressed: string | undefined;
@@ -53,7 +48,6 @@ export class NativeCell extends React.Component<INativeCellProps, INativeCellSta
 
     constructor(prop: INativeCellProps) {
         super(prop);
-        this.state = { showingMarkdownEditor: false };
     }
 
     public render() {
@@ -65,14 +59,18 @@ export class NativeCell extends React.Component<INativeCellProps, INativeCellSta
     }
 
     public componentDidUpdate(prevProps: INativeCellProps) {
-        if (this.props.selectedCell === this.props.cellVM.cell.id && prevProps.selectedCell !== this.props.selectedCell) {
-            this.giveFocus(this.props.focusedCell === this.props.cellVM.cell.id);
+        if (this.props.cellVM.selected && !prevProps.cellVM.selected) {
+            this.giveFocus(this.props.cellVM.focused);
         }
 
         // Anytime we update, reset the key. This object will be reused for different cell ids
         this.lastKeyPressed = undefined;
     }
 
+    public shouldComponentUpdate(nextProps: INativeCellProps): boolean {
+        return !fastDeepEqual(this.props, nextProps);
+    }
+
     public giveFocus(giveCodeFocus: boolean) {
         // Start out with ourselves
         if (this.wrapperRef && this.wrapperRef.current) {
@@ -83,9 +81,6 @@ export class NativeCell extends React.Component<INativeCellProps, INativeCellSta
             if (this.inputRef && this.inputRef.current) {
                 this.inputRef.current.giveFocus();
             }
-            if (this.isMarkdownCell()) {
-                this.setState({showingMarkdownEditor: true});
-            }
         }
     }
 
@@ -131,11 +126,11 @@ export class NativeCell extends React.Component<INativeCellProps, INativeCellSta
     }
 
     private isSelected = () => {
-        return this.props.selectedCell === this.cellId;
+        return this.props.cellVM.selected;
     }
 
     private isFocused = () => {
-        return this.props.focusedCell === this.cellId;
+        return this.props.cellVM.focused;
     }
 
     private renderNormalCell() {
@@ -149,7 +144,7 @@ export class NativeCell extends React.Component<INativeCellProps, INativeCellSta
         }
 
         // Content changes based on if a markdown cell or not.
-        const content = this.isMarkdownCell() && !this.state.showingMarkdownEditor ?
+        const content = this.isMarkdownCell() && !this.isShowingMarkdownEditor() ?
             <div className='cell-result-container'>
                 <div className='cell-row-container'>
                     {this.renderCollapseBar(false)}
@@ -185,11 +180,16 @@ export class NativeCell extends React.Component<INativeCellProps, INativeCellSta
     }
 
     private onMouseClick = (ev: React.MouseEvent<HTMLDivElement>) => {
-        // When we receive a click, propagate upwards. Might change our state
-        ev.stopPropagation();
-        this.lastKeyPressed = undefined;
-        const focusedCell = this.isFocused() ? this.cellId : undefined;
-        this.props.stateController.selectCell(this.cellId, focusedCell);
+        if (ev.nativeEvent.target) {
+            const elem = ev.nativeEvent.target as HTMLElement;
+            if (!elem.className.includes('image-button')) {
+                // Not a click on an button in a toolbar, select the cell.
+                ev.stopPropagation();
+                this.lastKeyPressed = undefined;
+                const focusedCell = this.isFocused() ? this.cellId : undefined;
+                this.props.stateController.selectCell(this.cellId, focusedCell);
+            }
+        }
     }
 
     private onMouseDoubleClick = (ev: React.MouseEvent<HTMLDivElement>) => {
@@ -203,7 +203,11 @@ export class NativeCell extends React.Component<INativeCellProps, INativeCellSta
     }
 
     private shouldRenderMarkdownEditor = () : boolean => {
-        return (this.isMarkdownCell() && (this.state.showingMarkdownEditor || this.props.cellVM.cell.id === Identifiers.EditCellId));
+        return (this.isMarkdownCell() && (this.isShowingMarkdownEditor() || this.props.cellVM.cell.id === Identifiers.EditCellId));
+    }
+
+    private isShowingMarkdownEditor = (): boolean => {
+        return (this.isMarkdownCell() && this.props.cellVM.focused);
     }
 
     private shouldRenderInput(): boolean {
@@ -221,9 +225,9 @@ export class NativeCell extends React.Component<INativeCellProps, INativeCellSta
     private shouldRenderOutput(): boolean {
         if (this.isCodeCell()) {
             const cell = this.getCodeCell();
-            return this.hasOutput() && cell.outputs && !this.props.hideOutput && (Array.isArray(cell.outputs) && cell.outputs.length !== 0);
+            return this.hasOutput() && cell.outputs && !this.props.cellVM.hideOutput && (Array.isArray(cell.outputs) && cell.outputs.length !== 0);
         } else if (this.isMarkdownCell()) {
-            return !this.state.showingMarkdownEditor;
+            return !this.isShowingMarkdownEditor();
         }
         return false;
     }
@@ -292,12 +296,8 @@ export class NativeCell extends React.Component<INativeCellProps, INativeCellSta
                 if (this.lastKeyPressed === 'd' && !this.isFocused()  && this.isSelected()) {
                     e.stopPropagation();
                     this.lastKeyPressed = undefined; // Reset it so we don't keep deleting
-                    const cellToSelect = this.getPrevCellId() || this.getNextCellId();
                     this.props.stateController.possiblyDeleteCell(cellId);
                     this.props.stateController.sendCommand(NativeCommandType.DeleteCell, 'keyboard');
-                    if (cellToSelect) {
-                        this.moveSelection(cellToSelect);
-                    }
                 }
                 break;
             case 'a':
@@ -504,7 +504,7 @@ export class NativeCell extends React.Component<INativeCellProps, INativeCellSta
         };
         const canMoveUp = this.props.stateController.canMoveUp(cellId);
         const canMoveDown = this.props.stateController.canMoveDown(cellId);
-        const addButtonRender = this.getNextCellId() !== undefined ?
+        const addButtonRender = !this.props.lastCell ?
             <div className='navbar-add-button'>
                 <ImageButton baseTheme={this.props.baseTheme} onClick={this.addNewCell} tooltip={getLocString('DataScience.insertBelow', 'Insert cell below')}>
                     <Image baseTheme={this.props.baseTheme} class='image-button-image' image={ImageName.InsertBelow} />
@@ -545,14 +545,8 @@ export class NativeCell extends React.Component<INativeCellProps, INativeCellSta
     private renderMiddleToolbar = () => {
         const cellId = this.props.cellVM.cell.id;
         const deleteCell = () => {
-            const cellToSelect = this.getNextCellId() || this.getPrevCellId();
             this.props.stateController.possiblyDeleteCell(cellId);
             this.props.stateController.sendCommand(NativeCommandType.DeleteCell, 'mouse');
-            setTimeout(() => {
-                if (cellToSelect) {
-                    this.moveSelection(cellToSelect);
-                }
-            }, 10);
         };
         const runAbove = () => {
             this.props.stateController.runAbove(cellId);
@@ -582,7 +576,7 @@ export class NativeCell extends React.Component<INativeCellProps, INativeCellSta
 
             // This is special. Coming in on a mouse down event so we get
             // called before focus changes. After focus changes, then switch to code
-            if (this.state.showingMarkdownEditor) {
+            if (this.isShowingMarkdownEditor()) {
                 this.pendingFocusLoss = handler;
             } else {
                 handler();
@@ -657,7 +651,7 @@ export class NativeCell extends React.Component<INativeCellProps, INativeCellSta
                     focused={this.isCodeCell() ? this.onCodeFocused : this.onMarkdownFocused}
                     unfocused={this.isCodeCell() ? this.onCodeUnfocused : this.onMarkdownUnfocused}
                     keyDown={this.keyDownInput}
-                    showLineNumbers={this.props.showLineNumbers}
+                    showLineNumbers={this.props.cellVM.showLineNumbers}
                     font={this.props.font}
                 />
             );
@@ -678,8 +672,6 @@ export class NativeCell extends React.Component<INativeCellProps, INativeCellSta
     }
 
     private onMarkdownUnfocused = () => {
-        this.props.stateController.codeLostFocus(this.cellId);
-
         // There might be a pending focus loss handler.
         if (this.pendingFocusLoss) {
             const func = this.pendingFocusLoss;
@@ -687,10 +679,7 @@ export class NativeCell extends React.Component<INativeCellProps, INativeCellSta
             func();
         }
 
-        // Indicate not showing the editor anymore. The equivalent of this
-        // is not when we receive focus but when we GIVE focus to the markdown editor
-        // otherwise we wouldn't be able to display it.
-        this.setState({showingMarkdownEditor: false});
+        this.props.stateController.codeLostFocus(this.cellId);
     }
 
     private renderOutput = (): JSX.Element | null => {
@@ -728,10 +717,10 @@ export class NativeCell extends React.Component<INativeCellProps, INativeCellSta
     private renderCollapseBar = (input: boolean) => {
         let classes = 'collapse-bar';
 
-        if (this.props.selectedCell === this.props.cellVM.cell.id && this.props.focusedCell !== this.props.cellVM.cell.id) {
+        if (this.isSelected() && !this.isFocused()) {
             classes += ' collapse-bar-selected';
         }
-        if (this.props.focusedCell === this.props.cellVM.cell.id) {
+        if (this.isFocused()) {
             classes += ' collapse-bar-focused';
         }
 
diff --git a/src/datascience-ui/native-editor/nativeEditor.less b/src/datascience-ui/native-editor/nativeEditor.less
index a5a3f8d8e96c..80c7bbb55ea3 100644
--- a/src/datascience-ui/native-editor/nativeEditor.less
+++ b/src/datascience-ui/native-editor/nativeEditor.less
@@ -115,6 +115,16 @@
     background: var(--override-widget-background, var(--vscode-notifications-background));
 }
 
+.markdown-editor-area {
+    position: relative;
+    width:100%;
+    padding-right: 10px;
+    margin-bottom: 0px;
+    padding-left: 2px;
+    padding-top: 2px;
+    background: var(--override-widget-background, var(--vscode-notifications-background));
+}
+
 .code-watermark {
     top: 5px; /* Account for extra padding and border in native editor */
 }
diff --git a/src/datascience-ui/native-editor/nativeEditor.tsx b/src/datascience-ui/native-editor/nativeEditor.tsx
index 204046809856..21c99415bd3d 100644
--- a/src/datascience-ui/native-editor/nativeEditor.tsx
+++ b/src/datascience-ui/native-editor/nativeEditor.tsx
@@ -24,8 +24,6 @@ import { NativeEditorStateController } from './nativeEditorStateController';
 // tslint:disable: react-this-binding-issue
 // tslint:disable-next-line:no-require-imports no-var-requires
 const debounce = require('lodash/debounce') as typeof import('lodash/debounce');
-// tslint:disable-next-line: no-require-imports
-import cloneDeep = require('lodash/cloneDeep');
 
 interface INativeEditorProps {
     skipDefault: boolean;
@@ -149,7 +147,7 @@ export class NativeEditor extends React.Component<INativeEditorProps, IMainState
     private moveSelectionToExisting = (cellId: string) => {
         // Cell should already exist in the UI
         if (this.contentPanelRef) {
-            const wasFocused = this.state.focusedCell !== undefined;
+            const wasFocused = this.state.focusedCellId !== undefined;
             this.stateController.selectCell(cellId, wasFocused ? cellId : undefined);
             this.focusCell(cellId, wasFocused ? true : false);
         }
@@ -161,7 +159,7 @@ export class NativeEditor extends React.Component<INativeEditorProps, IMainState
         if (cells.find(c => c.id === id)) {
             // Force selection change right now as we don't need the cell to exist
             // to make it selected (otherwise we'll get a flash)
-            const wasFocused = this.state.focusedCell !== undefined;
+            const wasFocused = this.state.focusedCellId !== undefined;
             this.stateController.selectCell(id, wasFocused ? id : undefined);
 
             // Then wait to give it actual input focus
@@ -297,8 +295,7 @@ export class NativeEditor extends React.Component<INativeEditorProps, IMainState
                         } else if (bottom < visibleTop) {
                             continue;
                         } else {
-                            cellVMs[i] = cloneDeep(cellVM);
-                            cellVMs[i].useQuickEdit = false;
+                            cellVMs[i] = {...cellVM, useQuickEdit: false };
                             makeChange = true;
                         }
                     }
@@ -400,12 +397,9 @@ export class NativeEditor extends React.Component<INativeEditorProps, IMainState
                         baseTheme={this.props.baseTheme}
                         codeTheme={this.props.codeTheme}
                         monacoTheme={this.state.monacoTheme}
-                        showLineNumbers={cellVM.showLineNumbers}
-                        selectedCell={this.state.selectedCell}
-                        focusedCell={this.state.focusedCell}
-                        hideOutput={cellVM.hideOutput}
                         focusCell={this.focusCell}
                         selectCell={this.selectCell}
+                        lastCell={lastLine !== null}
                         font={this.state.font}
                     />
                 </ErrorBoundary>
@@ -414,6 +408,7 @@ export class NativeEditor extends React.Component<INativeEditorProps, IMainState
     }
 
     private focusCell = (cellId: string, focusCode: boolean): void => {
+        this.stateController.selectCell(cellId, focusCode ? cellId : undefined);
         const ref = this.cellRefs.get(cellId);
         if (ref && ref.current) {
             ref.current.giveFocus(focusCode);
@@ -421,8 +416,8 @@ export class NativeEditor extends React.Component<INativeEditorProps, IMainState
     }
 
     private scrollDiv = (_div: HTMLDivElement) => {
-        if (this.state.newCell) {
-            const newCell = this.state.newCell;
+        if (this.state.newCellId) {
+            const newCell = this.state.newCellId;
             this.stateController.setState({newCell: undefined});
             // Bounce this so state has time to update.
             setTimeout(() => {
diff --git a/src/datascience-ui/native-editor/nativeEditorStateController.ts b/src/datascience-ui/native-editor/nativeEditorStateController.ts
index 94c685b9d182..80433cf6dfee 100644
--- a/src/datascience-ui/native-editor/nativeEditorStateController.ts
+++ b/src/datascience-ui/native-editor/nativeEditorStateController.ts
@@ -87,12 +87,13 @@ export class NativeEditorStateController extends MainStateController {
 
     public addNewCell = (): ICellViewModel | undefined => {
         const cells = this.getState().cellVMs;
-        const selectedCell = this.getState().selectedCell;
+        const selectedCell = this.getState().selectedCellId;
         this.suspendUpdates();
         const id = uuid();
-        const pos = selectedCell ? cells.findIndex(cvm => cvm.cell.id === this.getState().selectedCell) + 1 : cells.length;
+        const pos = selectedCell ? cells.findIndex(cvm => cvm.cell.id === this.getState().selectedCellId) + 1 : cells.length;
         this.setState({ newCell: id });
         const vm = this.insertCell(createEmptyCell(id, null), pos);
+        this.sendMessage(InteractiveWindowMessages.InsertCell, { id, code: '', codeCellAbove: this.firstCodeCellAbove(id) });
         if (vm) {
             // Make sure the new cell is monaco
             vm.useQuickEdit = false;
@@ -112,7 +113,9 @@ export class NativeEditorStateController extends MainStateController {
                 inputBlockShow: true,
                 inputBlockText: '',
                 inputBlockCollapseNeeded: false,
-                inputBlockToggled: noop
+                inputBlockToggled: noop,
+                selected: cells[0].selected,
+                focused: cells[0].focused
             };
             this.setState({ cellVMs: [newVM], undoStack: this.pushStack(this.getState().undoStack, cells) });
         } else {
@@ -151,6 +154,7 @@ export class NativeEditorStateController extends MainStateController {
             const id = uuid();
             this.setState({ newCell: id });
             this.insertCell(createEmptyCell(id, null), index, isMonaco);
+            this.sendMessage(InteractiveWindowMessages.InsertCell, { id, code: '', codeCellAbove: this.firstCodeCellAbove(id) });
             this.resumeUpdates();
             return id;
         }
@@ -164,6 +168,7 @@ export class NativeEditorStateController extends MainStateController {
             const id = uuid();
             this.setState({ newCell: id });
             this.insertCell(createEmptyCell(id, null), index + 1, isMonaco);
+            this.sendMessage(InteractiveWindowMessages.InsertCell, { id, code: '', codeCellAbove: this.firstCodeCellAbove(id) });
             this.resumeUpdates();
             return id;
         }
@@ -179,6 +184,7 @@ export class NativeEditorStateController extends MainStateController {
                 cellVMs: cellVms,
                 undoStack: this.pushStack(this.getState().undoStack, origVms)
             });
+            this.sendMessage(InteractiveWindowMessages.SwapCells, { firstCellId: cellId!, secondCellId: cellVms[index].cell.id });
         }
     }
 
@@ -192,6 +198,7 @@ export class NativeEditorStateController extends MainStateController {
                 cellVMs: cellVms,
                 undoStack: this.pushStack(this.getState().undoStack, origVms)
             });
+            this.sendMessage(InteractiveWindowMessages.SwapCells, { firstCellId: cellId!, secondCellId: cellVms[index].cell.id });
         }
     }
 
diff --git a/src/datascience-ui/react-common/monacoEditor.tsx b/src/datascience-ui/react-common/monacoEditor.tsx
index 6117fde784d7..28430bc99677 100644
--- a/src/datascience-ui/react-common/monacoEditor.tsx
+++ b/src/datascience-ui/react-common/monacoEditor.tsx
@@ -37,7 +37,8 @@ interface IMonacoEditorState {
     editor?: monacoEditor.editor.IStandaloneCodeEditor;
     model: monacoEditor.editor.ITextModel | null;
     visibleLineCount: number;
-    attached: boolean;
+    attached: boolean; // Keeps track of when we reparent the editor out of the dummy dom node.
+    widgetsReparented: boolean; // Keeps track of when we reparent the hover widgets so they work inside something with overflow
 }
 
 // Need this to prevent wiping of the current value on a componentUpdate. react-monaco-editor has that problem.
@@ -61,7 +62,7 @@ export class MonacoEditor extends React.Component<IMonacoEditorProps, IMonacoEdi
 
     constructor(props: IMonacoEditorProps) {
         super(props);
-        this.state = { editor: undefined, model: null, visibleLineCount: -1, attached: false };
+        this.state = { editor: undefined, model: null, visibleLineCount: -1, attached: false, widgetsReparented: false };
         this.containerRef = React.createRef<HTMLDivElement>();
         this.measureWidthRef = React.createRef<HTMLDivElement>();
         this.debouncedUpdateEditorSize = debounce(this.updateEditorSize.bind(this), 150);
@@ -156,6 +157,12 @@ export class MonacoEditor extends React.Component<IMonacoEditorProps, IMonacoEdi
                 }
             }));
 
+            // Track focus changes to make sure we update our widget parent and widget position
+            this.subscriptions.push(editor.onDidFocusEditorWidget(() => {
+                this.throttledUpdateWidgetPosition();
+                this.updateWidgetParent(editor);
+            }));
+
             // Update our margin to include the correct line number style
             this.updateMargin(editor);
 
@@ -376,19 +383,25 @@ export class MonacoEditor extends React.Component<IMonacoEditorProps, IMonacoEdi
                 // Make sure to attach to a real dom node.
                 if (!this.state.attached && this.state.editor && this.monacoContainer) {
                     this.containerRef.current.appendChild(this.monacoContainer);
-
-                    // Make sure our suggest and hover windows show up on top of other stuff
-                    this.updateWidgetParent(this.state.editor);
+                    this.monacoContainer.addEventListener('mousemove', this.onContainerMove);
                 }
                 this.setState({visibleLineCount: currLineCount, attached: true});
                 this.state.editor.layout({width, height});
-
-                // Also need to update our widget positions
-                this.throttledUpdateWidgetPosition(width);
             }
         }
     }
 
+    private onContainerMove = () => {
+        if (!this.widgetParent && !this.state.widgetsReparented && this.monacoContainer) {
+            // Only need to do this once, but update the widget parents and move them.
+            this.updateWidgetParent(this.state.editor);
+            this.startUpdateWidgetPosition();
+
+            // Since only doing this once, remove the listener.
+            this.monacoContainer.removeEventListener('mousemove', this.onContainerMove);
+        }
+    }
+
     private onHoverLeave = () => {
         // If the hover is active, make sure to hide it.
         if (this.state.editor && this.widgetParent) {
@@ -452,14 +465,15 @@ export class MonacoEditor extends React.Component<IMonacoEditorProps, IMonacoEdi
         }
     }
 
-    private updateWidgetParent(editor: monacoEditor.editor.IStandaloneCodeEditor) {
+    private updateWidgetParent(editor: monacoEditor.editor.IStandaloneCodeEditor | undefined) {
         // Reparent the hover widgets. They cannot be inside anything that has overflow hidden or scrolling or they won't show
         // up overtop of anything. Warning, this is a big hack. If the class name changes or the logic
         // for figuring out the position of hover widgets changes, this won't work anymore.
         // appendChild on a DOM node moves it, but doesn't clone it.
         // https://developer.mozilla.org/en-US/docs/Web/API/Node/appendChild
-        const editorNode = editor.getDomNode();
-        if (editorNode) {
+        const editorNode = editor ? editor.getDomNode() : undefined;
+        if (editor && editorNode && !this.state.widgetsReparented) {
+            this.setState({widgetsReparented: true});
             try {
                 const elements = editorNode.getElementsByClassName('overflowingContentWidgets');
                 if (elements && elements.length) {
diff --git a/src/test/datascience/intellisense.unit.test.ts b/src/test/datascience/intellisense.unit.test.ts
index 1361f948612f..51d5418d7db7 100644
--- a/src/test/datascience/intellisense.unit.test.ts
+++ b/src/test/datascience/intellisense.unit.test.ts
@@ -18,11 +18,30 @@ import {
     IInteractiveWindowMapping,
     InteractiveWindowMessages
 } from '../../client/datascience/interactive-common/interactiveWindowTypes';
-import { IInteractiveWindowListener, IInteractiveWindowProvider, IJupyterExecution } from '../../client/datascience/types';
+import {
+    ICell,
+    IInteractiveWindowListener,
+    IInteractiveWindowProvider,
+    IJupyterExecution
+} from '../../client/datascience/types';
+import { generateCells } from '../../datascience-ui/interactive-common/mainState';
 import { MockAutoSelectionService } from '../mocks/autoSelector';
 import { MockLanguageClient } from './mockLanguageClient';
 
 // tslint:disable:no-any unified-signatures
+const TestCellContents = `myvar = """ # Lorem Ipsum
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit.
+Nullam eget varius ligula, eget fermentum mauris.
+Cras ultrices, enim sit amet iaculis ornare, nisl nibh aliquet elit, sed ultrices velit ipsum dignissim nisl.
+Nunc quis orci ante. Vivamus vel blandit velit.
+","Sed mattis dui diam, et blandit augue mattis vestibulum.
+Suspendisse ornare interdum velit. Suspendisse potenti.
+Morbi molestie lacinia sapien nec porttitor. Nam at vestibulum nisi.
+"""
+df
+df
+`;
 
 // tslint:disable-next-line: max-func-body-length
 suite('DataScience Intellisense Unit Tests', () => {
@@ -133,13 +152,23 @@ suite('DataScience Intellisense Unit Tests', () => {
     }
 
     function removeCell(id: string): Promise<void> {
-        sendMessage(InteractiveWindowMessages.RemoveCell, { id }).ignoreErrors();
-        return Promise.resolve();
+        return sendMessage(InteractiveWindowMessages.RemoveCell, { id });
     }
 
     function removeAllCells(): Promise<void> {
-        sendMessage(InteractiveWindowMessages.DeleteAllCells).ignoreErrors();
-        return Promise.resolve();
+        return sendMessage(InteractiveWindowMessages.DeleteAllCells);
+    }
+
+    function swapCells(id1: string, id2: string): Promise<void> {
+        return sendMessage(InteractiveWindowMessages.SwapCells, { firstCellId: id1, secondCellId: id2 });
+    }
+
+    function insertCell(id: string, code: string, codeCellAbove?: string): Promise<void> {
+        return sendMessage(InteractiveWindowMessages.InsertCell, { id, code, codeCellAbove });
+    }
+
+    function loadAllCells(cells: ICell[]): Promise<void> {
+        return sendMessage(InteractiveWindowMessages.LoadAllCellsComplete, { cells });
     }
 
     test('Add a single cell', async () => {
@@ -288,4 +317,98 @@ suite('DataScience Intellisense Unit Tests', () => {
         await addCell('import baz', '3');
         expect(languageClient.getDocumentContents()).to.be.eq('import sys\nimport foo\nimport bar\nimport baz\nsys', 'Document not set');
     });
+
+    test('Load remove and insert', async () => {
+        const cells = generateCells('foo.py', 1);
+        await loadAllCells(cells);
+        expect(languageClient.getDocumentContents()).to.be.eq(TestCellContents, 'Load all cells is failing');
+        await removeAllCells();
+        expect(languageClient.getDocumentContents()).to.be.eq('', 'Remove all cells is failing');
+        await insertCell('6', 'foo');
+        expect(languageClient.getDocumentContents()).to.be.eq('foo\n', 'Insert after remove');
+        await insertCell('7', 'bar', '6');
+        expect(languageClient.getDocumentContents()).to.be.eq('foo\nbar\n', 'Double insert after remove');
+    });
+
+    test('Swap cells around', async () => {
+        const cells = generateCells('foo.py', 1);
+        await loadAllCells(cells);
+        await swapCells('1', '2'); // 2nd cell is markdown
+        expect(languageClient.getDocumentContents()).to.be.eq(TestCellContents, 'Swap cells should skip swapping on markdown');
+        await swapCells('1', '3');
+        const afterSwap = `df
+myvar = """ # Lorem Ipsum
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit.
+Nullam eget varius ligula, eget fermentum mauris.
+Cras ultrices, enim sit amet iaculis ornare, nisl nibh aliquet elit, sed ultrices velit ipsum dignissim nisl.
+Nunc quis orci ante. Vivamus vel blandit velit.
+","Sed mattis dui diam, et blandit augue mattis vestibulum.
+Suspendisse ornare interdum velit. Suspendisse potenti.
+Morbi molestie lacinia sapien nec porttitor. Nam at vestibulum nisi.
+"""
+df
+`;
+        expect(languageClient.getDocumentContents()).to.be.eq(afterSwap, 'Swap cells failed');
+        await swapCells('1', '3');
+        expect(languageClient.getDocumentContents()).to.be.eq(TestCellContents, 'Swap cells back failed');
+    });
+
+    test('Insert and swap', async () => {
+        const cells = generateCells('foo.py', 1);
+        await loadAllCells(cells);
+        expect(languageClient.getDocumentContents()).to.be.eq(TestCellContents, 'Load all cells is failing');
+        await insertCell('6', 'foo');
+        const afterInsert = `foo
+myvar = """ # Lorem Ipsum
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit.
+Nullam eget varius ligula, eget fermentum mauris.
+Cras ultrices, enim sit amet iaculis ornare, nisl nibh aliquet elit, sed ultrices velit ipsum dignissim nisl.
+Nunc quis orci ante. Vivamus vel blandit velit.
+","Sed mattis dui diam, et blandit augue mattis vestibulum.
+Suspendisse ornare interdum velit. Suspendisse potenti.
+Morbi molestie lacinia sapien nec porttitor. Nam at vestibulum nisi.
+"""
+df
+df
+`;
+        expect(languageClient.getDocumentContents()).to.be.eq(afterInsert, 'Insert cell failed');
+        await insertCell('7', 'foo', '1');
+        const afterInsert2 = `foo
+myvar = """ # Lorem Ipsum
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit.
+Nullam eget varius ligula, eget fermentum mauris.
+Cras ultrices, enim sit amet iaculis ornare, nisl nibh aliquet elit, sed ultrices velit ipsum dignissim nisl.
+Nunc quis orci ante. Vivamus vel blandit velit.
+","Sed mattis dui diam, et blandit augue mattis vestibulum.
+Suspendisse ornare interdum velit. Suspendisse potenti.
+Morbi molestie lacinia sapien nec porttitor. Nam at vestibulum nisi.
+"""
+foo
+df
+df
+`;
+        expect(languageClient.getDocumentContents()).to.be.eq(afterInsert2, 'Insert2 cell failed');
+        await removeCell('7');
+        expect(languageClient.getDocumentContents()).to.be.eq(afterInsert, 'Remove 2 cell failed');
+        await swapCells('1', '3');
+        const afterSwap = `foo
+df
+myvar = """ # Lorem Ipsum
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit.
+Nullam eget varius ligula, eget fermentum mauris.
+Cras ultrices, enim sit amet iaculis ornare, nisl nibh aliquet elit, sed ultrices velit ipsum dignissim nisl.
+Nunc quis orci ante. Vivamus vel blandit velit.
+","Sed mattis dui diam, et blandit augue mattis vestibulum.
+Suspendisse ornare interdum velit. Suspendisse potenti.
+Morbi molestie lacinia sapien nec porttitor. Nam at vestibulum nisi.
+"""
+df
+`;
+        expect(languageClient.getDocumentContents()).to.be.eq(afterSwap, 'Swap cell failed');
+    });
+
 });
diff --git a/src/test/datascience/nativeEditor.functional.test.tsx b/src/test/datascience/nativeEditor.functional.test.tsx
index b2eb2bb71053..ddb2a1284e2d 100644
--- a/src/test/datascience/nativeEditor.functional.test.tsx
+++ b/src/test/datascience/nativeEditor.functional.test.tsx
@@ -118,16 +118,16 @@ for _ in range(50):
             return Promise.resolve({ result: result, haveMore: loops > 0 });
         });
 
-        await addCell(wrapper, badPanda, true, 4);
+        await addCell(wrapper, badPanda, true);
         verifyHtmlOnCell(wrapper, 'NativeCell', `has no attribute 'read'`, CellPosition.Last);
 
-        await addCell(wrapper, goodPanda, true, 4);
+        await addCell(wrapper, goodPanda, true);
         verifyHtmlOnCell(wrapper, 'NativeCell', `<td>`, CellPosition.Last);
 
-        await addCell(wrapper, matPlotLib, true, 5);
+        await addCell(wrapper, matPlotLib, true, 6);
         verifyHtmlOnCell(wrapper, 'NativeCell', matPlotLibResults, CellPosition.Last);
 
-        await addCell(wrapper, spinningCursor, true, 3 + (ioc.mockJupyter ? (cursors.length * 3) : 50));
+        await addCell(wrapper, spinningCursor, true, 4 + (ioc.mockJupyter ? (cursors.length * 3) : 50));
         verifyHtmlOnCell(wrapper, 'NativeCell', '<div>', CellPosition.Last);
     }, () => { return ioc; });
 

From f110ca3e9801a41e6e20a2ad77c80843c10012d5 Mon Sep 17 00:00:00 2001
From: Rich Chiodo <rchiodo@users.noreply.github.com>
Date: Mon, 7 Oct 2019 12:33:52 -0700
Subject: [PATCH 10/36] Change the default cell marker (#7782)

* Change the default cell marker

* Fix test failures
Fix gather to use new comment
Fix formatting on code comments from nls

* Fix unit test too

* Fix gather to replace #%%
---
 news/2 Fixes/7674.md                          |  2 ++
 package.json                                  |  6 ++++++
 package.nls.json                              |  4 ++--
 package.nls.nl.json                           |  2 +-
 snippets/python.json                          |  4 ++--
 src/client/common/types.ts                    |  1 +
 src/client/common/utils/localize.ts           |  4 ++--
 src/client/datascience/constants.ts           |  3 ++-
 .../editor-integration/codewatcher.ts         | 16 +++++++++++-----
 src/client/datascience/gather/gather.ts       |  7 ++++++-
 .../interactive-common/interactiveBase.ts     |  7 ++++---
 .../datascience/jupyter/jupyterImporter.ts    | 19 ++++++++++++-------
 .../datascience/gather/gather.unit.test.ts    |  4 +++-
 .../interactiveWindow.functional.test.tsx     | 13 +++++++------
 .../manualTestFiles/manualTestFile.py         |  8 ++++----
 15 files changed, 65 insertions(+), 35 deletions(-)
 create mode 100644 news/2 Fixes/7674.md

diff --git a/news/2 Fixes/7674.md b/news/2 Fixes/7674.md
new file mode 100644
index 000000000000..69467e4d436b
--- /dev/null
+++ b/news/2 Fixes/7674.md	
@@ -0,0 +1,2 @@
+Change the default cell marker to '# %%' instead of '#%%' to prevent linter errors in python files with markers.
+Also added a new setting to change this - 'python.dataScience.defaultCellMarker'.
diff --git a/package.json b/package.json
index 4e940cda4ee4..b153d3754bf2 100644
--- a/package.json
+++ b/package.json
@@ -1557,6 +1557,12 @@
                     "description": "Regular expression used to identify code cells. All code until the next match is considered part of this cell. \nDefaults to '^(#\\s*%%|#\\s*\\<codecell\\>|#\\s*In\\[\\d*?\\]|#\\s*In\\[ \\])' if left blank",
                     "scope": "resource"
                 },
+                "python.dataScience.defaultCellMarker": {
+                    "type": "string",
+                    "default": "# %%",
+                    "description": "Cell marker used for delineating a cell in a python file.",
+                    "scope": "resource"
+                },
                 "python.dataScience.markdownRegularExpression": {
                     "type": "string",
                     "default": "^(#\\s*%%\\s*\\[markdown\\]|#\\s*\\<markdowncell\\>)",
diff --git a/package.nls.json b/package.nls.json
index 1c70d070fa5c..dff61841145d 100644
--- a/package.nls.json
+++ b/package.nls.json
@@ -217,7 +217,7 @@
     "DataScience.exportingFormat": "Exporting {0}",
     "DataScience.exportCancel": "Cancel",
     "Common.canceled": "Canceled",
-    "DataScience.importChangeDirectoryComment": "#%% Change working directory from the workspace root to the ipynb file location. Turn this addition off with the DataScience.changeDirOnImportExport setting",
+    "DataScience.importChangeDirectoryComment": "{0} Change working directory from the workspace root to the ipynb file location. Turn this addition off with the DataScience.changeDirOnImportExport setting",
     "DataScience.exportChangeDirectoryComment": "# Change directory to VSCode workspace root so that relative path loads work correctly. Turn this addition off with the DataScience.changeDirOnImportExport setting",
     "DataScience.interruptKernelStatus": "Interrupting IPython Kernel",
     "DataScience.restartKernelAfterInterruptMessage": "Interrupting the kernel timed out. Do you want to restart the kernel instead? All variables will be lost.",
@@ -339,7 +339,7 @@
     "DataScience.jupyterDebuggerInstallPtvsdYes": "Yes",
     "DataScience.jupyterDebuggerInstallPtvsdNo": "No",
     "DataScience.cellStopOnErrorFormatMessage": "{0} cells were canceled due to an error in the previous cell.",
-    "DataScience.instructionComments": "# To add a new cell, type '#%%'\n# To add a new markdown cell, type '#%% [markdown]'\n",
+    "DataScience.instructionComments": "# To add a new cell, type '{0}'\n# To add a new markdown cell, type '{0} [markdown]'\n",
     "DataScience.scrollToCellTitleFormatMessage": "Go to [{0}]",
     "DataScience.remoteDebuggerNotSupported": "Debugging while attached to a remote server is not currently supported.",
     "DataScience.save": "Save notebook",
diff --git a/package.nls.nl.json b/package.nls.nl.json
index 8b4f57ee8a19..4197ddaa9e75 100644
--- a/package.nls.nl.json
+++ b/package.nls.nl.json
@@ -115,7 +115,7 @@
     "DataScience.exportingFormat": "Aan het exporteren {0}",
     "DataScience.exportCancel": "Annuleren",
     "Common.canceled": "Geannuleerd",
-    "DataScience.importChangeDirectoryComment": "#%% De werkmap van de werkruimte root naar de ipynb-bestandslocatie veranderen. Schakel deze toevoeging uit met de instelling DataScience.changeDirOnImportExport",
+    "DataScience.importChangeDirectoryComment": "{0} De werkmap van de werkruimte root naar de ipynb-bestandslocatie veranderen. Schakel deze toevoeging uit met de instelling DataScience.changeDirOnImportExport",
     "DataScience.exportChangeDirectoryComment": "# De map wijzigen naar de VSCode-werktuimte root zodat de relatieve pad-ladingen correct werken. Schakel deze toevoeging uit met de instelling DataScience.changeDirOnImportExport",
     "DataScience.interruptKernelStatus": "IPython-kernel onderbreken",
     "DataScience.restartKernelAfterInterruptMessage": "Het onderbreken van de kernel duurde te lang. Wil je de kernel in plaats daarvan herstarten? Alle variabelen zullen verloren gaan.",
diff --git a/snippets/python.json b/snippets/python.json
index 4d12d255699b..b1954d45cf17 100644
--- a/snippets/python.json
+++ b/snippets/python.json
@@ -242,12 +242,12 @@
     },
     "add/new/cell": {
         "prefix": "add/new/cell",
-        "body": "#%%",
+        "body": "# %%",
         "description": "Code snippet to add a new cell"
     },
     "mark/markdown": {
         "prefix": "mark/markdown",
-        "body": "#%% [markdown]",
+        "body": "# %% [markdown]",
         "description": "Code snippet to add a new markdown cell"
     }
 }
diff --git a/src/client/common/types.ts b/src/client/common/types.ts
index 296b594d804b..cba278d6e533 100644
--- a/src/client/common/types.ts
+++ b/src/client/common/types.ts
@@ -355,6 +355,7 @@ export interface IDataScienceSettings {
     runMagicCommands?: string;
     runStartupCommands: string;
     debugJustMyCode: boolean;
+    defaultCellMarker?: string;
 }
 
 export const IConfigurationService = Symbol('IConfigurationService');
diff --git a/src/client/common/utils/localize.ts b/src/client/common/utils/localize.ts
index 883d86a28241..d3c1f802d5a6 100644
--- a/src/client/common/utils/localize.ts
+++ b/src/client/common/utils/localize.ts
@@ -148,7 +148,7 @@ export namespace DataScience {
     export const runAllCellsLensCommandTitle = localize('python.command.python.datascience.runallcells.title', 'Run all cells');
     export const runAllCellsAboveLensCommandTitle = localize('python.command.python.datascience.runallcellsabove.title', 'Run above');
     export const runCellAndAllBelowLensCommandTitle = localize('python.command.python.datascience.runcellandallbelow.title', 'Run Below');
-    export const importChangeDirectoryComment = localize('DataScience.importChangeDirectoryComment', '#%% Change working directory from the workspace root to the ipynb file location. Turn this addition off with the DataScience.changeDirOnImportExport setting');
+    export const importChangeDirectoryComment = localize('DataScience.importChangeDirectoryComment', '{0} Change working directory from the workspace root to the ipynb file location. Turn this addition off with the DataScience.changeDirOnImportExport setting');
     export const exportChangeDirectoryComment = localize('DataScience.exportChangeDirectoryComment', '# Change directory to VSCode workspace root so that relative path loads work correctly. Turn this addition off with the DataScience.changeDirOnImportExport setting');
 
     export const restartKernelMessage = localize('DataScience.restartKernelMessage', 'Do you want to restart the Jupter kernel? All variables will be lost.');
@@ -262,7 +262,7 @@ export namespace DataScience {
     export const jupyterDebuggerInstallPtvsdNo = localize('DataScience.jupyterDebuggerInstallPtvsdNo', 'No');
     export const cellStopOnErrorFormatMessage = localize('DataScience.cellStopOnErrorFormatMessage', '{0} cells were canceled due to an error in the previous cell.');
     export const scrollToCellTitleFormatMessage = localize('DataScience.scrollToCellTitleFormatMessage', 'Go to [{0}]');
-    export const instructionComments = localize('DataScience.instructionComments', '# To add a new cell, type "#%%"\n# To add a new markdown cell, type "#%% [markdown]"\n');
+    export const instructionComments = localize('DataScience.instructionComments', '# To add a new cell, type "{0}"\n# To add a new markdown cell, type "{0} [markdown]"\n');
     export const invalidNotebookFileError = localize('DataScience.invalidNotebookFileError', 'Notebook is not in the correct format. Check the file for correct json.');
     export const invalidNotebookFileErrorFormat = localize('DataScience.invalidNotebookFileError', '{0} is not a valid notebook file. Check the file for correct json.');
     export const nativeEditorTitle = localize('DataScience.nativeEditorTitle', 'Notebook Editor');
diff --git a/src/client/datascience/constants.ts b/src/client/datascience/constants.ts
index 3e8c5f24ce40..6b22853385a8 100644
--- a/src/client/datascience/constants.ts
+++ b/src/client/datascience/constants.ts
@@ -277,12 +277,13 @@ export namespace Identifiers {
     export const SvgSizeTag = 'sizeTag={{0}, {1}}';
     export const InteractiveWindowIdentity = 'history://EC155B3B-DC18-49DC-9E99-9A948AA2F27B';
     export const InteractiveWindowIdentityScheme = 'history';
+    export const DefaultCodeCellMarker = '# %%';
 }
 
 export namespace CodeSnippits {
     export const ChangeDirectory = ['{0}', '{1}', 'import os', 'try:', '\tos.chdir(os.path.join(os.getcwd(), \'{2}\'))', '\tprint(os.getcwd())', 'except:', '\tpass', ''];
     export const ChangeDirectoryCommentIdentifier = '# ms-python.python added'; // Not translated so can compare.
-    export const ImportIPython = '#%%\nfrom IPython import get_ipython\n\n';
+    export const ImportIPython = '{0}\nfrom IPython import get_ipython\n\n{1}';
     export const MatplotLibInitSvg = `import matplotlib\n%matplotlib inline\n${Identifiers.MatplotLibDefaultParams} = dict(matplotlib.rcParams)\n%config InlineBackend.figure_formats = 'svg', 'png'`;
     export const MatplotLibInitPng = `import matplotlib\n%matplotlib inline\n${Identifiers.MatplotLibDefaultParams} = dict(matplotlib.rcParams)\n%config InlineBackend.figure_formats = 'png'`;
 }
diff --git a/src/client/datascience/editor-integration/codewatcher.ts b/src/client/datascience/editor-integration/codewatcher.ts
index 6ebdb12a6423..5958ff620a3a 100644
--- a/src/client/datascience/editor-integration/codewatcher.ts
+++ b/src/client/datascience/editor-integration/codewatcher.ts
@@ -22,7 +22,7 @@ import { StopWatch } from '../../common/utils/stopWatch';
 import { captureTelemetry, sendTelemetryEvent } from '../../telemetry';
 import { ICodeExecutionHelper } from '../../terminals/types';
 import { CellMatcher } from '../cellMatcher';
-import { Commands, Telemetry } from '../constants';
+import { Commands, Identifiers, Telemetry } from '../constants';
 import { ICodeLensFactory, ICodeWatcher, IDataScienceErrorHandler, IInteractiveWindowProvider } from '../types';
 
 @injectable()
@@ -268,9 +268,10 @@ export class CodeWatcher implements ICodeWatcher {
 
     public async addEmptyCellToBottom(): Promise<void> {
         const editor = this.documentManager.activeTextEditor;
+        const cellDelineator = this.defaultCellMarker;
         if (editor) {
             editor.edit((editBuilder) => {
-                editBuilder.insert(new Position(editor.document.lineCount, 0), '\n\n#%%\n');
+                editBuilder.insert(new Position(editor.document.lineCount, 0), `\n\n${cellDelineator}\n`);
             });
 
             const newPosition = new Position(editor.document.lineCount + 3, 0); // +3 to account for the added spaces and to position after the new mark
@@ -286,6 +287,7 @@ export class CodeWatcher implements ICodeWatcher {
         const editor = this.documentManager.activeTextEditor;
         const cellMatcher = new CellMatcher();
         let index = 0;
+        const cellDelineator = this.defaultCellMarker;
 
         if (editor) {
             editor.edit((editBuilder) => {
@@ -295,14 +297,14 @@ export class CodeWatcher implements ICodeWatcher {
                     if (cellMatcher.isCell(editor.document.lineAt(i).text)) {
                         lastCell = false;
                         index = i;
-                        editBuilder.insert(new Position(i, 0), '#%%\n\n');
+                        editBuilder.insert(new Position(i, 0), `${cellDelineator}\n\n`);
                         break;
                     }
                 }
 
                 if (lastCell) {
                     index = editor.document.lineCount;
-                    editBuilder.insert(new Position(editor.document.lineCount, 0), '\n#%%\n');
+                    editBuilder.insert(new Position(editor.document.lineCount, 0), `\n${cellDelineator}\n`);
                 }
             });
         }
@@ -313,6 +315,10 @@ export class CodeWatcher implements ICodeWatcher {
             .then(() => this.advanceToRange(new Range(newPosition, newPosition)));
     }
 
+    private get defaultCellMarker(): string {
+        return this.configService.getSettings().datascience.defaultCellMarker || Identifiers.DefaultCodeCellMarker;
+    }
+
     private onCodeLensFactoryUpdated(): void {
         // Update our code lenses.
         if (this.document) {
@@ -419,7 +425,7 @@ export class CodeWatcher implements ICodeWatcher {
 
         if (editor) {
             editor.edit((editBuilder) => {
-                editBuilder.insert(new Position(currentRange.end.line + 1, 0), '\n\n#%%\n');
+                editBuilder.insert(new Position(currentRange.end.line + 1, 0), `\n\n${this.defaultCellMarker}\n`);
             });
         }
 
diff --git a/src/client/datascience/gather/gather.ts b/src/client/datascience/gather/gather.ts
index c57b3d303904..049ad27c7c92 100644
--- a/src/client/datascience/gather/gather.ts
+++ b/src/client/datascience/gather/gather.ts
@@ -15,6 +15,7 @@ import { Common } from '../../common/utils/localize';
 import { noop } from '../../common/utils/misc';
 import { CellMatcher } from '../cellMatcher';
 import { concatMultilineString } from '../common';
+import { Identifiers } from '../constants';
 import { CellState, ICell as IVscCell, IGatherExecution, INotebookExecutionLogger } from '../types';
 
 /**
@@ -79,9 +80,13 @@ export class GatherExecution implements IGatherExecution, INotebookExecutionLogg
         if (cell === undefined) {
             return '';
         }
+
+        // Get the default cell marker as we need to replace #%% with it.
+        const defaultCellMarker = this.configService.getSettings().datascience.defaultCellMarker || Identifiers.DefaultCodeCellMarker;
+
         // Call internal slice method
         const slices = this._executionSlicer.sliceAllExecutions(cell);
-        const program = slices[0].cellSlices.reduce(concat, '');
+        const program = slices.length > 0 ? slices[0].cellSlices.reduce(concat, '').replace(/#%%/g, defaultCellMarker) : '';
 
         // Add a comment at the top of the file explaining what gather does
         const descriptor = '# This file contains the minimal amount of code required to produce the code cell you gathered.\n';
diff --git a/src/client/datascience/interactive-common/interactiveBase.ts b/src/client/datascience/interactive-common/interactiveBase.ts
index ebd865a2f22b..2dbd8f06a4ba 100644
--- a/src/client/datascience/interactive-common/interactiveBase.ts
+++ b/src/client/datascience/interactive-common/interactiveBase.ts
@@ -998,6 +998,7 @@ export abstract class InteractiveBase extends WebViewHost<IInteractiveWindowMapp
             const hasCellsAlready = ranges.length > 0;
             const line = editor.selection.start.line;
             const revealLine = line + 1;
+            const defaultCellMarker = this.configService.getSettings().datascience.defaultCellMarker || Identifiers.DefaultCodeCellMarker;
             let newCode = `${source}${os.EOL}`;
             if (hasCellsAlready) {
                 // See if inside of a range or not.
@@ -1005,13 +1006,13 @@ export abstract class InteractiveBase extends WebViewHost<IInteractiveWindowMapp
 
                 // If in the middle, wrap the new code
                 if (matchingRange && matchingRange.range.start.line < line && line < editor.document.lineCount - 1) {
-                    newCode = `#%%${os.EOL}${source}${os.EOL}#%%${os.EOL}`;
+                    newCode = `${defaultCellMarker}${os.EOL}${source}${os.EOL}${defaultCellMarker}${os.EOL}`;
                 } else {
-                    newCode = `#%%${os.EOL}${source}${os.EOL}`;
+                    newCode = `${defaultCellMarker}${os.EOL}${source}${os.EOL}`;
                 }
             } else if (editor.document.lineCount <= 0 || editor.document.isUntitled) {
                 // No lines in the document at all, just insert new code
-                newCode = `#%%${os.EOL}${source}${os.EOL}`;
+                newCode = `${defaultCellMarker}${os.EOL}${source}${os.EOL}`;
             }
 
             await editor.edit((editBuilder) => {
diff --git a/src/client/datascience/jupyter/jupyterImporter.ts b/src/client/datascience/jupyter/jupyterImporter.ts
index e4a61b6ca269..2fcf89670d2f 100644
--- a/src/client/datascience/jupyter/jupyterImporter.ts
+++ b/src/client/datascience/jupyter/jupyterImporter.ts
@@ -6,6 +6,7 @@ import * as fs from 'fs-extra';
 import { inject, injectable } from 'inversify';
 import * as os from 'os';
 import * as path from 'path';
+import '../../common/extensions';
 
 import { IWorkspaceService } from '../../common/application/types';
 import { IFileSystem, IPlatformService } from '../../common/platform/types';
@@ -20,16 +21,16 @@ import { InvalidNotebookFileError } from './invalidNotebookFileError';
 export class JupyterImporter implements INotebookImporter {
     public isDisposed: boolean = false;
     // Template that changes markdown cells to have # %% [markdown] in the comments
-    private readonly nbconvertTemplate =
+    private readonly nbconvertTemplateFormat =
         // tslint:disable-next-line:no-multiline-string
         `{%- extends 'null.tpl' -%}
 {% block codecell %}
-#%%
+{0}
 {{ super() }}
 {% endblock codecell %}
 {% block in_prompt %}{% endblock in_prompt %}
 {% block input %}{{ cell.source | ipython2python }}{% endblock input %}
-{% block markdowncell scoped %}#%% [markdown]
+{% block markdowncell scoped %}{0} [markdown]
 {{ cell.source | comment_lines }}
 {% endblock markdowncell %}`;
 
@@ -116,16 +117,20 @@ export class JupyterImporter implements INotebookImporter {
     }
 
     private addInstructionComments = (pythonOutput: string): string => {
-        const comments = localize.DataScience.instructionComments();
+        const comments = localize.DataScience.instructionComments().format(this.defaultCellMarker);
         return comments.concat(pythonOutput);
     }
 
+    private get defaultCellMarker(): string {
+        return this.configuration.getSettings().datascience.defaultCellMarker || Identifiers.DefaultCodeCellMarker;
+    }
+
     private addIPythonImport = (pythonOutput: string): string => {
-        return CodeSnippits.ImportIPython.concat(pythonOutput);
+        return CodeSnippits.ImportIPython.format(this.defaultCellMarker, pythonOutput);
     }
 
     private addDirectoryChange = (pythonOutput: string, directoryChange: string): string => {
-        const newCode = CodeSnippits.ChangeDirectory.join(os.EOL).format(localize.DataScience.importChangeDirectoryComment(), CodeSnippits.ChangeDirectoryCommentIdentifier, directoryChange);
+        const newCode = CodeSnippits.ChangeDirectory.join(os.EOL).format(localize.DataScience.importChangeDirectoryComment().format(this.defaultCellMarker), CodeSnippits.ChangeDirectoryCommentIdentifier, directoryChange);
         return newCode.concat(pythonOutput);
     }
 
@@ -173,7 +178,7 @@ export class JupyterImporter implements INotebookImporter {
             try {
                 // Save this file into our disposables so the temp file goes away
                 this.disposableRegistry.push(file);
-                await fs.appendFile(file.filePath, this.nbconvertTemplate);
+                await fs.appendFile(file.filePath, this.nbconvertTemplateFormat.format(this.defaultCellMarker));
 
                 // Now we should have a template that will convert
                 return file.filePath;
diff --git a/src/test/datascience/gather/gather.unit.test.ts b/src/test/datascience/gather/gather.unit.test.ts
index b0bda5334fd0..d4dc30b9c56f 100644
--- a/src/test/datascience/gather/gather.unit.test.ts
+++ b/src/test/datascience/gather/gather.unit.test.ts
@@ -125,6 +125,7 @@ suite('DataScience code gathering unit tests', () => {
 
     dataScienceSettings.setup(d => d.gatherRules).returns(() => gatherRules);
     dataScienceSettings.setup(d => d.enabled).returns(() => true);
+    dataScienceSettings.setup(d => d.defaultCellMarker).returns(() => '# %%');
     pythonSettings.setup(p => p.datascience).returns(() => dataScienceSettings.object);
     configurationService.setup(c => c.getSettings(TypeMoq.It.isAny())).returns(() => pythonSettings.object);
     appShell.setup(a => a.showInformationMessage(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(''));
@@ -140,9 +141,10 @@ suite('DataScience code gathering unit tests', () => {
     });
 
     test('Gathers program slices for a cell', async () => {
+        const defaultCellMarker = '# %%';
         const cell: IVscCell = codeCells[codeCells.length - 1];
         const program = gatherExecution.gatherCode(cell);
-        const expectedProgram = `# This file contains the minimal amount of code required to produce the code cell you gathered.\n#%%\nfrom bokeh.plotting import show, figure, output_notebook\n\n#%%\nx = [1,2,3,4,5]\ny = [21,9,15,17,4]\n\n#%%\np=figure(title='demo',x_axis_label='x',y_axis_label='y')\n\n#%%\np.line(x,y,line_width=2)\n\n#%%\nshow(p)\n`;
+        const expectedProgram = `# This file contains the minimal amount of code required to produce the code cell you gathered.\n${defaultCellMarker}\nfrom bokeh.plotting import show, figure, output_notebook\n\n${defaultCellMarker}\nx = [1,2,3,4,5]\ny = [21,9,15,17,4]\n\n${defaultCellMarker}\np=figure(title='demo',x_axis_label='x',y_axis_label='y')\n\n${defaultCellMarker}\np.line(x,y,line_width=2)\n\n${defaultCellMarker}\nshow(p)\n`;
         assert.equal(program.trim(), expectedProgram.trim());
     });
 });
diff --git a/src/test/datascience/interactiveWindow.functional.test.tsx b/src/test/datascience/interactiveWindow.functional.test.tsx
index 2bda12f75273..90b70372488a 100644
--- a/src/test/datascience/interactiveWindow.functional.test.tsx
+++ b/src/test/datascience/interactiveWindow.functional.test.tsx
@@ -53,6 +53,7 @@ import {
 suite('DataScience Interactive Window output tests', () => {
     const disposables: Disposable[] = [];
     let ioc: DataScienceIocContainer;
+    const defaultCellMarker = '# %%';
 
     setup(() => {
         ioc = new DataScienceIocContainer();
@@ -577,7 +578,7 @@ for _ in range(50):
     runMountedTest('Gather code run from text editor', async (wrapper) => {
         ioc.getSettings().datascience.enableGather = true;
         // Enter some code.
-        const code = '#%%\na=1\na';
+        const code = `${defaultCellMarker}\na=1\na`;
         await addCode(ioc, wrapper, code);
         addMockData(ioc, code, undefined);
         const ImageButtons = getLastOutputCell(wrapper, 'InteractiveCell').find(ImageButton); // This isn't rendering correctly
@@ -589,7 +590,7 @@ for _ in range(50):
         const docManager = ioc.get<IDocumentManager>(IDocumentManager) as MockDocumentManager;
         assert.notEqual(docManager.activeTextEditor, undefined);
         if (docManager.activeTextEditor) {
-            assert.equal(docManager.activeTextEditor.document.getText(), `# This file contains the minimal amount of code required to produce the code cell you gathered.\n#%%\na=1\na\n\n`);
+            assert.equal(docManager.activeTextEditor.document.getText(), `# This file contains the minimal amount of code required to produce the code cell you gathered.\n${defaultCellMarker}\na=1\na\n\n`);
         }
     }, () => { return ioc; });
 
@@ -611,21 +612,21 @@ for _ in range(50):
         const docManager = ioc.get<IDocumentManager>(IDocumentManager) as MockDocumentManager;
         assert.notEqual(docManager.activeTextEditor, undefined);
         if (docManager.activeTextEditor) {
-            assert.equal(docManager.activeTextEditor.document.getText(), `# This file contains the minimal amount of code required to produce the code cell you gathered.\n#%%\na=1\na\n\n`);
+            assert.equal(docManager.activeTextEditor.document.getText(), `# This file contains the minimal amount of code required to produce the code cell you gathered.\n${defaultCellMarker}\na=1\na\n\n`);
         }
     }, () => { return ioc; });
 
     runMountedTest('Copy back to source', async (_wrapper) => {
-        ioc.addDocument(`#%%${os.EOL}print("bar")`, 'foo.py');
+        ioc.addDocument(`${defaultCellMarker}${os.EOL}print("bar")`, 'foo.py');
         const docManager = ioc.get<IDocumentManager>(IDocumentManager);
         docManager.showTextDocument(docManager.textDocuments[0]);
         const window = await getOrCreateInteractiveWindow(ioc) as InteractiveWindow;
         window.copyCode({source: 'print("baz")'});
-        assert.equal(docManager.textDocuments[0].getText(), `#%%${os.EOL}print("baz")${os.EOL}#%%${os.EOL}print("bar")`, 'Text not inserted');
+        assert.equal(docManager.textDocuments[0].getText(), `${defaultCellMarker}${os.EOL}print("baz")${os.EOL}${defaultCellMarker}${os.EOL}print("bar")`, 'Text not inserted');
         const activeEditor = docManager.activeTextEditor as MockEditor;
         activeEditor.selection = new Selection(1, 2, 1, 2);
         window.copyCode({source: 'print("baz")'});
-        assert.equal(docManager.textDocuments[0].getText(), `#%%${os.EOL}#%%${os.EOL}print("baz")${os.EOL}#%%${os.EOL}print("baz")${os.EOL}#%%${os.EOL}print("bar")`, 'Text not inserted');
+        assert.equal(docManager.textDocuments[0].getText(), `${defaultCellMarker}${os.EOL}${defaultCellMarker}${os.EOL}print("baz")${os.EOL}${defaultCellMarker}${os.EOL}print("baz")${os.EOL}${defaultCellMarker}${os.EOL}print("bar")`, 'Text not inserted');
     }, () => { return ioc; });
 
     runMountedTest('Limit text output', async (wrapper) => {
diff --git a/src/test/datascience/manualTestFiles/manualTestFile.py b/src/test/datascience/manualTestFiles/manualTestFile.py
index 6ee58091af44..393deee6a965 100644
--- a/src/test/datascience/manualTestFiles/manualTestFile.py
+++ b/src/test/datascience/manualTestFiles/manualTestFile.py
@@ -1,16 +1,16 @@
 # To run this file either conda or pip install the following: jupyter, numpy, matplotlib, pandas, tqdm, bokeh
 
-#%% Basic Imports
+# %% Basic Imports
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
 
-#%% Matplotlib Plot
+# %% Matplotlib Plot
 x = np.linspace(0, 20, 100)
 plt.plot(x, np.sin(x))
 plt.show()
 
-#%% Bokeh Plot
+# %% Bokeh Plot
 from bokeh.io import output_notebook, show
 from bokeh.plotting import figure
 output_notebook()
@@ -55,4 +55,4 @@
 \nabla \cdot \vec{\mathbf{E}} & = 4 \pi \rho \\
 \nabla \times \vec{\mathbf{E}}\, +\, \frac1c\, \frac{\partial\vec{\mathbf{B}}}{\partial t} & = \vec{\mathbf{0}} \\
 \nabla \cdot \vec{\mathbf{B}} & = 0
-\end{align}
\ No newline at end of file
+\end{align}

From ee7a5070d112914e3e1ce873ecd6747d8c6522c4 Mon Sep 17 00:00:00 2001
From: Rich Chiodo <rchiodo@users.noreply.github.com>
Date: Mon, 7 Oct 2019 16:45:34 -0700
Subject: [PATCH 11/36] Fix selection and focus not updating when clicking
 around in a notebook (#7806)

* Fix selection and focus not updating when clicking around in a notebook editor.

* Also fix add cell to put focus in the new cell
---
 news/2 Fixes/7802.md                             |  1 +
 package-lock.json                                | 10 +++++-----
 .../interactive-common/cellInput.tsx             |  3 +--
 .../interactive-common/mainStateController.ts    | 16 ++++++++--------
 src/datascience-ui/native-editor/nativeCell.tsx  |  6 +++---
 .../native-editor/nativeEditor.tsx               |  5 ++++-
 6 files changed, 22 insertions(+), 19 deletions(-)
 create mode 100644 news/2 Fixes/7802.md

diff --git a/news/2 Fixes/7802.md b/news/2 Fixes/7802.md
new file mode 100644
index 000000000000..969f2f7feccd
--- /dev/null
+++ b/news/2 Fixes/7802.md	
@@ -0,0 +1 @@
+Fix selection and focus not updating when clicking around in a notebook editor.
diff --git a/package-lock.json b/package-lock.json
index 2c4fd706f33d..6a0b36e78cdb 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -13770,7 +13770,7 @@
             "dependencies": {
                 "buffer": {
                     "version": "4.9.1",
-                    "resolved": "http://registry.npmjs.org/buffer/-/buffer-4.9.1.tgz",
+                    "resolved": "https://registry.npmjs.org/buffer/-/buffer-4.9.1.tgz",
                     "integrity": "sha1-bRu2AbB6TvztlwlBMgkwJ8lbwpg=",
                     "dev": true,
                     "requires": {
@@ -13793,7 +13793,7 @@
                 },
                 "readable-stream": {
                     "version": "2.3.6",
-                    "resolved": "http://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz",
+                    "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz",
                     "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==",
                     "dev": true,
                     "requires": {
@@ -14145,7 +14145,7 @@
                 },
                 "os-locale": {
                     "version": "3.1.0",
-                    "resolved": false,
+                    "resolved": "https://registry.npmjs.org/os-locale/-/os-locale-3.1.0.tgz",
                     "integrity": "sha512-Z8l3R4wYWM40/52Z+S265okfFj8Kt2cC2MKY+xNi3kFs+XGI7WXu/I309QQQYbRW4ijiZ+yxs9pqEhJh0DqW3Q==",
                     "dev": true,
                     "requires": {
@@ -14162,7 +14162,7 @@
                 },
                 "resolve-from": {
                     "version": "4.0.0",
-                    "resolved": false,
+                    "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
                     "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
                     "dev": true
                 },
@@ -18754,7 +18754,7 @@
             "dependencies": {
                 "json5": {
                     "version": "1.0.1",
-                    "resolved": "http://registry.npmjs.org/json5/-/json5-1.0.1.tgz",
+                    "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.1.tgz",
                     "integrity": "sha512-aKS4WQjPenRxiQsC93MNfjx+nbF4PAdYzmd/1JIj8HYzqfbu86beTuNgXDzPknWk0n0uARlyewZo4s++ES36Ow==",
                     "dev": true,
                     "requires": {
diff --git a/src/datascience-ui/interactive-common/cellInput.tsx b/src/datascience-ui/interactive-common/cellInput.tsx
index 3089235935f1..17a60132396d 100644
--- a/src/datascience-ui/interactive-common/cellInput.tsx
+++ b/src/datascience-ui/interactive-common/cellInput.tsx
@@ -26,7 +26,6 @@ interface ICellInputProps {
     monacoTheme: string | undefined;
     editorOptions?: monacoEditor.editor.IEditorOptions;
     editorMeasureClassName?: string;
-    focusedCell?: string;
     showLineNumbers?: boolean;
     font: IFont;
     onCodeChange(changes: monacoEditor.editor.IModelContentChange[], cellId: string, modelId: string): void;
@@ -56,7 +55,7 @@ export class CellInput extends React.Component<ICellInputProps> {
     }
 
     public componentDidUpdate(prevProps: ICellInputProps) {
-        if (this.props.focusedCell === this.props.cellVM.cell.id && prevProps.focusedCell !== this.props.focusedCell) {
+        if (this.props.cellVM.focused && !prevProps.cellVM.focused) {
             this.giveFocus();
         }
     }
diff --git a/src/datascience-ui/interactive-common/mainStateController.ts b/src/datascience-ui/interactive-common/mainStateController.ts
index 328d0cf00a34..6878373735bd 100644
--- a/src/datascience-ui/interactive-common/mainStateController.ts
+++ b/src/datascience-ui/interactive-common/mainStateController.ts
@@ -314,8 +314,8 @@ export class MainStateController implements IMessageHandler {
             // Update our state
             this.setState({
                 cellVMs: newVMs,
-                selectedCell: newSelection,
-                focusedCell: newFocused,
+                selectedCellId: newSelection,
+                focusedCellId: newFocused,
                 undoStack: this.pushStack(this.pendingState.undoStack, this.pendingState.cellVMs),
                 skipNextScroll: true
             });
@@ -509,7 +509,7 @@ export class MainStateController implements IMessageHandler {
                 newVMs[oldSelect] = { ...newVMs[oldSelect], focused: false };
             }
             // Only unfocus if we haven't switched somewhere else yet
-            this.setState({ focusedCell: undefined, cellVMs: newVMs });
+            this.setState({ focusedCellId: undefined, cellVMs: newVMs });
         }
     }
 
@@ -528,13 +528,13 @@ export class MainStateController implements IMessageHandler {
             }
 
             // Save the whole thing in our state.
-            this.setState({ selectedCell: cellId, focusedCell: cellId, cellVMs: newVMs });
+            this.setState({ selectedCellId: cellId, focusedCellId: cellId, cellVMs: newVMs });
         }
     }
 
-    public selectCell = (cellId: string, focusedCell?: string) => {
+    public selectCell = (cellId: string, focusedCellId?: string) => {
         // Skip if already the same cell
-        if (this.pendingState.selectedCellId !== cellId || this.pendingState.focusedCellId !== focusedCell) {
+        if (this.pendingState.selectedCellId !== cellId || this.pendingState.focusedCellId !== focusedCellId) {
             const newVMs = [...this.pendingState.cellVMs];
             // Switch the old vm
             const oldSelect = this.findCellIndex(this.pendingState.selectedCellId);
@@ -543,11 +543,11 @@ export class MainStateController implements IMessageHandler {
             }
             const newSelect = this.findCellIndex(cellId);
             if (newSelect >= 0) {
-                newVMs[newSelect] = { ...newVMs[newSelect], selected: true, focused: focusedCell === newVMs[newSelect].cell.id };
+                newVMs[newSelect] = { ...newVMs[newSelect], selected: true, focused: focusedCellId === newVMs[newSelect].cell.id };
             }
 
             // Save the whole thing in our state.
-            this.setState({ selectedCell: cellId, focusedCell, cellVMs: newVMs });
+            this.setState({ selectedCellId: cellId, focusedCellId, cellVMs: newVMs });
         }
     }
 
diff --git a/src/datascience-ui/native-editor/nativeCell.tsx b/src/datascience-ui/native-editor/nativeCell.tsx
index 75c6cc58ad7b..03e2a9d9ac3d 100644
--- a/src/datascience-ui/native-editor/nativeCell.tsx
+++ b/src/datascience-ui/native-editor/nativeCell.tsx
@@ -186,8 +186,8 @@ export class NativeCell extends React.Component<INativeCellProps> {
                 // Not a click on an button in a toolbar, select the cell.
                 ev.stopPropagation();
                 this.lastKeyPressed = undefined;
-                const focusedCell = this.isFocused() ? this.cellId : undefined;
-                this.props.stateController.selectCell(this.cellId, focusedCell);
+                const focusedCellId = this.isFocused() ? this.cellId : undefined;
+                this.props.stateController.selectCell(this.cellId, focusedCellId);
             }
         }
     }
@@ -487,7 +487,7 @@ export class NativeCell extends React.Component<INativeCellProps> {
         const newCell = this.props.stateController.insertBelow(this.props.cellVM.cell.id, true);
         this.props.stateController.sendCommand(NativeCommandType.AddToEnd, 'mouse');
         if (newCell) {
-            this.props.selectCell(newCell);
+            this.props.focusCell(newCell, true);
         }
     }
 
diff --git a/src/datascience-ui/native-editor/nativeEditor.tsx b/src/datascience-ui/native-editor/nativeEditor.tsx
index 21c99415bd3d..479f8baa2c4d 100644
--- a/src/datascience-ui/native-editor/nativeEditor.tsx
+++ b/src/datascience-ui/native-editor/nativeEditor.tsx
@@ -172,8 +172,11 @@ export class NativeEditor extends React.Component<INativeEditorProps, IMainState
     // tslint:disable: react-this-binding-issue
     private renderToolbarPanel() {
         const addCell = () => {
-            this.stateController.addNewCell();
+            const newCell = this.stateController.addNewCell();
             this.stateController.sendCommand(NativeCommandType.AddToEnd, 'mouse');
+            if (newCell) {
+                this.stateController.selectCell(newCell.cell.id, newCell.cell.id);
+            }
         };
         const runAll = () => {
             this.stateController.runAll();

From e77abfbb31ff6510a08df1516aad0fd19ad52852 Mon Sep 17 00:00:00 2001
From: Rich Chiodo <rchiodo@users.noreply.github.com>
Date: Tue, 8 Oct 2019 08:59:00 -0700
Subject: [PATCH 12/36] More functional tests for the notebook editor (#7804)

* New tests

* Add some more functional tests for the notebook editor
Make sure when an error occurs on running a cell it's displayed to the user.

* Review feedback
---
 news/3 Code Health/7372.md                    |  1 +
 .../editor-integration/codewatcher.ts         |  4 +-
 .../datascience/errorHandler/errorHandler.ts  | 42 +++++-----
 .../interactive-common/interactiveBase.ts     | 44 ++++++-----
 .../interactive-ipynb/nativeEditor.ts         | 27 ++++++-
 .../nativeEditorCommandListener.ts            |  2 +-
 .../interactive-ipynb/nativeEditorProvider.ts |  2 +-
 .../interactiveWindowCommandListener.ts       |  4 +-
 .../datascience/jupyter/jupyterExecution.ts   | 26 +++----
 .../nativeEditorStateController.ts            |  6 ++
 .../nativeEditor.functional.test.tsx          | 76 ++++++++++++++++++-
 .../datascience/nativeEditorTestHelpers.tsx   | 14 +++-
 src/test/datascience/testHelpers.tsx          |  6 +-
 13 files changed, 183 insertions(+), 71 deletions(-)
 create mode 100644 news/3 Code Health/7372.md

diff --git a/news/3 Code Health/7372.md b/news/3 Code Health/7372.md
new file mode 100644
index 000000000000..332da98db687
--- /dev/null
+++ b/news/3 Code Health/7372.md	
@@ -0,0 +1 @@
+More functional tests for the notebook editor.
diff --git a/src/client/datascience/editor-integration/codewatcher.ts b/src/client/datascience/editor-integration/codewatcher.ts
index 5958ff620a3a..fab1715b11bd 100644
--- a/src/client/datascience/editor-integration/codewatcher.ts
+++ b/src/client/datascience/editor-integration/codewatcher.ts
@@ -339,7 +339,7 @@ export class CodeWatcher implements ICodeWatcher {
             }
             this.sendPerceivedCellExecute(stopWatch);
         } catch (err) {
-            this.dataScienceErrorHandler.handleError(err).ignoreErrors();
+            await this.dataScienceErrorHandler.handleError(err);
         }
 
         return result;
@@ -353,7 +353,7 @@ export class CodeWatcher implements ICodeWatcher {
                 const activeInteractiveWindow = await this.interactiveWindowProvider.getOrCreateActive();
                 return activeInteractiveWindow.addMessage(message);
             } catch (err) {
-                this.dataScienceErrorHandler.handleError(err).ignoreErrors();
+                await this.dataScienceErrorHandler.handleError(err);
             }
         }
     }
diff --git a/src/client/datascience/errorHandler/errorHandler.ts b/src/client/datascience/errorHandler/errorHandler.ts
index 290af382c0b7..049d981ea6f4 100644
--- a/src/client/datascience/errorHandler/errorHandler.ts
+++ b/src/client/datascience/errorHandler/errorHandler.ts
@@ -20,34 +20,30 @@ export class DataScienceErrorHandler implements IDataScienceErrorHandler {
 
     public async handleError(err: Error): Promise<void> {
         if (err instanceof JupyterInstallError) {
-            this.applicationShell.showInformationMessage(
+            const response = await this.applicationShell.showInformationMessage(
                 err.message,
                 localize.DataScience.jupyterInstall(),
                 localize.DataScience.notebookCheckForImportNo(),
-                err.actionTitle)
-                .then(response => {
-                    if (response === localize.DataScience.jupyterInstall()) {
-                        return this.channels.getInstallationChannels()
-                            .then(installers => {
-                                if (installers) {
-                                    // If Conda is available, always pick it as the user must have a Conda Environment
-                                    const installer = installers.find(ins => ins.name === 'Conda');
-                                    const product = ProductNames.get(Product.jupyter);
+                err.actionTitle);
+            if (response === localize.DataScience.jupyterInstall()) {
+                const installers = await this.channels.getInstallationChannels();
+                if (installers) {
+                    // If Conda is available, always pick it as the user must have a Conda Environment
+                    const installer = installers.find(ins => ins.name === 'Conda');
+                    const product = ProductNames.get(Product.jupyter);
 
-                                    if (installer && product) {
-                                        installer.installModule(product)
-                                            .catch(e => this.applicationShell.showErrorMessage(e.message, localize.DataScience.pythonInteractiveHelpLink()));
-                                    } else if (installers[0] && product) {
-                                        installers[0].installModule(product)
-                                            .catch(e => this.applicationShell.showErrorMessage(e.message, localize.DataScience.pythonInteractiveHelpLink()));
-                                    }
-                                }
-                            });
-                    } else if (response === err.actionTitle) {
-                        // This is a special error that shows a link to open for more help
-                        this.applicationShell.openUrl(err.action);
+                    if (installer && product) {
+                        installer.installModule(product)
+                            .catch(e => this.applicationShell.showErrorMessage(e.message, localize.DataScience.pythonInteractiveHelpLink()));
+                    } else if (installers[0] && product) {
+                        installers[0].installModule(product)
+                            .catch(e => this.applicationShell.showErrorMessage(e.message, localize.DataScience.pythonInteractiveHelpLink()));
                     }
-                });
+                }
+            } else if (response === err.actionTitle) {
+                // This is a special error that shows a link to open for more help
+                this.applicationShell.openUrl(err.action);
+            }
         } else if (err instanceof JupyterSelfCertsError) {
             // Don't show the message for self cert errors
             noop();
diff --git a/src/client/datascience/interactive-common/interactiveBase.ts b/src/client/datascience/interactive-common/interactiveBase.ts
index 2dbd8f06a4ba..7ceaa55ba4dc 100644
--- a/src/client/datascience/interactive-common/interactiveBase.ts
+++ b/src/client/datascience/interactive-common/interactiveBase.ts
@@ -647,7 +647,7 @@ export abstract class InteractiveBase extends WebViewHost<IInteractiveWindowMapp
                             await this.ipynbProvider.open(Uri.file(file), contents);
                         }
                     } catch (e) {
-                        this.errorHandler.handleError(e).ignoreErrors();
+                        await this.errorHandler.handleError(e);
                     }
                 });
             } catch (exc) {
@@ -721,7 +721,6 @@ export abstract class InteractiveBase extends WebViewHost<IInteractiveWindowMapp
             if (!usable) {
                 // Not loading anymore
                 status.dispose();
-                this.dispose();
 
                 // Indicate failing.
                 throw new JupyterInstallError(localize.DataScience.jupyterNotSupported().format(await this.jupyterExecution.getNotebookError()), localize.DataScience.pythonInteractiveHelpLink());
@@ -741,7 +740,7 @@ export abstract class InteractiveBase extends WebViewHost<IInteractiveWindowMapp
                         sendTelemetryEvent(Telemetry.SelfCertsMessageClose);
                     }
                     // Don't leave our Interactive Window open in a non-connected state
-                    this.dispose();
+                    this.closeBecauseOfFailure(e).ignoreErrors();
                 });
                 throw e;
             } else {
@@ -1140,27 +1139,30 @@ export abstract class InteractiveBase extends WebViewHost<IInteractiveWindowMapp
     private async checkUsable(): Promise<boolean> {
         let activeInterpreter: PythonInterpreter | undefined;
         try {
-            activeInterpreter = await this.interpreterService.getActiveInterpreter();
-            const usableInterpreter = await this.jupyterExecution.getUsableJupyterPython();
-            if (usableInterpreter) {
-                // See if the usable interpreter is not our active one. If so, show a warning
-                // Only do this if not the guest in a liveshare session
-                const api = await this.liveShare.getApi();
-                if (!api || (api.session && api.session.role !== vsls.Role.Guest)) {
-                    const active = await this.interpreterService.getActiveInterpreter();
-                    const activeDisplayName = active ? active.displayName : undefined;
-                    const activePath = active ? active.path : undefined;
-                    const usableDisplayName = usableInterpreter ? usableInterpreter.displayName : undefined;
-                    const usablePath = usableInterpreter ? usableInterpreter.path : undefined;
-                    const notebookError = await this.jupyterExecution.getNotebookError();
-                    if (activePath && usablePath && !this.fileSystem.arePathsSame(activePath, usablePath) && activeDisplayName && usableDisplayName) {
-                        this.applicationShell.showWarningMessage(localize.DataScience.jupyterKernelNotSupportedOnActive().format(activeDisplayName, usableDisplayName, notebookError));
+            const options = await this.getNotebookOptions();
+            if (options && !options.uri) {
+                activeInterpreter = await this.interpreterService.getActiveInterpreter();
+                const usableInterpreter = await this.jupyterExecution.getUsableJupyterPython();
+                if (usableInterpreter) {
+                    // See if the usable interpreter is not our active one. If so, show a warning
+                    // Only do this if not the guest in a liveshare session
+                    const api = await this.liveShare.getApi();
+                    if (!api || (api.session && api.session.role !== vsls.Role.Guest)) {
+                        const active = await this.interpreterService.getActiveInterpreter();
+                        const activeDisplayName = active ? active.displayName : undefined;
+                        const activePath = active ? active.path : undefined;
+                        const usableDisplayName = usableInterpreter ? usableInterpreter.displayName : undefined;
+                        const usablePath = usableInterpreter ? usableInterpreter.path : undefined;
+                        const notebookError = await this.jupyterExecution.getNotebookError();
+                        if (activePath && usablePath && !this.fileSystem.arePathsSame(activePath, usablePath) && activeDisplayName && usableDisplayName) {
+                            this.applicationShell.showWarningMessage(localize.DataScience.jupyterKernelNotSupportedOnActive().format(activeDisplayName, usableDisplayName, notebookError));
+                        }
                     }
                 }
+                return usableInterpreter ? true : false;
+            } else {
+                return true;
             }
-
-            return usableInterpreter ? true : false;
-
         } catch (e) {
             // Can't find a usable interpreter, show the error.
             if (activeInterpreter) {
diff --git a/src/client/datascience/interactive-ipynb/nativeEditor.ts b/src/client/datascience/interactive-ipynb/nativeEditor.ts
index ee49ccfbc2c4..84442ab6127d 100644
--- a/src/client/datascience/interactive-ipynb/nativeEditor.ts
+++ b/src/client/datascience/interactive-ipynb/nativeEditor.ts
@@ -244,7 +244,7 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
             // If that works, send the cells to the web view
             return this.postMessage(InteractiveWindowMessages.LoadAllCells, { cells });
         } catch (e) {
-            this.errorHandler.handleError(e).ignoreErrors();
+            return this.errorHandler.handleError(e);
         }
     }
 
@@ -280,10 +280,33 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
                 this.shareMessage(InteractiveWindowMessages.RemoteReexecuteCode, { code: info.code, file: Identifiers.EmptyFileName, line: 0, id: info.id, originator: this.id, debug: false });
             }
         } catch (exc) {
-            await this.errorHandler.handleError(exc);
+            // Make this error our cell output
+            this.sendCellsToWebView([
+                {
+                    data: {
+                        source: info.code,
+                        cell_type: 'code',
+                        outputs: [{
+                            output_type: 'error',
+                            evalue: exc.toString()
+                        }],
+                        metadata: {},
+                        execution_count: null
+                    },
+                    id: info.id,
+                    file: Identifiers.EmptyFileName,
+                    line: 0,
+                    state: CellState.error,
+                    type: 'execute'
+                }
+            ]);
 
             // Tell the other side we restarted the kernel. This will stop all executions
             this.postMessage(InteractiveWindowMessages.RestartKernel).ignoreErrors();
+
+            // Handle an error
+            await this.errorHandler.handleError(exc);
+
         }
     }
 
diff --git a/src/client/datascience/interactive-ipynb/nativeEditorCommandListener.ts b/src/client/datascience/interactive-ipynb/nativeEditorCommandListener.ts
index 97636f9366e2..91fd2edcf157 100644
--- a/src/client/datascience/interactive-ipynb/nativeEditorCommandListener.ts
+++ b/src/client/datascience/interactive-ipynb/nativeEditorCommandListener.ts
@@ -77,7 +77,7 @@ export class NativeEditorCommandListener implements IDataScienceCommandListener
                 // Then take the contents and load it.
                 await this.provider.open(file, contents);
             } catch (e) {
-                this.dataScienceErrorHandler.handleError(e).ignoreErrors();
+                return this.dataScienceErrorHandler.handleError(e);
             }
         }
     }
diff --git a/src/client/datascience/interactive-ipynb/nativeEditorProvider.ts b/src/client/datascience/interactive-ipynb/nativeEditorProvider.ts
index 4a13e5ef9422..f1b46c22a73a 100644
--- a/src/client/datascience/interactive-ipynb/nativeEditorProvider.ts
+++ b/src/client/datascience/interactive-ipynb/nativeEditorProvider.ts
@@ -194,7 +194,7 @@ export class NativeEditorProvider implements INotebookEditorProvider, IAsyncDisp
                 const command = 'workbench.action.closeActiveEditor';
                 await this.cmdManager.executeCommand(command);
             } catch (e) {
-                this.dataScienceErrorHandler.handleError(e).ignoreErrors();
+                return this.dataScienceErrorHandler.handleError(e);
             }
         }
     }
diff --git a/src/client/datascience/interactive-window/interactiveWindowCommandListener.ts b/src/client/datascience/interactive-window/interactiveWindowCommandListener.ts
index 45db25118975..4933f6dde117 100644
--- a/src/client/datascience/interactive-window/interactiveWindowCommandListener.ts
+++ b/src/client/datascience/interactive-window/interactiveWindowCommandListener.ts
@@ -233,10 +233,10 @@ export class InteractiveWindowCommandListener implements IDataScienceCommandList
                 }
             }
         } else {
-            this.dataScienceErrorHandler.handleError(
+            await this.dataScienceErrorHandler.handleError(
                 new JupyterInstallError(
                     localize.DataScience.jupyterNotSupported().format(await this.jupyterExecution.getNotebookError()),
-                    localize.DataScience.pythonInteractiveHelpLink())).ignoreErrors();
+                    localize.DataScience.pythonInteractiveHelpLink()));
         }
     }
 
diff --git a/src/client/datascience/jupyter/jupyterExecution.ts b/src/client/datascience/jupyter/jupyterExecution.ts
index ebe024899fbd..2ac27ba96055 100644
--- a/src/client/datascience/jupyter/jupyterExecution.ts
+++ b/src/client/datascience/jupyter/jupyterExecution.ts
@@ -34,7 +34,7 @@ import {
     INotebookServerLaunchInfo,
     INotebookServerOptions
 } from '../types';
-import {IFindCommandResult, JupyterCommandFinder} from './jupyterCommandFinder';
+import { IFindCommandResult, JupyterCommandFinder } from './jupyterCommandFinder';
 import { JupyterConnection, JupyterServerInfo } from './jupyterConnection';
 import { JupyterInstallError } from './jupyterInstallError';
 import { JupyterKernelSpec } from './jupyterKernelSpec';
@@ -94,7 +94,7 @@ export class JupyterExecutionBase implements IJupyterExecution {
     }
 
     public async getNotebookError(): Promise<string> {
-        const notebook = await this.commandFinder.findBestCommand(JupyterCommands.NotebookCommand);
+        const notebook = await this.findBestCommand(JupyterCommands.NotebookCommand);
         return notebook.error ? notebook.error : localize.DataScience.notebookNotFound();
     }
 
@@ -200,7 +200,7 @@ export class JupyterExecutionBase implements IJupyterExecution {
 
     public async spawnNotebook(file: string): Promise<void> {
         // First we find a way to start a notebook server
-        const notebookCommand = await this.findBestCommandTimed(JupyterCommands.NotebookCommand);
+        const notebookCommand = await this.findBestCommand(JupyterCommands.NotebookCommand);
         this.checkNotebookCommand(notebookCommand);
 
         const args: string[] = [`--NotebookApp.file_to_run=${file}`];
@@ -211,7 +211,7 @@ export class JupyterExecutionBase implements IJupyterExecution {
 
     public async importNotebook(file: string, template: string | undefined): Promise<string> {
         // First we find a way to start a nbconvert
-        const convert = await this.findBestCommandTimed(JupyterCommands.ConvertCommand);
+        const convert = await this.findBestCommand(JupyterCommands.ConvertCommand);
         if (!convert.command) {
             throw new Error(localize.DataScience.jupyterNbConvertNotSupported());
         }
@@ -270,6 +270,10 @@ export class JupyterExecutionBase implements IJupyterExecution {
         }
     }
 
+    protected async findBestCommand(command: JupyterCommands, cancelToken?: CancellationToken): Promise<IFindCommandResult> {
+        return this.commandFinder.findBestCommand(command, cancelToken);
+    }
+
     private checkNotebookCommand(notebook: IFindCommandResult) {
         if (!notebook.command) {
             const errorMessage = notebook.error ? notebook.error : localize.DataScience.notebookNotFound();
@@ -345,7 +349,7 @@ export class JupyterExecutionBase implements IJupyterExecution {
     @captureTelemetry(Telemetry.StartJupyter)
     private async startNotebookServer(useDefaultConfig: boolean, cancelToken?: CancellationToken): Promise<{ connection: IConnection; kernelSpec: IJupyterKernelSpec | undefined }> {
         // First we find a way to start a notebook server
-        const notebookCommand = await this.findBestCommandTimed(JupyterCommands.NotebookCommand, cancelToken);
+        const notebookCommand = await this.findBestCommand(JupyterCommands.NotebookCommand, cancelToken);
         this.checkNotebookCommand(notebookCommand);
 
         // Now actually launch it
@@ -452,7 +456,7 @@ export class JupyterExecutionBase implements IJupyterExecution {
 
     private getUsableJupyterPythonImpl = async (cancelToken?: CancellationToken): Promise<PythonInterpreter | undefined> => {
         // This should be the best interpreter for notebooks
-        const found = await this.findBestCommandTimed(JupyterCommands.NotebookCommand, cancelToken);
+        const found = await this.findBestCommand(JupyterCommands.NotebookCommand, cancelToken);
         if (found && found.command) {
             return found.command.interpreter();
         }
@@ -490,7 +494,7 @@ export class JupyterExecutionBase implements IJupyterExecution {
 
     private async addMatchingSpec(bestInterpreter: PythonInterpreter, cancelToken?: CancellationToken): Promise<void> {
         const displayName = localize.DataScience.historyTitle();
-        const ipykernelCommand = await this.findBestCommandTimed(JupyterCommands.KernelCreateCommand, cancelToken);
+        const ipykernelCommand = await this.findBestCommand(JupyterCommands.KernelCreateCommand, cancelToken);
 
         // If this fails, then we just skip this spec
         try {
@@ -571,7 +575,7 @@ export class JupyterExecutionBase implements IJupyterExecution {
     private isCommandSupported = async (command: JupyterCommands, cancelToken?: CancellationToken): Promise<boolean> => {
         // See if we can find the command
         try {
-            const result = await this.findBestCommandTimed(command, cancelToken);
+            const result = await this.findBestCommand(command, cancelToken);
             return result.command !== undefined;
         } catch (err) {
             this.logger.logWarning(err);
@@ -735,7 +739,7 @@ export class JupyterExecutionBase implements IJupyterExecution {
 
     private enumerateSpecs = async (_cancelToken?: CancellationToken): Promise<(JupyterKernelSpec | undefined)[]> => {
         if (await this.isKernelSpecSupported()) {
-            const kernelSpecCommand = await this.findBestCommandTimed(JupyterCommands.KernelSpecCommand);
+            const kernelSpecCommand = await this.findBestCommand(JupyterCommands.KernelSpecCommand);
 
             if (kernelSpecCommand.command) {
                 try {
@@ -768,8 +772,4 @@ export class JupyterExecutionBase implements IJupyterExecution {
 
         return [];
     }
-
-    private async findBestCommandTimed(command: JupyterCommands, cancelToken?: CancellationToken): Promise<IFindCommandResult> {
-        return this.commandFinder.findBestCommand(command, cancelToken);
-    }
 }
diff --git a/src/datascience-ui/native-editor/nativeEditorStateController.ts b/src/datascience-ui/native-editor/nativeEditorStateController.ts
index 80433cf6dfee..7ed47506dd2c 100644
--- a/src/datascience-ui/native-editor/nativeEditorStateController.ts
+++ b/src/datascience-ui/native-editor/nativeEditorStateController.ts
@@ -50,6 +50,12 @@ export class NativeEditorStateController extends MainStateController {
         return super.handleMessage(msg, payload);
     }
 
+    // This method is used by tests to prepare this react control for loading again.
+    public reset() {
+        this.waitingForLoadRender = false;
+        this.setState({ busy: true });
+    }
+
     public canMoveUp = (cellId?: string) => {
         const index = this.getState().cellVMs.findIndex(cvm => cvm.cell.id === cellId);
         return (index > 0);
diff --git a/src/test/datascience/nativeEditor.functional.test.tsx b/src/test/datascience/nativeEditor.functional.test.tsx
index ddb2a1284e2d..8fcc845afb86 100644
--- a/src/test/datascience/nativeEditor.functional.test.tsx
+++ b/src/test/datascience/nativeEditor.functional.test.tsx
@@ -4,17 +4,27 @@
 import * as assert from 'assert';
 import * as path from 'path';
 import * as TypeMoq from 'typemoq';
-import { Disposable, TextDocument, TextEditor } from 'vscode';
+import { Disposable, TextDocument, TextEditor, Uri } from 'vscode';
 
 import { IApplicationShell, IDocumentManager } from '../../client/common/application/types';
 import { createDeferred } from '../../client/common/utils/async';
 import { noop } from '../../client/common/utils/misc';
 import { Identifiers } from '../../client/datascience/constants';
-import { ICell, INotebookExporter } from '../../client/datascience/types';
+import { JupyterExecutionFactory } from '../../client/datascience/jupyter/jupyterExecutionFactory';
+import { ICell, IJupyterExecution, INotebookEditorProvider, INotebookExporter } from '../../client/datascience/types';
+import { PythonInterpreter } from '../../client/interpreter/contracts';
 import { NativeEditor } from '../../datascience-ui/native-editor/nativeEditor';
 import { ImageButton } from '../../datascience-ui/react-common/imageButton';
 import { DataScienceIocContainer } from './dataScienceIocContainer';
-import { addCell, createNewEditor, getNativeCellResults, openEditor, runMountedTest } from './nativeEditorTestHelpers';
+import {
+    addCell,
+    closeNotebook,
+    createNewEditor,
+    getNativeCellResults,
+    mountNativeWebView,
+    openEditor,
+    runMountedTest
+} from './nativeEditorTestHelpers';
 import { waitForUpdate } from './reactHelpers';
 import {
     addContinuousMockData,
@@ -37,6 +47,15 @@ suite('DataScience Native Editor tests', () => {
     setup(() => {
         ioc = new DataScienceIocContainer();
         ioc.registerDataScienceTypes();
+
+        const appShell = TypeMoq.Mock.ofType<IApplicationShell>();
+        appShell.setup(a => a.showErrorMessage(TypeMoq.It.isAnyString())).returns((_e) => Promise.resolve(''));
+        appShell.setup(a => a.showInformationMessage(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(''));
+        appShell.setup(a => a.showInformationMessage(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((_a1: string, a2: string, _a3: string) => Promise.resolve(a2));
+        appShell.setup(a => a.showInformationMessage(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((_a1: string, _a2: any, _a3: string, a4: string) => Promise.resolve(a4));
+        appShell.setup(a => a.showSaveDialog(TypeMoq.It.isAny())).returns(() => Promise.resolve(Uri.file('foo.ipynb')));
+        ioc.serviceManager.rebindInstance<IApplicationShell>(IApplicationShell, appShell.object);
+
     });
 
     teardown(async () => {
@@ -227,4 +246,55 @@ for _ in range(50):
         verifyHtmlOnCell(wrapper, 'NativeCell', `2`, 1);
         verifyHtmlOnCell(wrapper, 'NativeCell', `3`, 2);
     }, () => { return ioc; });
+
+    runMountedTest('Startup and shutdown', async (wrapper) => {
+        addMockData(ioc, 'b=2\nb', 2);
+        addMockData(ioc, 'c=3\nc', 3);
+
+        const baseFile = [ {id: 'NotebookImport#0', data: {source: 'a=1\na'}},
+        {id: 'NotebookImport#1', data: {source: 'b=2\nb'}},
+        {id: 'NotebookImport#2', data: {source: 'c=3\nc'}} ];
+        const runAllCells =  baseFile.map(cell => {
+            return createFileCell(cell, cell.data);
+        });
+        const notebook = await ioc.get<INotebookExporter>(INotebookExporter).translateToNotebook(runAllCells, undefined);
+        let editor = await openEditor(ioc, JSON.stringify(notebook));
+
+        // Run everything
+        let runAllButton = findButton(wrapper, NativeEditor, 3);
+        await waitForMessageResponse(ioc, () => runAllButton!.simulate('click'));
+        await waitForUpdate(wrapper, NativeEditor, 16);
+
+        // Close editor. Should still have the server up
+        await closeNotebook(editor, wrapper);
+        const jupyterExecution = ioc.serviceManager.get<IJupyterExecution>(IJupyterExecution);
+        const editorProvider = ioc.serviceManager.get<INotebookEditorProvider>(INotebookEditorProvider);
+        const server = await jupyterExecution.getServer(await editorProvider.getNotebookOptions());
+        assert.ok(server, 'Server was destroyed on notebook shutdown');
+
+        // Reopen, and rerun
+        editor = await openEditor(ioc, JSON.stringify(notebook));
+        runAllButton = findButton(wrapper, NativeEditor, 3);
+        await waitForMessageResponse(ioc, () => runAllButton!.simulate('click'));
+        await waitForUpdate(wrapper, NativeEditor, 15);
+        verifyHtmlOnCell(wrapper, 'NativeCell', `1`, 0);
+    }, () => { return ioc; });
+
+    test('Failure', async () => {
+        // Make a dummy class that will fail during launch
+        class FailedProcess extends JupyterExecutionFactory {
+            public getUsableJupyterPython(): Promise<PythonInterpreter | undefined> {
+                return Promise.resolve(undefined);
+            }
+        }
+        ioc.serviceManager.rebind<IJupyterExecution>(IJupyterExecution, FailedProcess);
+        ioc.serviceManager.get<IJupyterExecution>(IJupyterExecution);
+        addMockData(ioc, 'a=1\na', 1);
+        const wrapper = mountNativeWebView(ioc);
+        await createNewEditor(ioc);
+        await addCell(wrapper, 'a=1\na', true, 2);
+
+        // Cell should not have the output
+        verifyHtmlOnCell(wrapper, 'NativeCell', 'Jupyter cannot be started', CellPosition.Last);
+    });
 });
diff --git a/src/test/datascience/nativeEditorTestHelpers.tsx b/src/test/datascience/nativeEditorTestHelpers.tsx
index 12cf08779cef..37c4ce84511f 100644
--- a/src/test/datascience/nativeEditorTestHelpers.tsx
+++ b/src/test/datascience/nativeEditorTestHelpers.tsx
@@ -51,7 +51,7 @@ export function runMountedTest(name: string, testFunc: (wrapper: ReactWrapper<an
         const jupyterExecution = ioc.get<IJupyterExecution>(IJupyterExecution);
         if (await jupyterExecution.isNotebookSupported()) {
             addMockData(ioc, 'a=1\na', 1);
-            const wrapper = mountWebView(ioc, <NativeEditor baseTheme='vscode-light' codeTheme='light_vs' testMode={true} skipDefault={true} />);
+            const wrapper = mountNativeWebView(ioc);
             await testFunc(wrapper);
         } else {
             // tslint:disable-next-line:no-console
@@ -60,6 +60,10 @@ export function runMountedTest(name: string, testFunc: (wrapper: ReactWrapper<an
     });
 }
 
+export function mountNativeWebView(ioc: DataScienceIocContainer): ReactWrapper<any, Readonly<{}>, React.Component> {
+    return mountWebView(ioc, <NativeEditor baseTheme='vscode-light' codeTheme='light_vs' testMode={true} skipDefault={true} />);
+}
+
 // tslint:disable-next-line: no-any
 export async function addCell(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, code: string, submit: boolean = true, expectedSubmitRenderCount: number = 5): Promise<void> {
     // First get the stateController on the main panel. That's how we'll add a new cell.
@@ -81,3 +85,11 @@ export async function addCell(wrapper: ReactWrapper<any, Readonly<{}>, React.Com
         return update;
     }
 }
+
+export function closeNotebook(editor: INotebookEditor, wrapper: ReactWrapper<any, Readonly<{}>, React.Component>): Promise<void> {
+    const reactEditor = getMainPanel<NativeEditor>(wrapper, NativeEditor);
+    if (reactEditor) {
+        reactEditor.stateController.reset();
+    }
+    return editor.dispose();
+}
diff --git a/src/test/datascience/testHelpers.tsx b/src/test/datascience/testHelpers.tsx
index 157899499684..461a6aac039a 100644
--- a/src/test/datascience/testHelpers.tsx
+++ b/src/test/datascience/testHelpers.tsx
@@ -111,6 +111,8 @@ export function getLastOutputCell(wrapper: ReactWrapper<any, Readonly<{}>, React
 }
 
 export function verifyHtmlOnCell(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, cellType: string, html: string | undefined, cellIndex: number | CellPosition) {
+    wrapper.update();
+
     const foundResult = wrapper.find(cellType);
     assert.ok(foundResult.length >= 1, 'Didn\'t find any cells being rendered');
 
@@ -150,9 +152,9 @@ export function verifyHtmlOnCell(wrapper: ReactWrapper<any, Readonly<{}>, React.
         assert.ok(outHtml.includes(sliced), `${outHtml} does not contain ${sliced}`);
     } else {
         const output = targetCell!.find('div.cell-output');
-        const outputHtml = output.length > 0 ? output.html() : 'empty';
+        const outputHtml = output.length > 0 ? output.html() : undefined;
         // html not specified, look for an empty render
-        assert.ok(targetCell!.isEmptyRender(), `Target cell is not empty render, got this instead: ${outputHtml}`);
+        assert.ok(targetCell!.isEmptyRender() || outputHtml === undefined, `Target cell is not empty render, got this instead: ${outputHtml}`);
     }
 }
 

From b48395e7c1d71258b6954e19706d4836dac1de81 Mon Sep 17 00:00:00 2001
From: Ian Huff <ianhu@microsoft.com>
Date: Tue, 8 Oct 2019 09:49:18 -0700
Subject: [PATCH 13/36] Add native command palette cell commands and recontext
 IW cell commands (#7807)

---
 news/1 Enhancements/7800.md                   |  1 +
 package.json                                  | 59 +++++++++++++++++--
 package.nls.json                              |  4 ++
 src/client/common/application/commands.ts     |  3 +
 src/client/datascience/constants.ts           |  4 ++
 .../interactiveWindowTypes.ts                 |  7 ++-
 .../interactive-ipynb/nativeEditor.ts         | 15 +++++
 .../nativeEditorCommandListener.ts            | 24 ++++++++
 .../interactive-window/interactiveWindow.ts   |  3 +
 src/client/datascience/types.ts               |  4 ++
 .../interactive-common/mainStateController.ts |  3 +-
 .../nativeEditorStateController.ts            | 24 ++++++++
 12 files changed, 145 insertions(+), 6 deletions(-)
 create mode 100644 news/1 Enhancements/7800.md

diff --git a/news/1 Enhancements/7800.md b/news/1 Enhancements/7800.md
new file mode 100644
index 000000000000..647a10db36eb
--- /dev/null
+++ b/news/1 Enhancements/7800.md	
@@ -0,0 +1 @@
+Add command palette commands for native editor (run all cells, run selected cell, add new cell). And remove interactive window commands from contexts where they don't apply.
\ No newline at end of file
diff --git a/package.json b/package.json
index b153d3754bf2..93b20658d249 100644
--- a/package.json
+++ b/package.json
@@ -511,7 +511,7 @@
             },
             {
                 "command": "python.datascience.notebookeditor.removeallcells",
-                "title": "%python.command.python.datascience.removeallcells.title%",
+                "title": "%python.command.python.datascience.notebookeditor.removeallcells.title%",
                 "category": "Python"
             },
             {
@@ -524,6 +524,21 @@
                 "title": "%python.command.python.datascience.restartkernel.title%",
                 "category": "Python"
             },
+            {
+                "command": "python.datascience.notebookeditor.runallcells",
+                "title": "%python.command.python.datascience.notebookeditor.runallcells.title%",
+                "category": "Python"
+            },
+            {
+                "command": "python.datascience.notebookeditor.runselectedcell",
+                "title": "%python.command.python.datascience.notebookeditor.runselectedcell.title%",
+                "category": "Python"
+            },
+            {
+                "command": "python.datascience.notebookeditor.addcellbelow",
+                "title": "%python.command.python.datascience.notebookeditor.addcellbelow.title%",
+                "category": "Python"
+            },
             {
                 "command": "python.datascience.expandallcells",
                 "title": "%python.command.python.datascience.expandallcells.title%",
@@ -773,7 +788,25 @@
                     "command": "python.datascience.runallcells",
                     "title": "%python.command.python.datascience.runallcells.title%",
                     "category": "Python",
-                    "when": "python.datascience.featureenabled"
+                    "when": "python.datascience.hascodecells && python.datascience.featureenabled"
+                },
+                {
+                    "command": "python.datascience.scrolltocell",
+                    "title": "%python.command.python.datascience.scrolltocell.title%",
+                    "category": "Python",
+                    "when": "false"
+                },
+                {
+                    "command": "python.datascience.debugcell",
+                    "title": "%python.command.python.datascience.debugcell.title%",
+                    "category": "Python",
+                    "when": "python.datascience.hascodecells && python.datascience.featureenabled"
+                },
+                {
+                    "command": "python.datascience.runcell",
+                    "title": "%python.command.python.datascience.runcell.title%",
+                    "category": "Python",
+                    "when": "python.datascience.hascodecells && python.datascience.featureenabled"
                 },
                 {
                     "command": "python.datascience.runFileInteractive",
@@ -853,7 +886,7 @@
                 },
                 {
                     "command": "python.datascience.notebookeditor.removeallcells",
-                    "title": "%python.command.python.datascience.removeallcells.title%",
+                    "title": "%python.command.python.datascience.notebookeditor.removeallcells.title%",
                     "category": "Python",
                     "when": "python.datascience.havenativecells && python.datascience.featureenabled"
                 },
@@ -869,6 +902,24 @@
                     "category": "Python",
                     "when": "python.datascience.havenative && python.datascience.featureenabled"
                 },
+                {
+                    "command": "python.datascience.notebookeditor.runallcells",
+                    "title": "%python.command.python.datascience.notebookeditor.runallcells.title%",
+                    "category": "Python",
+                    "when": "python.datascience.havenative && python.datascience.featureenabled"
+                },
+                {
+                    "command": "python.datascience.notebookeditor.runselectedcell",
+                    "title": "%python.command.python.datascience.notebookeditor.runselectedcell.title%",
+                    "category": "Python",
+                    "when": "python.datascience.havenative && python.datascience.featureenabled && python.datascience.havecellselected"
+                },
+                {
+                    "command": "python.datascience.notebookeditor.addcellbelow",
+                    "title": "%python.command.python.datascience.notebookeditor.addcellbelow.title%",
+                    "category": "Python",
+                    "when": "python.datascience.havenative && python.datascience.featureenabled"
+                },
                 {
                     "command": "python.datascience.expandallcells",
                     "title": "%python.command.python.datascience.expandallcells.title%",
@@ -901,7 +952,7 @@
                     "command": "python.datascience.addcellbelow",
                     "title": "%python.command.python.datascience.addcellbelow.title%",
                     "category": "Python",
-                    "when": "python.datascience.featureenabled"
+                    "when": "python.datascience.hascodecells && python.datascience.featureenabled"
                 },
                 {
                     "command": "python.datascience.createnewnotebook",
diff --git a/package.nls.json b/package.nls.json
index dff61841145d..701a7f71f1ee 100644
--- a/package.nls.json
+++ b/package.nls.json
@@ -33,6 +33,7 @@
     "python.command.python.datascience.runFileInteractive.title": "Run Current File in Python Interactive Window",
     "python.command.python.datascience.debugFileInteractive.title": "Debug Current File in Python Interactive Window",
     "python.command.python.datascience.runallcells.title": "Run All Cells",
+    "python.command.python.datascience.notebookeditor.runallcells.title": "Run All Notebook Cells",
     "python.command.python.datascience.runallcellsabove.title": "Run Above",
     "python.command.python.datascience.runcellandallbelow.title": "Run Below",
     "python.command.python.datascience.runallcellsabove.palette.title": "Run Cells Above Current Cell",
@@ -60,6 +61,9 @@
     "python.command.python.datascience.undocells.title": "Undo Last Python Interactive Action",
     "python.command.python.datascience.redocells.title": "Redo Last Python Interactive Action",
     "python.command.python.datascience.removeallcells.title": "Delete All Python Interactive Cells",
+    "python.command.python.datascience.notebookeditor.removeallcells.title": "Delete All Notebook Editor Cells",
+    "python.command.python.datascience.notebookeditor.runselectedcell.title": "Run Selected Notebook Cell",
+    "python.command.python.datascience.notebookeditor.addcellbelow.title": "Add Empty Cell to Notebook File",
     "python.command.python.datascience.interruptkernel.title": "Interrupt IPython Kernel",
     "python.command.python.datascience.restartkernel.title": "Restart IPython Kernel",
     "python.command.python.datascience.expandallcells.title": "Expand All Python Interactive Cells",
diff --git a/src/client/common/application/commands.ts b/src/client/common/application/commands.ts
index b452796c7ecc..607e7098febb 100644
--- a/src/client/common/application/commands.ts
+++ b/src/client/common/application/commands.ts
@@ -58,6 +58,9 @@ interface ICommandNameWithoutArgumentTypeMapping {
     [DSCommands.NotebookEditorRemoveAllCells]: [];
     [DSCommands.NotebookEditorInterruptKernel]: [];
     [DSCommands.NotebookEditorRestartKernel]: [];
+    [DSCommands.NotebookEditorRunAllCells]: [];
+    [DSCommands.NotebookEditorRunSelectedCell]: [];
+    [DSCommands.NotebookEditorAddCellBelow]: [];
     [DSCommands.ExpandAllCells]: [];
     [DSCommands.CollapseAllCells]: [];
     [DSCommands.ExportOutputAsNotebook]: [];
diff --git a/src/client/datascience/constants.ts b/src/client/datascience/constants.ts
index 6b22853385a8..6bc7f42a4772 100644
--- a/src/client/datascience/constants.ts
+++ b/src/client/datascience/constants.ts
@@ -35,6 +35,9 @@ export namespace Commands {
     export const NotebookEditorRemoveAllCells = 'python.datascience.notebookeditor.removeallcells';
     export const NotebookEditorInterruptKernel = 'python.datascience.notebookeditor.interruptkernel';
     export const NotebookEditorRestartKernel = 'python.datascience.notebookeditor.restartkernel';
+    export const NotebookEditorRunAllCells = 'python.datascience.notebookeditor.runallcells';
+    export const NotebookEditorRunSelectedCell = 'python.datascience.notebookeditor.runselectedcell';
+    export const NotebookEditorAddCellBelow = 'python.datascience.notebookeditor.addcellbelow';
     export const ExpandAllCells = 'python.datascience.expandallcells';
     export const CollapseAllCells = 'python.datascience.collapseallcells';
     export const ExportOutputAsNotebook = 'python.datascience.exportoutputasnotebook';
@@ -71,6 +74,7 @@ export namespace EditorContexts {
     export const HaveNativeCells = 'python.datascience.havenativecells';
     export const HaveNativeRedoableCells = 'python.datascience.havenativeredoablecells';
     export const HaveNative = 'python.datascience.havenative';
+    export const HaveCellSelected = 'python.datascience.havecellselected';
 }
 
 export namespace RegExpValues {
diff --git a/src/client/datascience/interactive-common/interactiveWindowTypes.ts b/src/client/datascience/interactive-common/interactiveWindowTypes.ts
index c46a6bad5dd3..203dbdd470bc 100644
--- a/src/client/datascience/interactive-common/interactiveWindowTypes.ts
+++ b/src/client/datascience/interactive-common/interactiveWindowTypes.ts
@@ -72,7 +72,9 @@ export namespace InteractiveWindowMessages {
     export const SaveAll = 'save_all';
     export const NativeCommand = 'native_command';
     export const VariablesComplete = 'variables_complete';
-
+    export const NotebookRunAllCells = 'notebook_run_all_cells';
+    export const NotebookRunSelectedCell = 'notebook_run_selected_cell';
+    export const NotebookAddCellBelow = 'notebook_add_cell_below';
 }
 
 export enum NativeCommandType {
@@ -318,4 +320,7 @@ export class IInteractiveWindowMapping {
     public [InteractiveWindowMessages.SaveAll]: ISaveAll;
     public [InteractiveWindowMessages.NativeCommand]: INativeCommand;
     public [InteractiveWindowMessages.VariablesComplete]: never | undefined;
+    public [InteractiveWindowMessages.NotebookRunAllCells]: never | undefined;
+    public [InteractiveWindowMessages.NotebookRunSelectedCell]: never | undefined;
+    public [InteractiveWindowMessages.NotebookAddCellBelow]: never | undefined;
 }
diff --git a/src/client/datascience/interactive-ipynb/nativeEditor.ts b/src/client/datascience/interactive-ipynb/nativeEditor.ts
index 84442ab6127d..affa86420c7c 100644
--- a/src/client/datascience/interactive-ipynb/nativeEditor.ts
+++ b/src/client/datascience/interactive-ipynb/nativeEditor.ts
@@ -225,6 +225,18 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
         return this.ipynbProvider.getNotebookOptions();
     }
 
+    public runAllCells() {
+        this.postMessage(InteractiveWindowMessages.NotebookRunAllCells).ignoreErrors();
+    }
+
+    public runSelectedCell() {
+        this.postMessage(InteractiveWindowMessages.NotebookRunSelectedCell).ignoreErrors();
+    }
+
+    public addCellBelow() {
+        this.postMessage(InteractiveWindowMessages.NotebookAddCellBelow).ignoreErrors();
+    }
+
     protected async reopen(cells: ICell[]): Promise<void> {
         try {
             super.reload();
@@ -340,10 +352,13 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
             interactiveContext.set(!this.isDisposed).catch();
             const interactiveCellsContext = new ContextKey(EditorContexts.HaveNativeCells, this.commandManager);
             const redoableContext = new ContextKey(EditorContexts.HaveNativeRedoableCells, this.commandManager);
+            const hasCellSelectedContext = new ContextKey(EditorContexts.HaveCellSelected, this.commandManager);
             if (info) {
                 interactiveCellsContext.set(info.cellCount > 0).catch();
                 redoableContext.set(info.redoCount > 0).catch();
+                hasCellSelectedContext.set(info.selectedCell ? true : false).catch();
             } else {
+                hasCellSelectedContext.set(false).catch();
                 interactiveCellsContext.set(false).catch();
                 redoableContext.set(false).catch();
             }
diff --git a/src/client/datascience/interactive-ipynb/nativeEditorCommandListener.ts b/src/client/datascience/interactive-ipynb/nativeEditorCommandListener.ts
index 91fd2edcf157..ef299391a252 100644
--- a/src/client/datascience/interactive-ipynb/nativeEditorCommandListener.ts
+++ b/src/client/datascience/interactive-ipynb/nativeEditorCommandListener.ts
@@ -32,6 +32,30 @@ export class NativeEditorCommandListener implements IDataScienceCommandListener
         this.disposableRegistry.push(commandManager.registerCommand(Commands.NotebookEditorInterruptKernel, () => this.interruptKernel()));
         this.disposableRegistry.push(commandManager.registerCommand(Commands.NotebookEditorRestartKernel, () => this.restartKernel()));
         this.disposableRegistry.push(commandManager.registerCommand(Commands.OpenNotebook, (file?: Uri, _cmdSource: CommandSource = CommandSource.commandPalette) => this.openNotebook(file)));
+        this.disposableRegistry.push(commandManager.registerCommand(Commands.NotebookEditorRunAllCells, () => this.runAllCells()));
+        this.disposableRegistry.push(commandManager.registerCommand(Commands.NotebookEditorRunSelectedCell, () => this.runSelectedCell()));
+        this.disposableRegistry.push(commandManager.registerCommand(Commands.NotebookEditorAddCellBelow, () => this.addCellBelow()));
+    }
+
+    private runAllCells() {
+        const activeEditor = this.provider.activeEditor;
+        if (activeEditor) {
+            activeEditor.runAllCells();
+        }
+    }
+
+    private runSelectedCell() {
+        const activeEditor = this.provider.activeEditor;
+        if (activeEditor) {
+            activeEditor.runSelectedCell();
+        }
+    }
+
+    private addCellBelow() {
+        const activeEditor = this.provider.activeEditor;
+        if (activeEditor) {
+            activeEditor.addCellBelow();
+        }
     }
 
     private undoCells() {
diff --git a/src/client/datascience/interactive-window/interactiveWindow.ts b/src/client/datascience/interactive-window/interactiveWindow.ts
index 2be69ec9d633..b76b2a06cbb1 100644
--- a/src/client/datascience/interactive-window/interactiveWindow.ts
+++ b/src/client/datascience/interactive-window/interactiveWindow.ts
@@ -235,12 +235,15 @@ export class InteractiveWindow extends InteractiveBase implements IInteractiveWi
             interactiveContext.set(!this.isDisposed).catch();
             const interactiveCellsContext = new ContextKey(EditorContexts.HaveInteractiveCells, this.commandManager);
             const redoableContext = new ContextKey(EditorContexts.HaveRedoableCells, this.commandManager);
+            const hasCellSelectedContext = new ContextKey(EditorContexts.HaveCellSelected, this.commandManager);
             if (info) {
                 interactiveCellsContext.set(info.cellCount > 0).catch();
                 redoableContext.set(info.redoCount > 0).catch();
+                hasCellSelectedContext.set(info.selectedCell ? true : false).catch();
             } else {
                 interactiveCellsContext.set(false).catch();
                 redoableContext.set(false).catch();
+                hasCellSelectedContext.set(false).catch();
             }
         }
     }
diff --git a/src/client/datascience/types.ts b/src/client/datascience/types.ts
index 637df00766f9..f0edda8be83b 100644
--- a/src/client/datascience/types.ts
+++ b/src/client/datascience/types.ts
@@ -254,6 +254,9 @@ export interface INotebookEditor extends IInteractiveBase {
     readonly visible: boolean;
     readonly active: boolean;
     load(contents: string, file: Uri): Promise<void>;
+    runAllCells(): void;
+    runSelectedCell(): void;
+    addCellBelow(): void;
 }
 
 export const IInteractiveWindowListener = Symbol('IInteractiveWindowListener');
@@ -347,6 +350,7 @@ export interface IInteractiveWindowInfo {
     undoCount: number;
     redoCount: number;
     visibleCells: ICell[];
+    selectedCell: string | undefined;
 }
 
 export interface IMessageCell extends nbformat.IBaseCell {
diff --git a/src/datascience-ui/interactive-common/mainStateController.ts b/src/datascience-ui/interactive-common/mainStateController.ts
index 6878373735bd..f8262f0b81d3 100644
--- a/src/datascience-ui/interactive-common/mainStateController.ts
+++ b/src/datascience-ui/interactive-common/mainStateController.ts
@@ -1080,7 +1080,8 @@ export class MainStateController implements IMessageHandler {
             visibleCells: this.getNonEditCellVMs().map(cvm => cvm.cell),
             cellCount: this.getNonEditCellVMs().length,
             undoCount: this.pendingState.undoStack.length,
-            redoCount: this.pendingState.redoStack.length
+            redoCount: this.pendingState.redoStack.length,
+            selectedCell: this.pendingState.selectedCellId
         };
         this.sendMessage(InteractiveWindowMessages.SendInfo, info);
     }
diff --git a/src/datascience-ui/native-editor/nativeEditorStateController.ts b/src/datascience-ui/native-editor/nativeEditorStateController.ts
index 7ed47506dd2c..371939f22781 100644
--- a/src/datascience-ui/native-editor/nativeEditorStateController.ts
+++ b/src/datascience-ui/native-editor/nativeEditorStateController.ts
@@ -43,6 +43,18 @@ export class NativeEditorStateController extends MainStateController {
                 this.waitingForLoadRender = true;
                 break;
 
+            case InteractiveWindowMessages.NotebookRunAllCells:
+                this.runAll();
+                break;
+
+            case InteractiveWindowMessages.NotebookRunSelectedCell:
+                this.runSelectedCell();
+                break;
+
+            case InteractiveWindowMessages.NotebookAddCellBelow:
+                this.addNewCell();
+                break;
+
             default:
                 break;
         }
@@ -82,6 +94,18 @@ export class NativeEditorStateController extends MainStateController {
         return index > 0 && cells.find((cvm, i) => i >= index && cvm.cell.data.cell_type === 'code');
     }
 
+    public runSelectedCell = () => {
+        const selectedCellId = this.getState().selectedCellId;
+
+        if (selectedCellId) {
+            const cells = this.getState().cellVMs;
+            const selectedCell = cells.find(cvm => cvm.cell.id === selectedCellId);
+            if (selectedCell) {
+                this.submitInput(concatMultilineString(selectedCell.cell.data.source), selectedCell);
+            }
+        }
+    }
+
     public runAll = () => {
         // Run all code cells (markdown don't need to be run)
         this.suspendUpdates();

From 672cae926cc2d3b6e1455fc137c53e2a17cb6cc6 Mon Sep 17 00:00:00 2001
From: Don Jayamanne <don.jayamanne@yahoo.com>
Date: Tue, 8 Oct 2019 10:17:27 -0700
Subject: [PATCH 14/36] Tests for keyboard shortcuts in native editor (#7797)

* Tests  for keyboard shortcuts
* Added some more tests
* Code review comments
* Fix merge issues
---
 .../interactive-common/cellOutput.tsx         |   2 +-
 .../react-common/monacoEditor.tsx             |   2 +-
 .../nativeEditor.functional.test.tsx          | 839 +++++++++++++-----
 .../datascience/nativeEditorTestHelpers.tsx   |  13 +-
 src/test/datascience/testHelpers.tsx          | 156 +++-
 5 files changed, 751 insertions(+), 261 deletions(-)

diff --git a/src/datascience-ui/interactive-common/cellOutput.tsx b/src/datascience-ui/interactive-common/cellOutput.tsx
index a07f46b6afac..9f201f0e8772 100644
--- a/src/datascience-ui/interactive-common/cellOutput.tsx
+++ b/src/datascience-ui/interactive-common/cellOutput.tsx
@@ -174,7 +174,7 @@ export class CellOutput extends React.Component<ICellOutputProps> {
         const Transform = transforms['text/markdown'];
         const MarkdownClassName = 'markdown-cell-output';
 
-        return [<div className={MarkdownClassName}><Transform key={0} data={source} /></div>];
+        return [<div key={0} className={MarkdownClassName}><Transform key={0} data={source} /></div>];
     }
 
     // tslint:disable-next-line: max-func-body-length
diff --git a/src/datascience-ui/react-common/monacoEditor.tsx b/src/datascience-ui/react-common/monacoEditor.tsx
index 28430bc99677..35f5c1c778f4 100644
--- a/src/datascience-ui/react-common/monacoEditor.tsx
+++ b/src/datascience-ui/react-common/monacoEditor.tsx
@@ -33,7 +33,7 @@ export interface IMonacoEditorProps {
     lineCountChanged(newCount: number): void;
 }
 
-interface IMonacoEditorState {
+export interface IMonacoEditorState {
     editor?: monacoEditor.editor.IStandaloneCodeEditor;
     model: monacoEditor.editor.ITextModel | null;
     visibleLineCount: number;
diff --git a/src/test/datascience/nativeEditor.functional.test.tsx b/src/test/datascience/nativeEditor.functional.test.tsx
index 8fcc845afb86..973219361639 100644
--- a/src/test/datascience/nativeEditor.functional.test.tsx
+++ b/src/test/datascience/nativeEditor.functional.test.tsx
@@ -1,11 +1,14 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
+
 'use strict';
+
 import * as assert from 'assert';
+import { ReactWrapper } from 'enzyme';
+import * as monacoEditor from 'monaco-editor/esm/vs/editor/editor.api';
 import * as path from 'path';
 import * as TypeMoq from 'typemoq';
 import { Disposable, TextDocument, TextEditor, Uri } from 'vscode';
-
 import { IApplicationShell, IDocumentManager } from '../../client/common/application/types';
 import { createDeferred } from '../../client/common/utils/async';
 import { noop } from '../../client/common/utils/misc';
@@ -13,288 +16,648 @@ import { Identifiers } from '../../client/datascience/constants';
 import { JupyterExecutionFactory } from '../../client/datascience/jupyter/jupyterExecutionFactory';
 import { ICell, IJupyterExecution, INotebookEditorProvider, INotebookExporter } from '../../client/datascience/types';
 import { PythonInterpreter } from '../../client/interpreter/contracts';
+import { CellInput } from '../../datascience-ui/interactive-common/cellInput';
+import { CellOutput } from '../../datascience-ui/interactive-common/cellOutput';
+import { Editor } from '../../datascience-ui/interactive-common/editor';
+import { NativeCell } from '../../datascience-ui/native-editor/nativeCell';
 import { NativeEditor } from '../../datascience-ui/native-editor/nativeEditor';
+import { IKeyboardEvent } from '../../datascience-ui/react-common/event';
 import { ImageButton } from '../../datascience-ui/react-common/imageButton';
+import { IMonacoEditorState, MonacoEditor } from '../../datascience-ui/react-common/monacoEditor';
 import { DataScienceIocContainer } from './dataScienceIocContainer';
 import {
     addCell,
     closeNotebook,
     createNewEditor,
     getNativeCellResults,
-    mountNativeWebView,
-    openEditor,
-    runMountedTest
-} from './nativeEditorTestHelpers';
+    mountNativeWebView, openEditor, runMountedTest, setupWebview } from './nativeEditorTestHelpers';
 import { waitForUpdate } from './reactHelpers';
 import {
     addContinuousMockData,
     addMockData,
     CellPosition,
+    createKeyboardEventForCell,
     escapePath,
     findButton,
     getLastOutputCell,
+    isCellFocused,
+    isCellSelected,
     srcDirectory,
+    verifyCellIndex,
     verifyHtmlOnCell,
     waitForMessageResponse
 } from './testHelpers';
 
 //import { asyncDump } from '../common/asyncDump';
 // tslint:disable:max-func-body-length trailing-comma no-any no-multiline-string
-suite('DataScience Native Editor tests', () => {
-    const disposables: Disposable[] = [];
-    let ioc: DataScienceIocContainer;
-
-    setup(() => {
-        ioc = new DataScienceIocContainer();
-        ioc.registerDataScienceTypes();
-
-        const appShell = TypeMoq.Mock.ofType<IApplicationShell>();
-        appShell.setup(a => a.showErrorMessage(TypeMoq.It.isAnyString())).returns((_e) => Promise.resolve(''));
-        appShell.setup(a => a.showInformationMessage(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(''));
-        appShell.setup(a => a.showInformationMessage(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((_a1: string, a2: string, _a3: string) => Promise.resolve(a2));
-        appShell.setup(a => a.showInformationMessage(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((_a1: string, _a2: any, _a3: string, a4: string) => Promise.resolve(a4));
-        appShell.setup(a => a.showSaveDialog(TypeMoq.It.isAny())).returns(() => Promise.resolve(Uri.file('foo.ipynb')));
-        ioc.serviceManager.rebindInstance<IApplicationShell>(IApplicationShell, appShell.object);
+suite('DataScience Native Editor', () => {
+
+    function createFileCell(cell: any, data: any): ICell {
+        const newCell = { type: 'preview', id: 'FakeID', file: Identifiers.EmptyFileName, line: 0, state: 2, ...cell};
+        newCell.data = { cell_type: 'code', execution_count: null, metadata: {}, outputs: [], source: '', ...data };
+
+        return newCell;
+    }
+    suite('Editor tests', () => {
+        const disposables: Disposable[] = [];
+        let ioc: DataScienceIocContainer;
+
+        setup(() => {
+            ioc = new DataScienceIocContainer();
+            ioc.registerDataScienceTypes();
+
+            const appShell = TypeMoq.Mock.ofType<IApplicationShell>();
+            appShell.setup(a => a.showErrorMessage(TypeMoq.It.isAnyString())).returns((_e) => Promise.resolve(''));
+            appShell.setup(a => a.showInformationMessage(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(''));
+            appShell.setup(a => a.showInformationMessage(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((_a1: string, a2: string, _a3: string) => Promise.resolve(a2));
+            appShell.setup(a => a.showInformationMessage(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns((_a1: string, _a2: any, _a3: string, a4: string) => Promise.resolve(a4));
+            appShell.setup(a => a.showSaveDialog(TypeMoq.It.isAny())).returns(() => Promise.resolve(Uri.file('foo.ipynb')));
+            ioc.serviceManager.rebindInstance<IApplicationShell>(IApplicationShell, appShell.object);
 
+        });
+
+        teardown(async () => {
+            for (const disposable of disposables) {
+                if (!disposable) {
+                    continue;
+                }
+                // tslint:disable-next-line:no-any
+                const promise = disposable.dispose() as Promise<any>;
+                if (promise) {
+                    await promise;
+                }
+            }
+            await ioc.dispose();
+        });
+
+        // Uncomment this to debug hangs on exit
+        // suiteTeardown(() => {
+        //      asyncDump();
+        // });
+
+        runMountedTest('Simple text', async (wrapper) => {
+            // Create an editor so something is listening to messages
+            await createNewEditor(ioc);
+
+            // Add a cell into the UI and wait for it to render
+            await addCell(wrapper, 'a=1\na');
+
+            verifyHtmlOnCell(wrapper, 'NativeCell', '<span>1</span>', CellPosition.Last);
+        }, () => { return ioc; });
+
+        runMountedTest('Mime Types', async (wrapper) => {
+            // Create an editor so something is listening to messages
+            await createNewEditor(ioc);
+
+            const badPanda = `import pandas as pd
+    df = pd.read("${escapePath(path.join(srcDirectory(), 'DefaultSalesReport.csv'))}")
+    df.head()`;
+            const goodPanda = `import pandas as pd
+    df = pd.read_csv("${escapePath(path.join(srcDirectory(), 'DefaultSalesReport.csv'))}")
+    df.head()`;
+            const matPlotLib = 'import matplotlib.pyplot as plt\r\nimport numpy as np\r\nx = np.linspace(0,20,100)\r\nplt.plot(x, np.sin(x))\r\nplt.show()';
+            const matPlotLibResults = 'img';
+            const spinningCursor = `import sys
+    import time
+    def spinning_cursor():
+        while True:
+            for cursor in '|/-\\\\':
+                yield cursor
+    spinner = spinning_cursor()
+    for _ in range(50):
+        sys.stdout.write(next(spinner))
+        sys.stdout.flush()
+        time.sleep(0.1)
+        sys.stdout.write('\\r')`;
+
+            addMockData(ioc, badPanda, `pandas has no attribute 'read'`, 'text/html', 'error');
+            addMockData(ioc, goodPanda, `<td>A table</td>`, 'text/html');
+            addMockData(ioc, matPlotLib, matPlotLibResults, 'text/html');
+            const cursors = ['|', '/', '-', '\\'];
+            let cursorPos = 0;
+            let loops = 3;
+            addContinuousMockData(ioc, spinningCursor, async (_c) => {
+                const result = `${cursors[cursorPos]}\r`;
+                cursorPos += 1;
+                if (cursorPos >= cursors.length) {
+                    cursorPos = 0;
+                    loops -= 1;
+                }
+                return Promise.resolve({ result: result, haveMore: loops > 0 });
+            });
+
+            await addCell(wrapper, badPanda, true);
+            verifyHtmlOnCell(wrapper, 'NativeCell', `has no attribute 'read'`, CellPosition.Last);
+
+            await addCell(wrapper, goodPanda, true);
+            verifyHtmlOnCell(wrapper, 'NativeCell', `<td>`, CellPosition.Last);
+
+            await addCell(wrapper, matPlotLib, true, 6);
+            verifyHtmlOnCell(wrapper, 'NativeCell', matPlotLibResults, CellPosition.Last);
+
+            await addCell(wrapper, spinningCursor, true, 4 + (ioc.mockJupyter ? (cursors.length * 3) : 50));
+            verifyHtmlOnCell(wrapper, 'NativeCell', '<div>', CellPosition.Last);
+        }, () => { return ioc; });
+
+        runMountedTest('Click buttons', async (wrapper) => {
+            // Goto source should cause the visible editor to be picked as long as its filename matches
+            const showedEditor = createDeferred();
+            const textEditors: TextEditor[] = [];
+            const docManager = TypeMoq.Mock.ofType<IDocumentManager>();
+            const visibleEditor = TypeMoq.Mock.ofType<TextEditor>();
+            const dummyDocument = TypeMoq.Mock.ofType<TextDocument>();
+            dummyDocument.setup(d => d.fileName).returns(() => 'foo.py');
+            visibleEditor.setup(v => v.show()).returns(() => showedEditor.resolve());
+            visibleEditor.setup(v => v.revealRange(TypeMoq.It.isAny())).returns(noop);
+            visibleEditor.setup(v => v.document).returns(() => dummyDocument.object);
+            textEditors.push(visibleEditor.object);
+            docManager.setup(a => a.visibleTextEditors).returns(() => textEditors);
+            ioc.serviceManager.rebindInstance<IDocumentManager>(IDocumentManager, docManager.object);
+            // Create an editor so something is listening to messages
+            await createNewEditor(ioc);
+
+            // Get a cell into the list
+            await addCell(wrapper, 'a=1\na');
+
+            // find the buttons on the cell itself
+            let cell = getLastOutputCell(wrapper, 'NativeCell');
+            let ImageButtons = cell.find(ImageButton);
+            assert.equal(ImageButtons.length, 7, 'Cell buttons not found');
+            let deleteButton = ImageButtons.at(6);
+
+            // Make sure delete works
+            let afterDelete = await getNativeCellResults(wrapper, 1, async () => {
+                deleteButton.simulate('click');
+                return Promise.resolve();
+            });
+            assert.equal(afterDelete.length, 1, `Delete should remove a cell`);
+
+            // Secondary delete should NOT delete the cell as there should ALWAYS be at
+            // least one cell in the file.
+            cell = getLastOutputCell(wrapper, 'NativeCell');
+            ImageButtons = cell.find(ImageButton);
+            assert.equal(ImageButtons.length, 7, 'Cell buttons not found');
+            deleteButton = ImageButtons.at(6);
+
+            afterDelete = await getNativeCellResults(wrapper, 1, async () => {
+                deleteButton.simulate('click');
+                return Promise.resolve();
+            });
+            assert.equal(afterDelete.length, 1, `Delete should NOT remove the last cell`);
+        }, () => { return ioc; });
+
+        runMountedTest('Export', async (wrapper) => {
+            // Export should cause the export dialog to come up. Remap appshell so we can check
+            const dummyDisposable = {
+                dispose: () => { return; }
+            };
+            let exportCalled = false;
+            const appShell = TypeMoq.Mock.ofType<IApplicationShell>();
+            appShell.setup(a => a.showErrorMessage(TypeMoq.It.isAnyString())).returns((e) => { throw e; });
+            appShell.setup(a => a.showInformationMessage(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(''));
+            appShell.setup(a => a.showSaveDialog(TypeMoq.It.isAny())).returns(() => {
+                exportCalled = true;
+                return Promise.resolve(undefined);
+            });
+            appShell.setup(a => a.setStatusBarMessage(TypeMoq.It.isAny())).returns(() => dummyDisposable);
+            ioc.serviceManager.rebindInstance<IApplicationShell>(IApplicationShell, appShell.object);
+
+            // Make sure to create the interactive window after the rebind or it gets the wrong application shell.
+            await createNewEditor(ioc);
+            await addCell(wrapper, 'a=1\na');
+
+            // Export should cause exportCalled to change to true
+            const exportButton = findButton(wrapper, NativeEditor, 6);
+            await waitForMessageResponse(ioc, () => exportButton!.simulate('click'));
+            assert.equal(exportCalled, true, 'Export should have been called');
+        }, () => { return ioc; });
+
+        runMountedTest('RunAllCells', async (wrapper) => {
+            addMockData(ioc, 'b=2\nb', 2);
+            addMockData(ioc, 'c=3\nc', 3);
+
+            const baseFile = [ {id: 'NotebookImport#0', data: {source: 'a=1\na'}},
+            {id: 'NotebookImport#1', data: {source: 'b=2\nb'}},
+            {id: 'NotebookImport#2', data: {source: 'c=3\nc'}} ];
+            const runAllCells =  baseFile.map(cell => {
+                return createFileCell(cell, cell.data);
+            });
+            const notebook = await ioc.get<INotebookExporter>(INotebookExporter).translateToNotebook(runAllCells, undefined);
+            await openEditor(ioc, JSON.stringify(notebook));
+
+            // Export should cause exportCalled to change to true
+            const runAllButton = findButton(wrapper, NativeEditor, 3);
+            await waitForMessageResponse(ioc, () => runAllButton!.simulate('click'));
+
+            await waitForUpdate(wrapper, NativeEditor, 16);
+
+            verifyHtmlOnCell(wrapper, 'NativeCell', `1`, 0);
+            verifyHtmlOnCell(wrapper, 'NativeCell', `2`, 1);
+            verifyHtmlOnCell(wrapper, 'NativeCell', `3`, 2);
+        }, () => { return ioc; });
+
+        runMountedTest('Startup and shutdown', async (wrapper) => {
+            addMockData(ioc, 'b=2\nb', 2);
+            addMockData(ioc, 'c=3\nc', 3);
+
+            const baseFile = [ {id: 'NotebookImport#0', data: {source: 'a=1\na'}},
+            {id: 'NotebookImport#1', data: {source: 'b=2\nb'}},
+            {id: 'NotebookImport#2', data: {source: 'c=3\nc'}} ];
+            const runAllCells =  baseFile.map(cell => {
+                return createFileCell(cell, cell.data);
+            });
+            const notebook = await ioc.get<INotebookExporter>(INotebookExporter).translateToNotebook(runAllCells, undefined);
+            let editor = await openEditor(ioc, JSON.stringify(notebook));
+
+            // Run everything
+            let runAllButton = findButton(wrapper, NativeEditor, 3);
+            await waitForMessageResponse(ioc, () => runAllButton!.simulate('click'));
+            await waitForUpdate(wrapper, NativeEditor, 16);
+
+            // Close editor. Should still have the server up
+            await closeNotebook(editor, wrapper);
+            const jupyterExecution = ioc.serviceManager.get<IJupyterExecution>(IJupyterExecution);
+            const editorProvider = ioc.serviceManager.get<INotebookEditorProvider>(INotebookEditorProvider);
+            const server = await jupyterExecution.getServer(await editorProvider.getNotebookOptions());
+            assert.ok(server, 'Server was destroyed on notebook shutdown');
+
+            // Reopen, and rerun
+            editor = await openEditor(ioc, JSON.stringify(notebook));
+            runAllButton = findButton(wrapper, NativeEditor, 3);
+            await waitForMessageResponse(ioc, () => runAllButton!.simulate('click'));
+            await waitForUpdate(wrapper, NativeEditor, 15);
+            verifyHtmlOnCell(wrapper, 'NativeCell', `1`, 0);
+        }, () => { return ioc; });
+
+        test('Failure', async () => {
+            // Make a dummy class that will fail during launch
+            class FailedProcess extends JupyterExecutionFactory {
+                public getUsableJupyterPython(): Promise<PythonInterpreter | undefined> {
+                    return Promise.resolve(undefined);
+                }
+            }
+            ioc.serviceManager.rebind<IJupyterExecution>(IJupyterExecution, FailedProcess);
+            ioc.serviceManager.get<IJupyterExecution>(IJupyterExecution);
+            addMockData(ioc, 'a=1\na', 1);
+            const wrapper = mountNativeWebView(ioc);
+            await createNewEditor(ioc);
+            await addCell(wrapper, 'a=1\na', true, 2);
+
+            // Cell should not have the output
+            verifyHtmlOnCell(wrapper, 'NativeCell', 'Jupyter cannot be started', CellPosition.Last);
+        });
     });
 
-    teardown(async () => {
-        for (const disposable of disposables) {
-            if (!disposable) {
-                continue;
+    suite('Editor Keyboard tests', () => {
+        let wrapper: ReactWrapper<any, Readonly<{}>, React.Component>;
+        const disposables: Disposable[] = [];
+        let ioc: DataScienceIocContainer;
+        const baseFile = [
+            { id: 'NotebookImport#0', data: { source: 'a=1\na' } },
+            { id: 'NotebookImport#1', data: { source: 'b=2\nb' } },
+            { id: 'NotebookImport#2', data: { source: 'c=3\nc' } }
+        ];
+        setup(async function() {
+            ioc = new DataScienceIocContainer();
+            ioc.registerDataScienceTypes();
+            const wrapperPossiblyUndefined = await setupWebview(ioc);
+            if (wrapperPossiblyUndefined) {
+                wrapper = wrapperPossiblyUndefined;
+
+                addMockData(ioc, 'b=2\nb', 2);
+                addMockData(ioc, 'c=3\nc', 3);
+
+                const runAllCells = baseFile.map(cell => {
+                    return createFileCell(cell, cell.data);
+                });
+                const notebook = await ioc.get<INotebookExporter>(INotebookExporter).translateToNotebook(runAllCells, undefined);
+                await Promise.all([waitForUpdate(wrapper, NativeEditor, 1), openEditor(ioc, JSON.stringify(notebook))]);
+            } else {
+                // tslint:disable-next-line: no-invalid-this
+                this.skip();
             }
-            // tslint:disable-next-line:no-any
-            const promise = disposable.dispose() as Promise<any>;
-            if (promise) {
-                await promise;
+        });
+
+        teardown(async () => {
+            for (const disposable of disposables) {
+                if (!disposable) {
+                    continue;
+                }
+                // tslint:disable-next-line:no-any
+                const promise = disposable.dispose() as Promise<any>;
+                if (promise) {
+                    await promise;
+                }
             }
+            await ioc.dispose();
+        });
+
+        function clickCell(cellIndex: number) {
+            wrapper
+                .find(NativeCell)
+                .at(cellIndex)
+                .simulate('click');
+            wrapper.update();
+        }
+        function simulateKeyPressOnCell(cellIndex: number, keyboardEvent: Partial<IKeyboardEvent> & { code: string }) {
+            const event = { ...createKeyboardEventForCell(keyboardEvent), ...keyboardEvent };
+            wrapper
+                .find(NativeCell)
+                .at(cellIndex)
+                .find(CellInput)
+                .props().keyDown!(baseFile[cellIndex].id, event);
+            wrapper.update();
         }
-        await ioc.dispose();
-    });
 
-    // Uncomment this to debug hangs on exit
-    // suiteTeardown(() => {
-    //      asyncDump();
-    // });
+        test('None of the cells are selected by default', async () => {
+            assert.ok(!isCellSelected(wrapper, 'NativeCell', 0));
+            assert.ok(!isCellSelected(wrapper, 'NativeCell', 1));
+            assert.ok(!isCellSelected(wrapper, 'NativeCell', 2));
+        });
 
-    function createFileCell(cell: any, data: any): ICell {
-        const newCell = { type: 'preview', id: 'FakeID', file: Identifiers.EmptyFileName, line: 0, state: 2, ...cell};
-        newCell.data = { cell_type: 'code', execution_count: null, metadata: {}, outputs: [], source: '', ...data };
+        test('None of the cells are not focused by default', async () => {
+            assert.ok(!isCellFocused(wrapper, 'NativeCell', 0));
+            assert.ok(!isCellFocused(wrapper, 'NativeCell', 1));
+            assert.ok(!isCellFocused(wrapper, 'NativeCell', 2));
+        });
 
-        return newCell;
-    }
+        test('Select cells by clicking them', async () => {
+            // Click first cell, then second, then third.
+            clickCell(0);
+            assert.ok(isCellSelected(wrapper, 'NativeCell', 0));
+            assert.equal(isCellSelected(wrapper, 'NativeCell', 1), false);
+            assert.equal(isCellSelected(wrapper, 'NativeCell', 2), false);
+
+            clickCell(1);
+            assert.ok(isCellSelected(wrapper, 'NativeCell', 1));
+            assert.equal(isCellSelected(wrapper, 'NativeCell', 0), false);
+            assert.equal(isCellSelected(wrapper, 'NativeCell', 2), false);
+
+            clickCell(2);
+            assert.ok(isCellSelected(wrapper, 'NativeCell', 2));
+            assert.equal(isCellSelected(wrapper, 'NativeCell', 0), false);
+            assert.equal(isCellSelected(wrapper, 'NativeCell', 1), false);
+        });
 
-    runMountedTest('Simple text', async (wrapper) => {
-        // Create an editor so something is listening to messages
-        await createNewEditor(ioc);
-
-        // Add a cell into the UI and wait for it to render
-        await addCell(wrapper, 'a=1\na');
-
-        verifyHtmlOnCell(wrapper, 'NativeCell', '<span>1</span>', CellPosition.Last);
-    }, () => { return ioc; });
-
-    runMountedTest('Mime Types', async (wrapper) => {
-        // Create an editor so something is listening to messages
-        await createNewEditor(ioc);
-
-        const badPanda = `import pandas as pd
-df = pd.read("${escapePath(path.join(srcDirectory(), 'DefaultSalesReport.csv'))}")
-df.head()`;
-        const goodPanda = `import pandas as pd
-df = pd.read_csv("${escapePath(path.join(srcDirectory(), 'DefaultSalesReport.csv'))}")
-df.head()`;
-        const matPlotLib = 'import matplotlib.pyplot as plt\r\nimport numpy as np\r\nx = np.linspace(0,20,100)\r\nplt.plot(x, np.sin(x))\r\nplt.show()';
-        const matPlotLibResults = 'img';
-        const spinningCursor = `import sys
-import time
-
-def spinning_cursor():
-    while True:
-        for cursor in '|/-\\\\':
-            yield cursor
-
-spinner = spinning_cursor()
-for _ in range(50):
-    sys.stdout.write(next(spinner))
-    sys.stdout.flush()
-    time.sleep(0.1)
-    sys.stdout.write('\\r')`;
-
-        addMockData(ioc, badPanda, `pandas has no attribute 'read'`, 'text/html', 'error');
-        addMockData(ioc, goodPanda, `<td>A table</td>`, 'text/html');
-        addMockData(ioc, matPlotLib, matPlotLibResults, 'text/html');
-        const cursors = ['|', '/', '-', '\\'];
-        let cursorPos = 0;
-        let loops = 3;
-        addContinuousMockData(ioc, spinningCursor, async (_c) => {
-            const result = `${cursors[cursorPos]}\r`;
-            cursorPos += 1;
-            if (cursorPos >= cursors.length) {
-                cursorPos = 0;
-                loops -= 1;
+        test('Traverse cells by using ArrowUp and ArrowDown, k and j', async () => {
+            const keyCodesAndPositions = [
+                // When we press arrow down in the first cell, then second cell gets selected.
+                { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 0, expectedSelectedCell: 1 },
+                { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 1, expectedSelectedCell: 2 },
+                // Arrow down on last cell is a noop.
+                { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 2, expectedSelectedCell: 2 },
+                // When we press arrow up in the last cell, then second cell (from bottom) gets selected.
+                { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 2, expectedSelectedCell: 1 },
+                { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 1, expectedSelectedCell: 0 },
+                // Arrow up on last cell is a noop.
+                { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 0, expectedSelectedCell: 0 },
+
+                // Same tests as above with k and j.
+                { keyCode: 'j', cellIndexToPressKeysOn: 0, expectedSelectedCell: 1 },
+                { keyCode: 'j', cellIndexToPressKeysOn: 1, expectedSelectedCell: 2 },
+                // Arrow down on last cell is a noop.
+                { keyCode: 'j', cellIndexToPressKeysOn: 2, expectedSelectedCell: 2 },
+                { keyCode: 'k', cellIndexToPressKeysOn: 2, expectedSelectedCell: 1 },
+                { keyCode: 'k', cellIndexToPressKeysOn: 1, expectedSelectedCell: 0 },
+                // Arrow up on last cell is a noop.
+                { keyCode: 'k', cellIndexToPressKeysOn: 0, expectedSelectedCell: 0 }
+            ];
+
+            // keypress on first cell, then second, then third.
+            // Test navigation through all cells, by traversing up and down.
+            for (const testItem of keyCodesAndPositions) {
+                simulateKeyPressOnCell(testItem.cellIndexToPressKeysOn, { code: testItem.keyCode });
+
+                // Check if it is selected.
+                // Only the cell at the index should be selected, as that's what we click.
+                assert.ok(isCellSelected(wrapper, 'NativeCell', testItem.expectedSelectedCell) === true);
             }
-            return Promise.resolve({ result: result, haveMore: loops > 0 });
         });
 
-        await addCell(wrapper, badPanda, true);
-        verifyHtmlOnCell(wrapper, 'NativeCell', `has no attribute 'read'`, CellPosition.Last);
-
-        await addCell(wrapper, goodPanda, true);
-        verifyHtmlOnCell(wrapper, 'NativeCell', `<td>`, CellPosition.Last);
-
-        await addCell(wrapper, matPlotLib, true, 6);
-        verifyHtmlOnCell(wrapper, 'NativeCell', matPlotLibResults, CellPosition.Last);
-
-        await addCell(wrapper, spinningCursor, true, 4 + (ioc.mockJupyter ? (cursors.length * 3) : 50));
-        verifyHtmlOnCell(wrapper, 'NativeCell', '<div>', CellPosition.Last);
-    }, () => { return ioc; });
-
-    runMountedTest('Click buttons', async (wrapper) => {
-        // Goto source should cause the visible editor to be picked as long as its filename matches
-        const showedEditor = createDeferred();
-        const textEditors: TextEditor[] = [];
-        const docManager = TypeMoq.Mock.ofType<IDocumentManager>();
-        const visibleEditor = TypeMoq.Mock.ofType<TextEditor>();
-        const dummyDocument = TypeMoq.Mock.ofType<TextDocument>();
-        dummyDocument.setup(d => d.fileName).returns(() => 'foo.py');
-        visibleEditor.setup(v => v.show()).returns(() => showedEditor.resolve());
-        visibleEditor.setup(v => v.revealRange(TypeMoq.It.isAny())).returns(noop);
-        visibleEditor.setup(v => v.document).returns(() => dummyDocument.object);
-        textEditors.push(visibleEditor.object);
-        docManager.setup(a => a.visibleTextEditors).returns(() => textEditors);
-        ioc.serviceManager.rebindInstance<IDocumentManager>(IDocumentManager, docManager.object);
-        // Create an editor so something is listening to messages
-        await createNewEditor(ioc);
-
-        // Get a cell into the list
-        await addCell(wrapper, 'a=1\na');
-
-        // find the buttons on the cell itself
-        let cell = getLastOutputCell(wrapper, 'NativeCell');
-        let ImageButtons = cell.find(ImageButton);
-        assert.equal(ImageButtons.length, 7, 'Cell buttons not found');
-        let deleteButton = ImageButtons.at(6);
-
-        // Make sure delete works
-        let afterDelete = await getNativeCellResults(wrapper, 1, async () => {
-            deleteButton.simulate('click');
-            return Promise.resolve();
+        test('Traverse cells by using ArrowUp and ArrowDown, k and j', async () => {
+            const keyCodesAndPositions = [
+                // When we press arrow down in the first cell, then second cell gets selected.
+                { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 0, expectedIndex: 1 },
+                { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 1, expectedIndex: 2 },
+                // Arrow down on last cell is a noop.
+                { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 2, expectedIndex: 2 },
+                // When we press arrow up in the last cell, then second cell (from bottom) gets selected.
+                { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 2, expectedIndex: 1 },
+                { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 1, expectedIndex: 0 },
+                // Arrow up on last cell is a noop.
+                { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 0, expectedIndex: 0 }
+            ];
+
+            // keypress on first cell, then second, then third.
+            // Test navigation through all cells, by traversing up and down.
+            for (const testItem of keyCodesAndPositions) {
+                simulateKeyPressOnCell(testItem.cellIndexToPressKeysOn, { code: testItem.keyCode });
+
+                // Check if it is selected.
+                // Only the cell at the index should be selected, as that's what we click.
+                assert.ok(isCellSelected(wrapper, 'NativeCell', testItem.expectedIndex) === true);
+            }
         });
-        assert.equal(afterDelete.length, 1, `Delete should remove a cell`);
-
-        // Secondary delete should NOT delete the cell as there should ALWAYS be at
-        // least one cell in the file.
-        cell = getLastOutputCell(wrapper, 'NativeCell');
-        ImageButtons = cell.find(ImageButton);
-        assert.equal(ImageButtons.length, 7, 'Cell buttons not found');
-        deleteButton = ImageButtons.at(6);
-
-        afterDelete = await getNativeCellResults(wrapper, 1, async () => {
-            deleteButton.simulate('click');
-            return Promise.resolve();
+
+        test('Pressing \'Enter\' on a selected cell, results in focus being set to the code', async () => {
+            // For some reason we cannot allow setting focus to monaco editor.
+            // Tests are known to fall over if allowed.
+            const editor = wrapper
+                .find(NativeCell)
+                .at(1)
+                .find(Editor)
+                .first();
+            (editor.instance() as Editor).giveFocus = () => editor.props().focused!();
+
+            const update = waitForUpdate(wrapper, NativeEditor, 1);
+            clickCell(1);
+            simulateKeyPressOnCell(1, { code: 'Enter', editorInfo: undefined });
+            await update;
+
+            // The second cell should be selected.
+            assert.ok(isCellFocused(wrapper, 'NativeCell', 1));
         });
-        assert.equal(afterDelete.length, 1, `Delete should NOT remove the last cell`);
-    }, () => { return ioc; });
-
-    runMountedTest('Export', async (wrapper) => {
-        // Export should cause the export dialog to come up. Remap appshell so we can check
-        const dummyDisposable = {
-            dispose: () => { return; }
-        };
-        let exportCalled = false;
-        const appShell = TypeMoq.Mock.ofType<IApplicationShell>();
-        appShell.setup(a => a.showErrorMessage(TypeMoq.It.isAnyString())).returns((e) => { throw e; });
-        appShell.setup(a => a.showInformationMessage(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(''));
-        appShell.setup(a => a.showSaveDialog(TypeMoq.It.isAny())).returns(() => {
-            exportCalled = true;
-            return Promise.resolve(undefined);
+
+        test('Pressing \'Escape\' on a focused cell results in the cell being selected', async () => {
+            // First focus the cell.
+            let update = waitForUpdate(wrapper, NativeEditor, 1);
+            clickCell(1);
+            simulateKeyPressOnCell(1, { code: 'Enter', editorInfo: undefined });
+            await update;
+
+            // The second cell should be selected.
+            assert.equal(isCellSelected(wrapper, 'NativeCell', 1), false);
+            assert.equal(isCellFocused(wrapper, 'NativeCell', 1), true);
+
+            // Now hit escape.
+            update = waitForUpdate(wrapper, NativeEditor, 1);
+            simulateKeyPressOnCell(1, { code: 'Escape' });
+            await update;
+
+            // Confirm it is no longer focused, and it is selected.
+            assert.equal(isCellSelected(wrapper, 'NativeCell', 1), true);
+            assert.equal(isCellFocused(wrapper, 'NativeCell', 1), false);
         });
-        appShell.setup(a => a.setStatusBarMessage(TypeMoq.It.isAny())).returns(() => dummyDisposable);
-        ioc.serviceManager.rebindInstance<IApplicationShell>(IApplicationShell, appShell.object);
-
-        // Make sure to create the interactive window after the rebind or it gets the wrong application shell.
-        await createNewEditor(ioc);
-        await addCell(wrapper, 'a=1\na');
-
-        // Export should cause exportCalled to change to true
-        const exportButton = findButton(wrapper, NativeEditor, 6);
-        await waitForMessageResponse(ioc, () => exportButton!.simulate('click'));
-        assert.equal(exportCalled, true, 'Export should have been called');
-    }, () => { return ioc; });
-
-    runMountedTest('RunAllCells', async (wrapper) => {
-        addMockData(ioc, 'b=2\nb', 2);
-        addMockData(ioc, 'c=3\nc', 3);
-
-        const baseFile = [ {id: 'NotebookImport#0', data: {source: 'a=1\na'}},
-        {id: 'NotebookImport#1', data: {source: 'b=2\nb'}},
-        {id: 'NotebookImport#2', data: {source: 'c=3\nc'}} ];
-        const runAllCells =  baseFile.map(cell => {
-            return createFileCell(cell, cell.data);
+
+        test('Pressing \'Shift+Enter\' on a selected cell executes the cell and advances to the next cell', async () => {
+            clickCell(1);
+            const update = waitForUpdate(wrapper, NativeEditor, 7);
+            simulateKeyPressOnCell(1, { code: 'Enter', shiftKey: true, editorInfo: undefined });
+            await update;
+            wrapper.update();
+
+            // Ensure cell was executed.
+            verifyHtmlOnCell(wrapper, 'NativeCell', '<span>2</span>', 1);
+
+            // The third cell should be selected.
+            assert.ok(isCellSelected(wrapper, 'NativeCell', 2));
         });
-        const notebook = await ioc.get<INotebookExporter>(INotebookExporter).translateToNotebook(runAllCells, undefined);
-        await openEditor(ioc, JSON.stringify(notebook));
 
-        // Export should cause exportCalled to change to true
-        const runAllButton = findButton(wrapper, NativeEditor, 3);
-        await waitForMessageResponse(ioc, () => runAllButton!.simulate('click'));
+        test('Pressing \'Ctrl+Enter\' on a selected cell executes the cell and cell selection is not changed', async () => {
+            const update = waitForUpdate(wrapper, NativeEditor, 7);
+            clickCell(1);
+            simulateKeyPressOnCell(1, { code: 'Enter', ctrlKey: true, editorInfo: undefined });
+            await update;
 
-        await waitForUpdate(wrapper, NativeEditor, 16);
+            // Ensure cell was executed.
+            verifyHtmlOnCell(wrapper, 'NativeCell', '<span>2</span>', 1);
 
-        verifyHtmlOnCell(wrapper, 'NativeCell', `1`, 0);
-        verifyHtmlOnCell(wrapper, 'NativeCell', `2`, 1);
-        verifyHtmlOnCell(wrapper, 'NativeCell', `3`, 2);
-    }, () => { return ioc; });
+            // The first cell should be selected.
+            assert.ok(isCellSelected(wrapper, 'NativeCell', 1));
+        });
 
-    runMountedTest('Startup and shutdown', async (wrapper) => {
-        addMockData(ioc, 'b=2\nb', 2);
-        addMockData(ioc, 'c=3\nc', 3);
+        test('Pressing \'Altr+Enter\' on a selected cell adds a new cell below it', async () => {
+            // Initially 3 cells.
+            assert.equal(wrapper.find('NativeCell').length, 3);
 
-        const baseFile = [ {id: 'NotebookImport#0', data: {source: 'a=1\na'}},
-        {id: 'NotebookImport#1', data: {source: 'b=2\nb'}},
-        {id: 'NotebookImport#2', data: {source: 'c=3\nc'}} ];
-        const runAllCells =  baseFile.map(cell => {
-            return createFileCell(cell, cell.data);
+            const update = waitForUpdate(wrapper, NativeEditor, 1);
+            clickCell(1);
+            simulateKeyPressOnCell(1, { code: 'Enter', altKey: true, editorInfo: undefined });
+            await update;
+
+            // The second cell should be selected.
+            assert.ok(isCellSelected(wrapper, 'NativeCell', 2));
+            // There should be 4 cells.
+            assert.equal(wrapper.find('NativeCell').length, 4);
+        });
+
+        test('Pressing \'d\' on a selected cell twice deletes the cell', async () => {
+            // Initially 3 cells.
+            assert.equal(wrapper.find('NativeCell').length, 3);
+
+            clickCell(2);
+            simulateKeyPressOnCell(2, { code: 'd' });
+            simulateKeyPressOnCell(2, { code: 'd' });
+
+            // There should be 2 cells.
+            assert.equal(wrapper.find('NativeCell').length, 2);
+        });
+
+        test('Pressing \'a\' on a selected cell adds a cell at the current position', async () => {
+            // Initially 3 cells.
+            assert.equal(wrapper.find('NativeCell').length, 3);
+
+            // const secondCell = wrapper.find('NativeCell').at(1);
+
+            clickCell(0);
+            const update = waitForUpdate(wrapper, NativeEditor, 1);
+            simulateKeyPressOnCell(0, { code: 'a' });
+            await update;
+
+            // There should be 4 cells.
+            assert.equal(wrapper.find('NativeCell').length, 4);
+
+            // Verify cell indexes of old items.
+            verifyCellIndex(wrapper, 'div[id="NotebookImport#0"]', 1);
+            verifyCellIndex(wrapper, 'div[id="NotebookImport#1"]', 2);
+            verifyCellIndex(wrapper, 'div[id="NotebookImport#2"]', 3);
+        });
+
+        test('Pressing \'b\' on a selected cell adds a cell after the current position', async () => {
+            // Initially 3 cells.
+            assert.equal(wrapper.find('NativeCell').length, 3);
+
+            clickCell(1);
+            const update = waitForUpdate(wrapper, NativeEditor, 1);
+            simulateKeyPressOnCell(1, { code: 'b' });
+            await update;
+
+            // There should be 4 cells.
+            assert.equal(wrapper.find('NativeCell').length, 4);
+
+            // Verify cell indexes of old items.
+            verifyCellIndex(wrapper, 'div[id="NotebookImport#0"]', 0);
+            verifyCellIndex(wrapper, 'div[id="NotebookImport#1"]', 1);
+            verifyCellIndex(wrapper, 'div[id="NotebookImport#2"]', 3);
+        });
+
+        test('Toggle visibility of output', async () => {
+            // First execute contents of last cell.
+            let update = waitForUpdate(wrapper, NativeEditor, 7);
+            clickCell(2);
+            simulateKeyPressOnCell(2, { code: 'Enter', ctrlKey: true, editorInfo: undefined });
+            await update;
+
+            // Ensure cell was executed.
+            verifyHtmlOnCell(wrapper, 'NativeCell', '<span>3</span>', 2);
+
+            // Hide the output
+            update = waitForUpdate(wrapper, NativeEditor, 1);
+            simulateKeyPressOnCell(2, { code: 'o' });
+            await update;
+
+            // Ensure cell output is hidden (looking for cell results will throw an exception).
+            assert.throws(() => verifyHtmlOnCell(wrapper, 'NativeCell', '<span>3</span>', 2));
+
+            // Display the output
+            update = waitForUpdate(wrapper, NativeEditor, 1);
+            simulateKeyPressOnCell(2, { code: 'o' });
+            await update;
+
+            // Ensure cell output is visible again.
+            verifyHtmlOnCell(wrapper, 'NativeCell', '<span>3</span>', 2);
+        });
+
+        test('Toggle line numbers using the \'l\' key', async () => {
+            clickCell(1);
+
+            const monacoEditorComponent = wrapper.find(NativeCell).at(1).find(MonacoEditor).first();
+            const editor = (monacoEditorComponent.instance().state as IMonacoEditorState).editor!;
+            const oldUpdateOptions = editor.updateOptions.bind(editor);
+
+            let lineNumberSetting: any = '';
+            editor.updateOptions = (options: monacoEditor.editor.IEditorConstructionOptions) => {
+                lineNumberSetting = options.lineNumbers;
+                oldUpdateOptions(options);
+            };
+
+            // Display line numbers.
+            simulateKeyPressOnCell(1, { code: 'l' });
+            assert.equal(lineNumberSetting, 'on');
+
+            // toggle the display of line numbers.
+            simulateKeyPressOnCell(1, { code: 'l' });
+            assert.equal(lineNumberSetting, 'off');
+        });
+
+        test('Toggle markdown and code modes using \'y\' and \'m\' keys', async () => {
+            clickCell(1);
+
+            // Switch to markdown
+            simulateKeyPressOnCell(1, { code: 'm' });
+
+            // Confirm output cell is rendered and monaco editor is not.
+            assert.equal(wrapper.find(NativeCell).at(1).find(CellOutput).length, 1);
+            assert.equal(wrapper.find(NativeCell).at(1).find(MonacoEditor).length, 0);
+
+            // Switch back to code mode.
+            // At this moment, there's no cell input element, hence send key strokes to the wrapper.
+            const wrapperElement = wrapper.find(NativeCell).at(1).find('.cell-wrapper').first();
+            wrapperElement.simulate('keyDown', {key: 'y'});
+
+            // Confirm output cell is not rendered (remember we don't have any output) and monaco editor is rendered.
+            assert.equal(wrapper.find(NativeCell).at(1).find(CellOutput).length, 0);
+            assert.equal(wrapper.find(NativeCell).at(1).find(MonacoEditor).length, 1);
         });
-        const notebook = await ioc.get<INotebookExporter>(INotebookExporter).translateToNotebook(runAllCells, undefined);
-        let editor = await openEditor(ioc, JSON.stringify(notebook));
-
-        // Run everything
-        let runAllButton = findButton(wrapper, NativeEditor, 3);
-        await waitForMessageResponse(ioc, () => runAllButton!.simulate('click'));
-        await waitForUpdate(wrapper, NativeEditor, 16);
-
-        // Close editor. Should still have the server up
-        await closeNotebook(editor, wrapper);
-        const jupyterExecution = ioc.serviceManager.get<IJupyterExecution>(IJupyterExecution);
-        const editorProvider = ioc.serviceManager.get<INotebookEditorProvider>(INotebookEditorProvider);
-        const server = await jupyterExecution.getServer(await editorProvider.getNotebookOptions());
-        assert.ok(server, 'Server was destroyed on notebook shutdown');
-
-        // Reopen, and rerun
-        editor = await openEditor(ioc, JSON.stringify(notebook));
-        runAllButton = findButton(wrapper, NativeEditor, 3);
-        await waitForMessageResponse(ioc, () => runAllButton!.simulate('click'));
-        await waitForUpdate(wrapper, NativeEditor, 15);
-        verifyHtmlOnCell(wrapper, 'NativeCell', `1`, 0);
-    }, () => { return ioc; });
-
-    test('Failure', async () => {
-        // Make a dummy class that will fail during launch
-        class FailedProcess extends JupyterExecutionFactory {
-            public getUsableJupyterPython(): Promise<PythonInterpreter | undefined> {
-                return Promise.resolve(undefined);
-            }
-        }
-        ioc.serviceManager.rebind<IJupyterExecution>(IJupyterExecution, FailedProcess);
-        ioc.serviceManager.get<IJupyterExecution>(IJupyterExecution);
-        addMockData(ioc, 'a=1\na', 1);
-        const wrapper = mountNativeWebView(ioc);
-        await createNewEditor(ioc);
-        await addCell(wrapper, 'a=1\na', true, 2);
-
-        // Cell should not have the output
-        verifyHtmlOnCell(wrapper, 'NativeCell', 'Jupyter cannot be started', CellPosition.Last);
     });
 });
diff --git a/src/test/datascience/nativeEditorTestHelpers.tsx b/src/test/datascience/nativeEditorTestHelpers.tsx
index 37c4ce84511f..d0421752c580 100644
--- a/src/test/datascience/nativeEditorTestHelpers.tsx
+++ b/src/test/datascience/nativeEditorTestHelpers.tsx
@@ -48,10 +48,8 @@ export function getNativeCellResults(wrapper: ReactWrapper<any, Readonly<{}>, Re
 export function runMountedTest(name: string, testFunc: (wrapper: ReactWrapper<any, Readonly<{}>, React.Component>) => Promise<void>, getIOC: () => DataScienceIocContainer) {
     test(name, async () => {
         const ioc = getIOC();
-        const jupyterExecution = ioc.get<IJupyterExecution>(IJupyterExecution);
-        if (await jupyterExecution.isNotebookSupported()) {
-            addMockData(ioc, 'a=1\na', 1);
-            const wrapper = mountNativeWebView(ioc);
+        const wrapper = await setupWebview(ioc);
+        if (wrapper) {
             await testFunc(wrapper);
         } else {
             // tslint:disable-next-line:no-console
@@ -63,6 +61,13 @@ export function runMountedTest(name: string, testFunc: (wrapper: ReactWrapper<an
 export function mountNativeWebView(ioc: DataScienceIocContainer): ReactWrapper<any, Readonly<{}>, React.Component> {
     return mountWebView(ioc, <NativeEditor baseTheme='vscode-light' codeTheme='light_vs' testMode={true} skipDefault={true} />);
 }
+export async function setupWebview(ioc: DataScienceIocContainer) {
+    const jupyterExecution = ioc.get<IJupyterExecution>(IJupyterExecution);
+    if (await jupyterExecution.isNotebookSupported()) {
+        addMockData(ioc, 'a=1\na', 1);
+        return mountNativeWebView(ioc);
+    }
+}
 
 // tslint:disable-next-line: no-any
 export async function addCell(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, code: string, submit: boolean = true, expectedSubmitRenderCount: number = 5): Promise<void> {
diff --git a/src/test/datascience/testHelpers.tsx b/src/test/datascience/testHelpers.tsx
index 461a6aac039a..c13b66d11d4a 100644
--- a/src/test/datascience/testHelpers.tsx
+++ b/src/test/datascience/testHelpers.tsx
@@ -15,8 +15,10 @@ import { InteractiveWindowMessages } from '../../client/datascience/interactive-
 import { IJupyterExecution } from '../../client/datascience/types';
 import { InteractivePanel } from '../../datascience-ui/history-react/interactivePanel';
 import { NativeEditor } from '../../datascience-ui/native-editor/nativeEditor';
+import { IKeyboardEvent } from '../../datascience-ui/react-common/event';
 import { ImageButton } from '../../datascience-ui/react-common/imageButton';
 import { updateSettings } from '../../datascience-ui/react-common/settingsReactSide';
+import { noop } from '../core';
 import { DataScienceIocContainer } from './dataScienceIocContainer';
 import { createInputEvent, createKeyboardEvent, waitForUpdate } from './reactHelpers';
 
@@ -33,7 +35,7 @@ export enum CellPosition {
     Last = 'last'
 }
 
-export function waitForMessage(ioc: DataScienceIocContainer, message: string) : Promise<void> {
+export function waitForMessage(ioc: DataScienceIocContainer, message: string): Promise<void> {
     // Wait for the mounted web panel to send a message back to the data explorer
     const promise = createDeferred<void>();
     let handler: (m: string, p: any) => void;
@@ -48,7 +50,7 @@ export function waitForMessage(ioc: DataScienceIocContainer, message: string) :
 }
 
 export async function waitForMessageResponse(ioc: DataScienceIocContainer, action: () => void): Promise<void> {
-    ioc.wrapperCreatedPromise  = createDeferred<boolean>();
+    ioc.wrapperCreatedPromise = createDeferred<boolean>();
     action();
     await ioc.wrapperCreatedPromise.promise;
     ioc.wrapperCreatedPromise = undefined;
@@ -58,7 +60,8 @@ async function testInnerLoop(
     name: string,
     mountFunc: (ioc: DataScienceIocContainer) => ReactWrapper<any, Readonly<{}>, React.Component>,
     testFunc: (wrapper: ReactWrapper<any, Readonly<{}>, React.Component>) => Promise<void>,
-    getIOC: () => DataScienceIocContainer) {
+    getIOC: () => DataScienceIocContainer
+) {
     const ioc = getIOC();
     const jupyterExecution = ioc.get<IJupyterExecution>(IJupyterExecution);
     if (await jupyterExecution.isNotebookSupported()) {
@@ -73,8 +76,10 @@ async function testInnerLoop(
 
 export function runDoubleTest(name: string, testFunc: (wrapper: ReactWrapper<any, Readonly<{}>, React.Component>) => Promise<void>, getIOC: () => DataScienceIocContainer) {
     // Just run the test twice. Originally mounted twice, but too hard trying to figure out disposing.
-    test(`${name} (interactive)`, async () => testInnerLoop(name, (ioc) => mountWebView(ioc, <InteractivePanel baseTheme='vscode-light' codeTheme='light_vs' testMode={true} skipDefault={true} />), testFunc, getIOC));
-    test(`${name} (native)`, async () => testInnerLoop(name, (ioc) => mountWebView(ioc, <NativeEditor baseTheme='vscode-light' codeTheme='light_vs' testMode={true} skipDefault={true} />), testFunc, getIOC));
+    test(`${name} (interactive)`, async () =>
+        testInnerLoop(name, ioc => mountWebView(ioc, <InteractivePanel baseTheme='vscode-light' codeTheme='light_vs' testMode={true} skipDefault={true} />), testFunc, getIOC));
+    test(`${name} (native)`, async () =>
+        testInnerLoop(name, ioc => mountWebView(ioc, <NativeEditor baseTheme='vscode-light' codeTheme='light_vs' testMode={true} skipDefault={true} />), testFunc, getIOC));
 }
 
 export function mountWebView(ioc: DataScienceIocContainer, node: React.ReactElement): ReactWrapper<any, Readonly<{}>, React.Component> {
@@ -119,7 +124,7 @@ export function verifyHtmlOnCell(wrapper: ReactWrapper<any, Readonly<{}>, React.
     let targetCell: ReactWrapper;
     // Get the correct result that we are dealing with
     if (typeof cellIndex === 'number') {
-        if (cellIndex >= 0 && cellIndex <= (foundResult.length - 1)) {
+        if (cellIndex >= 0 && cellIndex <= foundResult.length - 1) {
             targetCell = foundResult.at(cellIndex);
         }
     } else if (typeof cellIndex === 'string') {
@@ -158,8 +163,114 @@ export function verifyHtmlOnCell(wrapper: ReactWrapper<any, Readonly<{}>, React.
     }
 }
 
-export function verifyLastCellInputState(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, cellType: string, state: CellInputState) {
+/**
+ * Creates a keyboard event for a cells.
+ *
+ * @export
+ * @param {(Partial<IKeyboardEvent> & { code: string })} event
+ * @returns
+ */
+export function createKeyboardEventForCell(event: Partial<IKeyboardEvent> & { code: string }) {
+    const defaultKeyboardEvent: IKeyboardEvent = {
+        altKey: false,
+        code: '',
+        ctrlKey: false,
+        editorInfo: {
+            contents: '',
+            isDirty: false,
+            isFirstLine: false,
+            isLastLine: false,
+            isSuggesting: false
+        },
+        metaKey: false,
+        preventDefault: noop,
+        shiftKey: false,
+        stopPropagation: noop,
+        target: {} as any
+    };
+
+    const defaultEditorInfo = defaultKeyboardEvent.editorInfo!;
+    const providedEditorInfo = event.editorInfo || {};
+    return {
+        ...defaultKeyboardEvent,
+        ...event,
+        editorInfo: {
+            ...defaultEditorInfo,
+            ...providedEditorInfo
+        }
+    };
+}
+
+export function isCellSelected(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, cellType: string, cellIndex: number | CellPosition): boolean {
+    try {
+        verifyCell(wrapper, cellType, { selector: '.cell-wrapper-selected' }, cellIndex);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+export function isCellFocused(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, cellType: string, cellIndex: number | CellPosition): boolean {
+    try {
+        verifyCell(wrapper, cellType, { selector: '.cell-wrapper-focused' }, cellIndex);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+export function verifyCellIndex(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, cellId: string, expectedCellIndex: number) {
+    const nativeCell = wrapper
+        .find(cellId)
+        .first()
+        .find('NativeCell');
+    const secondCell = wrapper.find('NativeCell').at(expectedCellIndex);
+    assert.equal(nativeCell.html(), secondCell.html());
+}
+
+function verifyCell(
+    wrapper: ReactWrapper<any, Readonly<{}>, React.Component>,
+    cellType: string,
+    options: { selector: string; shouldNotExist?: boolean },
+    cellIndex: number | CellPosition
+) {
+    const foundResult = wrapper.find(cellType);
+    assert.ok(foundResult.length >= 1, 'Didn\'t find any cells being rendered');
+
+    let targetCell: ReactWrapper;
+    // Get the correct result that we are dealing with
+    if (typeof cellIndex === 'number') {
+        if (cellIndex >= 0 && cellIndex <= foundResult.length - 1) {
+            targetCell = foundResult.at(cellIndex);
+        }
+    } else if (typeof cellIndex === 'string') {
+        switch (cellIndex) {
+            case CellPosition.First:
+                targetCell = foundResult.first();
+                break;
+
+            case CellPosition.Last:
+                // Skip the input cell on these checks.
+                targetCell = getLastOutputCell(wrapper, cellType);
+                break;
+
+            default:
+                // Fall through, targetCell check will fail out
+                break;
+        }
+    }
+
+    // ! is ok here to get rid of undefined type check as we want a fail here if we have not initialized targetCell
+    assert.ok(targetCell!, 'Target cell doesn\'t exist');
 
+    if (options.shouldNotExist) {
+        assert.ok(targetCell!.find(options.selector).length === 0, `Found cells with the matching selector '${options.selector}'`);
+    } else {
+        assert.ok(targetCell!.find(options.selector).length >= 1, `Didn't find any cells with the matching selector '${options.selector}'`);
+    }
+}
+
+export function verifyLastCellInputState(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, cellType: string, state: CellInputState) {
     const lastCell = getLastOutputCell(wrapper, cellType);
     assert.ok(lastCell, 'Last call doesn\'t exist');
 
@@ -189,8 +300,13 @@ export function verifyLastCellInputState(wrapper: ReactWrapper<any, Readonly<{}>
     }
 }
 
-export async function getCellResults(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, mainClass: React.ComponentClass<any>, cellType: string, expectedRenders: number, updater: () => Promise<void>): Promise<ReactWrapper<any, Readonly<{}>, React.Component>> {
-
+export async function getCellResults(
+    wrapper: ReactWrapper<any, Readonly<{}>, React.Component>,
+    mainClass: React.ComponentClass<any>,
+    cellType: string,
+    expectedRenders: number,
+    updater: () => Promise<void>
+): Promise<ReactWrapper<any, Readonly<{}>, React.Component>> {
     // Get a render promise with the expected number of renders
     const renderPromise = waitForUpdate(wrapper, mainClass, expectedRenders);
 
@@ -237,10 +353,9 @@ function simulateKey(domNode: HTMLTextAreaElement, key: string, shiftDown?: bool
             domNode.dispatchEvent(createInputEvent());
         }
     }
-
 }
 
-async function submitInput(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, mainClass: React.ComponentClass<any>,  textArea: HTMLTextAreaElement): Promise<void> {
+async function submitInput(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, mainClass: React.ComponentClass<any>, textArea: HTMLTextAreaElement): Promise<void> {
     // Get a render promise with the expected number of renders (how many updates a the shift + enter will cause)
     // Should be 6 - 1 for the shift+enter and 5 for the new cell.
     const renderPromise = waitForUpdate(wrapper, mainClass, 6);
@@ -256,15 +371,14 @@ function enterKey(_wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, te
     simulateKey(textArea, key);
 }
 
-export function getEditor(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>) : ReactWrapper<any, Readonly<{}>, React.Component> {
+export function getEditor(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>): ReactWrapper<any, Readonly<{}>, React.Component> {
     // Find the last cell. It should have a monacoEditor object
     const cells = wrapper.find('InteractiveCell');
     const lastCell = cells.last();
     return lastCell.find('MonacoEditor');
 }
 
-export function typeCode(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, code: string) : HTMLTextAreaElement | null {
-
+export function typeCode(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, code: string): HTMLTextAreaElement | null {
     // Find the last cell. It should have a monacoEditor object. We need to search
     // through its DOM to find the actual textarea to send input to
     // (we can't actually find it with the enzyme wrappers because they only search
@@ -284,8 +398,12 @@ export function typeCode(wrapper: ReactWrapper<any, Readonly<{}>, React.Componen
     return textArea;
 }
 
-export async function enterInput(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, mainClass: React.ComponentClass<any>,  code: string, resultClass: string): Promise<ReactWrapper<any, Readonly<{}>, React.Component>> {
-
+export async function enterInput(
+    wrapper: ReactWrapper<any, Readonly<{}>, React.Component>,
+    mainClass: React.ComponentClass<any>,
+    code: string,
+    resultClass: string
+): Promise<ReactWrapper<any, Readonly<{}>, React.Component>> {
     // First we have to type the code into the input box
     const textArea = typeCode(wrapper, code);
 
@@ -296,7 +414,11 @@ export async function enterInput(wrapper: ReactWrapper<any, Readonly<{}>, React.
     return wrapper.find(resultClass);
 }
 
-export function findButton(wrapper: ReactWrapper<any, Readonly<{}>, React.Component>, mainClass: React.ComponentClass<any>, index: number): ReactWrapper<any, Readonly<{}>, React.Component> | undefined {
+export function findButton(
+    wrapper: ReactWrapper<any, Readonly<{}>, React.Component>,
+    mainClass: React.ComponentClass<any>,
+    index: number
+): ReactWrapper<any, Readonly<{}>, React.Component> | undefined {
     const mainObj = wrapper.find(mainClass);
     if (mainObj) {
         const buttons = mainObj.find(ImageButton);

From 12ed8942d9d4537a8bb3a3b36c20fe5ad1eea4cc Mon Sep 17 00:00:00 2001
From: Don Jayamanne <don.jayamanne@yahoo.com>
Date: Tue, 8 Oct 2019 10:37:14 -0700
Subject: [PATCH 15/36] Smoke tests does not depend on build stage (#7819)

* Smoke tests does not depend on build stage
* Faster CI
---
 build/ci/vscode-python-ci.yaml            | 3 +--
 build/ci/vscode-python-pr-validation.yaml | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/build/ci/vscode-python-ci.yaml b/build/ci/vscode-python-ci.yaml
index f2939bf55565..187f1f2a796a 100644
--- a/build/ci/vscode-python-ci.yaml
+++ b/build/ci/vscode-python-ci.yaml
@@ -265,8 +265,7 @@ stages:
 
 
 - stage: Smoke
-  dependsOn:
-  - Build
+  dependsOn: []
   jobs:
   - job: 'Smoke'
     dependsOn: []
diff --git a/build/ci/vscode-python-pr-validation.yaml b/build/ci/vscode-python-pr-validation.yaml
index a5a25a53beb2..593947f75746 100644
--- a/build/ci/vscode-python-pr-validation.yaml
+++ b/build/ci/vscode-python-pr-validation.yaml
@@ -93,8 +93,7 @@ stages:
       - template: templates/test_phases.yml
 
 - stage: Smoke
-  dependsOn:
-  - Build
+  dependsOn: []
   jobs:
   - job: 'Smoke'
     dependsOn: []

From 2ebc2232d92d379bf6012599bb3ac429f16f647c Mon Sep 17 00:00:00 2001
From: Don Jayamanne <don.jayamanne@yahoo.com>
Date: Tue, 8 Oct 2019 11:13:10 -0700
Subject: [PATCH 16/36] Tests for undo using keyboard shortcut 'z' (#7824)

---
 .../interactive-common/mainStateController.ts | 24 ++++++++-------
 .../nativeEditor.functional.test.tsx          | 29 +++++++++++++++++++
 2 files changed, 43 insertions(+), 10 deletions(-)

diff --git a/src/datascience-ui/interactive-common/mainStateController.ts b/src/datascience-ui/interactive-common/mainStateController.ts
index f8262f0b81d3..d40a34e3eb1a 100644
--- a/src/datascience-ui/interactive-common/mainStateController.ts
+++ b/src/datascience-ui/interactive-common/mainStateController.ts
@@ -517,11 +517,13 @@ export class MainStateController implements IMessageHandler {
         // Skip if already has focus
         if (cellId !== this.pendingState.focusedCellId) {
             const newVMs = [...this.pendingState.cellVMs];
-            // Switch the old vm
-            const oldSelect = this.findCellIndex(this.pendingState.selectedCellId);
-            if (oldSelect >= 0) {
-                newVMs[oldSelect] = { ...newVMs[oldSelect], selected: false, focused: false };
-            }
+            // Reset the old vms (nothing should be selected/focused)
+            // Change state only for cells that were selected/focused
+            newVMs.forEach((cellVM, index) => {
+                if (cellVM.selected || cellVM.focused){
+                    newVMs[index] = { ...cellVM, selected: false, focused: false };
+                }
+            });
             const newSelect = this.findCellIndex(cellId);
             if (newSelect >= 0) {
                 newVMs[newSelect] = { ...newVMs[newSelect], selected: true, focused: true };
@@ -536,11 +538,13 @@ export class MainStateController implements IMessageHandler {
         // Skip if already the same cell
         if (this.pendingState.selectedCellId !== cellId || this.pendingState.focusedCellId !== focusedCellId) {
             const newVMs = [...this.pendingState.cellVMs];
-            // Switch the old vm
-            const oldSelect = this.findCellIndex(this.pendingState.selectedCellId);
-            if (oldSelect >= 0) {
-                newVMs[oldSelect] = { ...newVMs[oldSelect], selected: false, focused: false };
-            }
+            // Reset the old vms (nothing should be selected/focused)
+            // Change state only for cells that were selected/focused
+            newVMs.forEach((cellVM, index) => {
+                if (cellVM.selected || cellVM.focused){
+                    newVMs[index] = { ...cellVM, selected: false, focused: false };
+                }
+            });
             const newSelect = this.findCellIndex(cellId);
             if (newSelect >= 0) {
                 newVMs[newSelect] = { ...newVMs[newSelect], selected: true, focused: focusedCellId === newVMs[newSelect].cell.id };
diff --git a/src/test/datascience/nativeEditor.functional.test.tsx b/src/test/datascience/nativeEditor.functional.test.tsx
index 973219361639..dc0704d81c01 100644
--- a/src/test/datascience/nativeEditor.functional.test.tsx
+++ b/src/test/datascience/nativeEditor.functional.test.tsx
@@ -659,5 +659,34 @@ suite('DataScience Native Editor', () => {
             assert.equal(wrapper.find(NativeCell).at(1).find(CellOutput).length, 0);
             assert.equal(wrapper.find(NativeCell).at(1).find(MonacoEditor).length, 1);
         });
+
+        test('Test undo using the key \'z\'', async () => {
+            clickCell(0);
+
+            // Add, then undo, keep doing at least 3 times and confirm it works as expected.
+            for (let i = 0; i < 3; i += 1){
+                // Add a new cell
+                let update = waitForUpdate(wrapper, NativeEditor, 1);
+                simulateKeyPressOnCell(0, { code: 'a' });
+                await update;
+
+                // There should be 4 cells and first cell is selected & nothing focused.
+                assert.equal(isCellSelected(wrapper, 'NativeCell', 0), true);
+                assert.equal(isCellSelected(wrapper, 'NativeCell', 1), false);
+                assert.equal(isCellFocused(wrapper, 'NativeCell', 0), false);
+                assert.equal(isCellFocused(wrapper, 'NativeCell', 1), false);
+                assert.equal(wrapper.find('NativeCell').length, 4);
+
+                // Press 'z' to undo.
+                update = waitForUpdate(wrapper, NativeEditor, 1);
+                simulateKeyPressOnCell(0, { code: 'z' });
+                await update;
+
+                // There should be 3 cells and first cell is selected & nothing focused.
+                assert.equal(isCellSelected(wrapper, 'NativeCell', 0), true);
+                assert.equal(isCellSelected(wrapper, 'NativeCell', 1), false);
+                assert.equal(wrapper.find('NativeCell').length, 3);
+            }
+        });
     });
 });

From bf5aaa6134703aa8c44d7e68eecb0d26585d3ccd Mon Sep 17 00:00:00 2001
From: Don Jayamanne <don.jayamanne@yahoo.com>
Date: Tue, 8 Oct 2019 19:48:36 -0700
Subject: [PATCH 17/36] Update @types/vscode (#7833)

* Update vscode dependency
* News entry
---
 news/3 Code Health/7832.md | 1 +
 package-lock.json          | 6 +++---
 package.json               | 4 ++--
 3 files changed, 6 insertions(+), 5 deletions(-)
 create mode 100644 news/3 Code Health/7832.md

diff --git a/news/3 Code Health/7832.md b/news/3 Code Health/7832.md
new file mode 100644
index 000000000000..ee4faa776756
--- /dev/null
+++ b/news/3 Code Health/7832.md	
@@ -0,0 +1 @@
+Update version of `@types/vscode`.
diff --git a/package-lock.json b/package-lock.json
index 6a0b36e78cdb..d659dded995f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -2382,9 +2382,9 @@
             }
         },
         "@types/vscode": {
-            "version": "1.36.0",
-            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.36.0.tgz",
-            "integrity": "sha512-SbHR3Q5g/C3N+Ila3KrRf1rSZiyHxWdOZ7X3yFHXzw6HrvRLuVZrxnwEX0lTBMRpH9LkwZdqRTgXW+D075jxkg==",
+            "version": "1.38.0",
+            "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.38.0.tgz",
+            "integrity": "sha512-aGo8LQ4J1YF0T9ORuCO+bhQ5sGR1MXa7VOyOdEP685se3wyQWYUExcdiDi6rvaK61KUwfzzA19JRLDrUbDl7BQ==",
             "dev": true
         },
         "@types/webpack": {
diff --git a/package.json b/package.json
index 93b20658d249..cad8426add40 100644
--- a/package.json
+++ b/package.json
@@ -24,7 +24,7 @@
         "theme": "dark"
     },
     "engines": {
-        "vscode": "^1.36.0"
+        "vscode": "^1.38.0"
     },
     "keywords": [
         "python",
@@ -2780,7 +2780,7 @@
         "@types/tmp": "0.0.33",
         "@types/untildify": "^3.0.0",
         "@types/uuid": "^3.4.3",
-        "@types/vscode": "^1.36.0",
+        "@types/vscode": "^1.38.0",
         "@types/webpack-bundle-analyzer": "^2.13.0",
         "@types/winreg": "^1.2.30",
         "@types/ws": "^6.0.1",

From 939a1a2977bfd29ae5e87d79b4fef7ae4f4a0768 Mon Sep 17 00:00:00 2001
From: Rich Chiodo <rchiodo@users.noreply.github.com>
Date: Wed, 9 Oct 2019 12:50:29 -0700
Subject: [PATCH 18/36] Fix focus problems with add new cell buttons (#7827)

* Fix focus problems with add new cell buttons

* Get rid of unnecessary delay for async callbacks
---
 news/2 Fixes/7820.md                              | 1 +
 src/datascience-ui/native-editor/nativeCell.tsx   | 4 ++--
 src/datascience-ui/native-editor/nativeEditor.tsx | 8 +++++---
 3 files changed, 8 insertions(+), 5 deletions(-)
 create mode 100644 news/2 Fixes/7820.md

diff --git a/news/2 Fixes/7820.md b/news/2 Fixes/7820.md
new file mode 100644
index 000000000000..74f0775bdb7d
--- /dev/null
+++ b/news/2 Fixes/7820.md	
@@ -0,0 +1 @@
+Fix add new cell buttons in the notebook editor to give the new cell focus.
diff --git a/src/datascience-ui/native-editor/nativeCell.tsx b/src/datascience-ui/native-editor/nativeCell.tsx
index 03e2a9d9ac3d..d641cac7ec5b 100644
--- a/src/datascience-ui/native-editor/nativeCell.tsx
+++ b/src/datascience-ui/native-editor/nativeCell.tsx
@@ -563,7 +563,7 @@ export class NativeCell extends React.Component<INativeCellProps> {
         const switchToMarkdown = () => {
             this.props.stateController.changeCellType(cellId, 'markdown');
             this.props.stateController.sendCommand(NativeCommandType.ChangeToMarkdown, 'mouse');
-            setTimeout(() => this.props.focusCell(cellId, true), 10);
+            setTimeout(() => this.props.focusCell(cellId, true), 0);
         };
         const switchToCode = () => {
             const handler = () => {
@@ -571,7 +571,7 @@ export class NativeCell extends React.Component<INativeCellProps> {
                     this.props.stateController.changeCellType(cellId, 'code');
                     this.props.stateController.sendCommand(NativeCommandType.ChangeToCode, 'mouse');
                     this.props.focusCell(cellId, true);
-                }, 10);
+                }, 0);
             };
 
             // This is special. Coming in on a mouse down event so we get
diff --git a/src/datascience-ui/native-editor/nativeEditor.tsx b/src/datascience-ui/native-editor/nativeEditor.tsx
index 479f8baa2c4d..df7ea965cc59 100644
--- a/src/datascience-ui/native-editor/nativeEditor.tsx
+++ b/src/datascience-ui/native-editor/nativeEditor.tsx
@@ -98,7 +98,8 @@ export class NativeEditor extends React.Component<INativeEditorProps, IMainState
             const cellId = this.state.cellVMs.length > 0 ? this.state.cellVMs[0].cell.id : undefined;
             const newCell = this.stateController.insertAbove(cellId, true);
             if (newCell) {
-                this.selectCell(newCell);
+                // Make async because the click changes focus.
+                setTimeout(() => this.focusCell(newCell, true), 0);
             }
         };
         const addCellLine = this.state.cellVMs.length === 0 ? null :
@@ -370,7 +371,8 @@ export class NativeEditor extends React.Component<INativeEditorProps, IMainState
             const newCell = this.stateController.insertBelow(cellVM.cell.id, true);
             this.stateController.sendCommand(NativeCommandType.AddToEnd, 'mouse');
             if (newCell) {
-                this.selectCell(newCell);
+                // Has to be async because the click will change the focus on mouse up
+                setTimeout(() => this.focusCell(newCell, true), 0);
             }
         };
         const lastLine = index === this.state.cellVMs.length - 1 ?
@@ -425,7 +427,7 @@ export class NativeEditor extends React.Component<INativeEditorProps, IMainState
             // Bounce this so state has time to update.
             setTimeout(() => {
                 this.focusCell(newCell, true);
-            }, 10);
+            }, 0);
         }
     }
 }

From 963c556f88957bb59f041dee6b0332ae62c73322 Mon Sep 17 00:00:00 2001
From: Don Jayamanne <don.jayamanne@yahoo.com>
Date: Wed, 9 Oct 2019 12:51:37 -0700
Subject: [PATCH 19/36] Use VSC API instead of hardcoding the uri resource
 vscode-resource (#7835)

* Update vscode dependency
* News entry
* Stop hardcoding 'vscode-resource' and use VSC api
---
 news/3 Code Health/7834.md                |  1 +
 src/client/common/application/webPanel.ts | 13 +++++--------
 2 files changed, 6 insertions(+), 8 deletions(-)
 create mode 100644 news/3 Code Health/7834.md

diff --git a/news/3 Code Health/7834.md b/news/3 Code Health/7834.md
new file mode 100644
index 000000000000..3bd2421b2b27
--- /dev/null
+++ b/news/3 Code Health/7834.md	
@@ -0,0 +1 @@
+Use `Webview.asWebviewUri` to generate a URI for use in the `Webview Panel` instead of hardcoding the resource `vscode-resource`.
diff --git a/src/client/common/application/webPanel.ts b/src/client/common/application/webPanel.ts
index 2e3bc5900e01..bf650a4656bb 100644
--- a/src/client/common/application/webPanel.ts
+++ b/src/client/common/application/webPanel.ts
@@ -5,8 +5,7 @@ import '../../common/extensions';
 
 import * as fs from 'fs-extra';
 import * as path from 'path';
-import { Uri, ViewColumn, WebviewPanel, window } from 'vscode';
-
+import { Uri, ViewColumn, Webview, WebviewPanel, window } from 'vscode';
 import * as localize from '../../common/utils/localize';
 import { Identifiers } from '../../datascience/constants';
 import { IServiceContainer } from '../../ioc/types';
@@ -89,7 +88,7 @@ export class WebPanel implements IWebPanel {
 
                 // Call our special function that sticks this script inside of an html page
                 // and translates all of the paths to vscode-resource URIs
-                this.panel.webview.html = this.generateReactHtml(mainScriptPath, embeddedCss, settings);
+                this.panel.webview.html = this.generateReactHtml(mainScriptPath, this.panel.webview, embeddedCss, settings);
 
                 // Reset when the current panel is closed
                 this.disposableRegistry.push(this.panel.onDidDispose(() => {
@@ -118,11 +117,9 @@ export class WebPanel implements IWebPanel {
     }
 
     // tslint:disable-next-line:no-any
-    private generateReactHtml(mainScriptPath: string, embeddedCss?: string, settings?: any) {
-        const uriBasePath = Uri.file(`${path.dirname(mainScriptPath)}/`);
-        const uriPath = Uri.file(mainScriptPath);
-        const uriBase = uriBasePath.with({ scheme: 'vscode-resource' });
-        const uri = uriPath.with({ scheme: 'vscode-resource' });
+    private generateReactHtml(mainScriptPath: string, webView: Webview, embeddedCss?: string, settings?: any) {
+        const uriBase = webView.asWebviewUri(Uri.file(`${path.dirname(mainScriptPath)}/`));
+        const uri = webView.asWebviewUri(Uri.file(mainScriptPath));
         const locDatabase = localize.getCollectionJSON();
         const style = embeddedCss ? embeddedCss : '';
         const settingsString = settings ? JSON.stringify(settings) : '{}';

From db32d3a5a1217545770b9ef5aaf2ee615bc2804a Mon Sep 17 00:00:00 2001
From: Rich Chiodo <rchiodo@users.noreply.github.com>
Date: Wed, 9 Oct 2019 17:24:09 -0700
Subject: [PATCH 20/36] Remove jison dependency (#7863)

---
 package-lock.json | 116 ----------------------------------------------
 package.json      |   1 -
 2 files changed, 117 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index d659dded995f..6cbf43e4b2e2 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -2622,11 +2622,6 @@
             "integrity": "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==",
             "dev": true
         },
-        "JSONSelect": {
-            "version": "0.4.0",
-            "resolved": "https://registry.npmjs.org/JSONSelect/-/JSONSelect-0.4.0.tgz",
-            "integrity": "sha1-oI7cxn6z/L6Z7WMIVTRKDPKCu40="
-        },
         "JSONStream": {
             "version": "1.3.5",
             "resolved": "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.5.tgz",
@@ -2637,11 +2632,6 @@
                 "through": ">=2.2.7 <3"
             }
         },
-        "JSV": {
-            "version": "4.0.2",
-            "resolved": "https://registry.npmjs.org/JSV/-/JSV-4.0.2.tgz",
-            "integrity": "sha1-0Hf2glVx+CEy+d/67Vh7QCn+/1c="
-        },
         "abab": {
             "version": "2.0.0",
             "resolved": "https://registry.npmjs.org/abab/-/abab-2.0.0.tgz",
@@ -5434,14 +5424,6 @@
             "integrity": "sha512-UZK3NBx2Mca+b5LsG7bY183pHWt5Y1xts4P3Pz7ENTwGVnJOUWbRb3ocjvX7hx9tq/yTAdclXm9sZ38gNuem4A==",
             "dev": true
         },
-        "cjson": {
-            "version": "0.3.0",
-            "resolved": "https://registry.npmjs.org/cjson/-/cjson-0.3.0.tgz",
-            "integrity": "sha1-5kObkHA9MS/24iJAl76pLOPQKhQ=",
-            "requires": {
-                "jsonlint": "1.6.0"
-            }
-        },
         "class-utils": {
             "version": "0.3.6",
             "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz",
@@ -7646,11 +7628,6 @@
                 "object.defaults": "^1.1.0"
             }
         },
-        "ebnf-parser": {
-            "version": "0.1.10",
-            "resolved": "https://registry.npmjs.org/ebnf-parser/-/ebnf-parser-0.1.10.tgz",
-            "integrity": "sha1-zR9rpHfFY4xAyX7ZtXLbW6tdgzE="
-        },
         "ecc-jsbn": {
             "version": "0.1.2",
             "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz",
@@ -8040,33 +8017,6 @@
             "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
             "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ="
         },
-        "escodegen": {
-            "version": "1.3.3",
-            "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.3.3.tgz",
-            "integrity": "sha1-8CQBb1qI4Eb9EgBQVek5gC5sXyM=",
-            "requires": {
-                "esprima": "~1.1.1",
-                "estraverse": "~1.5.0",
-                "esutils": "~1.0.0",
-                "source-map": "~0.1.33"
-            },
-            "dependencies": {
-                "esprima": {
-                    "version": "1.1.1",
-                    "resolved": "https://registry.npmjs.org/esprima/-/esprima-1.1.1.tgz",
-                    "integrity": "sha1-W28VR/TRAuZw4UDFCb5ncdautUk="
-                },
-                "source-map": {
-                    "version": "0.1.43",
-                    "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.1.43.tgz",
-                    "integrity": "sha1-wkvBRspRfBRx9drL4lcbK3+eM0Y=",
-                    "optional": true,
-                    "requires": {
-                        "amdefine": ">=0.0.4"
-                    }
-                }
-            }
-        },
         "eslint-scope": {
             "version": "4.0.3",
             "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-4.0.3.tgz",
@@ -11745,37 +11695,6 @@
                 "is-object": "^1.0.1"
             }
         },
-        "jison": {
-            "version": "0.4.18",
-            "resolved": "https://registry.npmjs.org/jison/-/jison-0.4.18.tgz",
-            "integrity": "sha512-FKkCiJvozgC7VTHhMJ00a0/IApSxhlGsFIshLW6trWJ8ONX2TQJBBz6DlcO1Gffy4w9LT+uL+PA+CVnUSJMF7w==",
-            "requires": {
-                "JSONSelect": "0.4.0",
-                "cjson": "0.3.0",
-                "ebnf-parser": "0.1.10",
-                "escodegen": "1.3.x",
-                "esprima": "1.1.x",
-                "jison-lex": "0.3.x",
-                "lex-parser": "~0.1.3",
-                "nomnom": "1.5.2"
-            },
-            "dependencies": {
-                "esprima": {
-                    "version": "1.1.1",
-                    "resolved": "https://registry.npmjs.org/esprima/-/esprima-1.1.1.tgz",
-                    "integrity": "sha1-W28VR/TRAuZw4UDFCb5ncdautUk="
-                }
-            }
-        },
-        "jison-lex": {
-            "version": "0.3.4",
-            "resolved": "https://registry.npmjs.org/jison-lex/-/jison-lex-0.3.4.tgz",
-            "integrity": "sha1-gcoo2E+ESZ36jFlNzePYo/Jux6U=",
-            "requires": {
-                "lex-parser": "0.1.x",
-                "nomnom": "1.5.2"
-            }
-        },
         "jquery": {
             "version": "3.4.1",
             "resolved": "https://registry.npmjs.org/jquery/-/jquery-3.4.1.tgz",
@@ -12044,15 +11963,6 @@
             "resolved": "https://registry.npmjs.org/jsonify/-/jsonify-0.0.0.tgz",
             "integrity": "sha1-LHS27kHZPKUbe1qu6PUDYx0lKnM="
         },
-        "jsonlint": {
-            "version": "1.6.0",
-            "resolved": "https://registry.npmjs.org/jsonlint/-/jsonlint-1.6.0.tgz",
-            "integrity": "sha1-iKpGvCiaesk7tGyuLVihh6m7SUo=",
-            "requires": {
-                "JSV": ">= 4.0.x",
-                "nomnom": ">= 1.5.x"
-            }
-        },
         "jsonparse": {
             "version": "1.2.0",
             "resolved": "https://registry.npmjs.org/jsonparse/-/jsonparse-1.2.0.tgz",
@@ -12243,11 +12153,6 @@
                 "type-check": "~0.3.2"
             }
         },
-        "lex-parser": {
-            "version": "0.1.4",
-            "resolved": "https://registry.npmjs.org/lex-parser/-/lex-parser-0.1.4.tgz",
-            "integrity": "sha1-ZMTwJfF/1Tv7RXY/rrFvAVp0dVA="
-        },
         "liftoff": {
             "version": "3.1.0",
             "resolved": "https://registry.npmjs.org/liftoff/-/liftoff-3.1.0.tgz",
@@ -13869,27 +13774,6 @@
             "resolved": "https://registry.npmjs.org/node-stream-zip/-/node-stream-zip-1.8.2.tgz",
             "integrity": "sha512-zwP2F/R28Oqtl0gOLItk5QjJ6jEU8XO4kaUMgeqvCyXPgdCZlm8T/5qLMiNy+moJCBCiMQAaX7aVMRhT0t2vkQ=="
         },
-        "nomnom": {
-            "version": "1.5.2",
-            "resolved": "https://registry.npmjs.org/nomnom/-/nomnom-1.5.2.tgz",
-            "integrity": "sha1-9DRUSKhTz71cDSYyDyR3qwUm/i8=",
-            "requires": {
-                "colors": "0.5.x",
-                "underscore": "1.1.x"
-            },
-            "dependencies": {
-                "colors": {
-                    "version": "0.5.1",
-                    "resolved": "https://registry.npmjs.org/colors/-/colors-0.5.1.tgz",
-                    "integrity": "sha1-fQAj6usVTo7p/Oddy5I9DtFmd3Q="
-                },
-                "underscore": {
-                    "version": "1.1.7",
-                    "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.1.7.tgz",
-                    "integrity": "sha1-QLq4S60Z0jAJbo1u9ii/8FXYPbA="
-                }
-            }
-        },
         "nopt": {
             "version": "1.0.10",
             "resolved": "https://registry.npmjs.org/nopt/-/nopt-1.0.10.tgz",
diff --git a/package.json b/package.json
index cad8426add40..74277dabc922 100644
--- a/package.json
+++ b/package.json
@@ -2675,7 +2675,6 @@
         "hash.js": "^1.1.7",
         "iconv-lite": "^0.4.21",
         "inversify": "^4.11.1",
-        "jison": "^0.4.18",
         "jsonc-parser": "^2.0.3",
         "less-plugin-inline-urls": "^1.2.0",
         "line-by-line": "^0.1.6",

From 9a340abb1eab4c38b6dda37ed0a995987bc8c22a Mon Sep 17 00:00:00 2001
From: Rich Chiodo <rchiodo@users.noreply.github.com>
Date: Thu, 10 Oct 2019 11:08:56 -0700
Subject: [PATCH 21/36] Another fix for focus on add (#7883)

---
 src/datascience-ui/native-editor/nativeEditor.tsx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/datascience-ui/native-editor/nativeEditor.tsx b/src/datascience-ui/native-editor/nativeEditor.tsx
index df7ea965cc59..60afeaefe45a 100644
--- a/src/datascience-ui/native-editor/nativeEditor.tsx
+++ b/src/datascience-ui/native-editor/nativeEditor.tsx
@@ -176,7 +176,8 @@ export class NativeEditor extends React.Component<INativeEditorProps, IMainState
             const newCell = this.stateController.addNewCell();
             this.stateController.sendCommand(NativeCommandType.AddToEnd, 'mouse');
             if (newCell) {
-                this.stateController.selectCell(newCell.cell.id, newCell.cell.id);
+                // Has to be async because the click will change the focus on mouse up
+                setTimeout(() => this.focusCell(newCell.cell.id, true), 0);
             }
         };
         const runAll = () => {

From 6a7512d2fa88158cd8f91fcb2b511b3dd7b18b7a Mon Sep 17 00:00:00 2001
From: Don Jayamanne <don.jayamanne@yahoo.com>
Date: Thu, 10 Oct 2019 12:22:33 -0700
Subject: [PATCH 22/36] Auto save native editor notebook (#7831)

---
 news/1 Enhancements/7831.md                   |   1 +
 .../common/application/applicationShell.ts    |   6 +-
 src/client/common/application/types.ts        |   7 +
 .../interactiveWindowTypes.ts                 |   2 +
 .../interactive-ipynb/autoSaveService.ts      | 142 +++
 .../interactive-ipynb/nativeEditor.ts         |  79 +-
 src/client/datascience/serviceRegistry.ts     |   2 +
 src/client/datascience/types.ts               |  10 +
 src/client/datascience/webViewHost.ts         |   2 +
 .../interactive-common/mainStateController.ts |   2 +-
 .../nativeEditorStateController.ts            |   4 +-
 src/datascience-ui/react-common/postOffice.ts |  11 +-
 .../react-common/settingsReactSide.ts         |   2 +-
 src/test/common.ts                            |  36 +-
 .../datascience/dataScienceIocContainer.ts    |  47 +-
 src/test/datascience/mockDocumentManager.ts   |   2 +-
 src/test/datascience/mockWorkspaceConfig.ts   |  28 +
 .../nativeEditor.functional.test.tsx          | 858 ++++++++++++------
 .../datascience/nativeEditorTestHelpers.tsx   |   4 +-
 19 files changed, 874 insertions(+), 371 deletions(-)
 create mode 100644 news/1 Enhancements/7831.md
 create mode 100644 src/client/datascience/interactive-ipynb/autoSaveService.ts
 create mode 100644 src/test/datascience/mockWorkspaceConfig.ts

diff --git a/news/1 Enhancements/7831.md b/news/1 Enhancements/7831.md
new file mode 100644
index 000000000000..cd8ca8a6c628
--- /dev/null
+++ b/news/1 Enhancements/7831.md	
@@ -0,0 +1 @@
+Added ability to auto-save chagnes made to the notebook.
diff --git a/src/client/common/application/applicationShell.ts b/src/client/common/application/applicationShell.ts
index 2ab4066f67b4..ea902b332fda 100644
--- a/src/client/common/application/applicationShell.ts
+++ b/src/client/common/application/applicationShell.ts
@@ -5,11 +5,14 @@
 // tslint:disable:no-var-requires no-any unified-signatures
 
 import { injectable } from 'inversify';
-import { CancellationToken, Disposable, env, InputBox, InputBoxOptions, MessageItem, MessageOptions, OpenDialogOptions, OutputChannel, Progress, ProgressOptions, QuickPick, QuickPickItem, QuickPickOptions, SaveDialogOptions, StatusBarAlignment, StatusBarItem, TreeView, TreeViewOptions, Uri, window, WorkspaceFolder, WorkspaceFolderPickOptions } from 'vscode';
+import { CancellationToken, Disposable, env, Event, InputBox, InputBoxOptions, MessageItem, MessageOptions, OpenDialogOptions, OutputChannel, Progress, ProgressOptions, QuickPick, QuickPickItem, QuickPickOptions, SaveDialogOptions, StatusBarAlignment, StatusBarItem, TreeView, TreeViewOptions, Uri, window, WindowState, WorkspaceFolder, WorkspaceFolderPickOptions } from 'vscode';
 import { IApplicationShell } from './types';
 
 @injectable()
 export class ApplicationShell implements IApplicationShell {
+    public get onDidChangeWindowState(): Event<WindowState> {
+        return window.onDidChangeWindowState;
+    }
     public showInformationMessage(message: string, ...items: string[]): Thenable<string>;
     public showInformationMessage(message: string, options: MessageOptions, ...items: string[]): Thenable<string>;
     public showInformationMessage<T extends MessageItem>(message: string, ...items: T[]): Thenable<T>;
@@ -81,5 +84,4 @@ export class ApplicationShell implements IApplicationShell {
     public createOutputChannel(name: string): OutputChannel {
         return window.createOutputChannel(name);
     }
-
 }
diff --git a/src/client/common/application/types.ts b/src/client/common/application/types.ts
index e3681214ed9a..a63f538e6a8e 100644
--- a/src/client/common/application/types.ts
+++ b/src/client/common/application/types.ts
@@ -49,6 +49,7 @@ import {
     TreeViewOptions,
     Uri,
     ViewColumn,
+    WindowState,
     WorkspaceConfiguration,
     WorkspaceEdit,
     WorkspaceFolder,
@@ -64,6 +65,12 @@ import { ICommandNameArgumentTypeMapping } from './commands';
 
 export const IApplicationShell = Symbol('IApplicationShell');
 export interface IApplicationShell {
+    /**
+     * An [event](#Event) which fires when the focus state of the current window
+     * changes. The value of the event represents whether the window is focused.
+     */
+    readonly onDidChangeWindowState: Event<WindowState>;
+
     showInformationMessage(message: string, ...items: string[]): Thenable<string | undefined>;
 
     /**
diff --git a/src/client/datascience/interactive-common/interactiveWindowTypes.ts b/src/client/datascience/interactive-common/interactiveWindowTypes.ts
index 203dbdd470bc..3c438ca51a56 100644
--- a/src/client/datascience/interactive-common/interactiveWindowTypes.ts
+++ b/src/client/datascience/interactive-common/interactiveWindowTypes.ts
@@ -27,6 +27,8 @@ export namespace InteractiveWindowMessages {
     export const Interrupt = 'interrupt';
     export const SubmitNewCell = 'submit_new_cell';
     export const UpdateSettings = SharedMessages.UpdateSettings;
+    // Message sent to React component from extension asking it to save the notebook.
+    export const DoSave = 'DoSave';
     export const SendInfo = 'send_info';
     export const Started = SharedMessages.Started;
     export const AddedSysInfo = 'added_sys_info';
diff --git a/src/client/datascience/interactive-ipynb/autoSaveService.ts b/src/client/datascience/interactive-ipynb/autoSaveService.ts
new file mode 100644
index 000000000000..61f69e225490
--- /dev/null
+++ b/src/client/datascience/interactive-ipynb/autoSaveService.ts
@@ -0,0 +1,142 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { inject, injectable } from 'inversify';
+import { ConfigurationChangeEvent, Event, EventEmitter, TextEditor, Uri } from 'vscode';
+import { IApplicationShell, IDocumentManager, IWorkspaceService } from '../../common/application/types';
+import '../../common/extensions';
+import { traceError } from '../../common/logger';
+import { IFileSystem } from '../../common/platform/types';
+import { IDisposable } from '../../common/types';
+import { INotebookIdentity, InteractiveWindowMessages } from '../interactive-common/interactiveWindowTypes';
+import { FileSettings, IInteractiveWindowListener, INotebookEditor, INotebookEditorProvider } from '../types';
+
+// tslint:disable: no-any
+
+/**
+ * Sends notifications to Notebooks to save the notebook.
+ * Based on auto save settings, this class will regularly check for changes and send a save requet.
+ * If window state changes or active editor changes, then notify notebooks (if auto save is configured to do so).
+ * Monitor save and modified events on editor to determine its current dirty state.
+ *
+ * @export
+ * @class AutoSaveService
+ * @implements {IInteractiveWindowListener}
+ */
+@injectable()
+export class AutoSaveService implements IInteractiveWindowListener {
+    private postEmitter: EventEmitter<{ message: string; payload: any }> = new EventEmitter<{ message: string; payload: any }>();
+    private disposables: IDisposable[] = [];
+    private notebookUri?: Uri;
+    private timeout?: ReturnType<typeof setTimeout>;
+    constructor(
+        @inject(IApplicationShell) appShell: IApplicationShell,
+        @inject(IDocumentManager) documentManager: IDocumentManager,
+        @inject(INotebookEditorProvider) private readonly notebookProvider: INotebookEditorProvider,
+        @inject(IFileSystem) private readonly fileSystem: IFileSystem,
+        @inject(IWorkspaceService) private readonly workspace: IWorkspaceService
+    ) {
+        this.workspace.onDidChangeConfiguration(this.onSettingsChanded.bind(this), this, this.disposables);
+        this.disposables.push(appShell.onDidChangeWindowState(this.onDidChangeWindowState.bind(this)));
+        this.disposables.push(documentManager.onDidChangeActiveTextEditor(this.onDidChangeActiveTextEditor.bind(this)));
+    }
+
+    public get postMessage(): Event<{ message: string; payload: any }> {
+        return this.postEmitter.event;
+    }
+
+    public onMessage(message: string, payload?: any): void {
+        if (message === InteractiveWindowMessages.NotebookIdentity) {
+            this.notebookUri = Uri.parse((payload as INotebookIdentity).resource);
+        }
+        if (message === InteractiveWindowMessages.LoadAllCellsComplete) {
+            const notebook = this.getNotebook();
+            if (!notebook) {
+                traceError(`Received message ${message}, but there is no notebook for ${this.notebookUri ? this.notebookUri.fsPath : undefined}`);
+                return;
+            }
+            this.disposables.push(notebook.modified(this.onNotebookModified, this, this.disposables));
+            this.disposables.push(notebook.saved(this.onNotebookSaved, this, this.disposables));
+        }
+    }
+    public dispose(): void | undefined {
+        this.disposables.filter(item => !!item).forEach(item => item.dispose());
+        this.clearTimeout();
+    }
+    private onNotebookModified(_: INotebookEditor) {
+        // If we haven't started a timer, then start if necessary.
+        if (!this.timeout) {
+            this.setTimer();
+        }
+    }
+    private onNotebookSaved(_: INotebookEditor) {
+        // If we haven't started a timer, then start if necessary.
+        if (!this.timeout) {
+            this.setTimer();
+        }
+    }
+    private getNotebook(): INotebookEditor | undefined {
+        const uri = this.notebookUri;
+        if (!uri) {
+            return;
+        }
+        return this.notebookProvider.editors.find(item => this.fileSystem.arePathsSame(item.file.fsPath, uri.fsPath));
+    }
+    private getAutoSaveSettings(): FileSettings {
+        const filesConfig = this.workspace.getConfiguration('files', this.notebookUri);
+        return {
+            autoSave: filesConfig.get('autoSave', 'off'),
+            autoSaveDelay: filesConfig.get('autoSaveDelay', 1000)
+        };
+    }
+    private onSettingsChanded(e: ConfigurationChangeEvent) {
+        if (e.affectsConfiguration('files.autoSave') || e.affectsConfiguration('files.autoSaveDelay')) {
+            // Reset the timer, as we may have increased it, turned it off or other.
+            this.clearTimeout();
+            this.setTimer();
+        }
+    }
+    private setTimer() {
+        const settings = this.getAutoSaveSettings();
+        if (!settings || settings.autoSave === 'off') {
+            return;
+        }
+        if (settings && settings.autoSave === 'afterDelay') {
+            // Add a timeout to save after n milli seconds.
+            // Do not use setInterval, as that will cause all handlers to queue up.
+            this.timeout = setTimeout(() => {
+                this.save();
+            }, settings.autoSaveDelay);
+        }
+    }
+    private clearTimeout() {
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+            this.timeout = undefined;
+        }
+    }
+    private save() {
+        this.clearTimeout();
+        const notebook = this.getNotebook();
+        if (notebook && notebook.isDirty) {
+            // Notify webview to perform a save.
+            this.postEmitter.fire({ message: InteractiveWindowMessages.DoSave, payload: undefined });
+        } else {
+            this.setTimer();
+        }
+    }
+    private onDidChangeWindowState() {
+        const settings = this.getAutoSaveSettings();
+        if (settings && settings.autoSave === 'onWindowChange') {
+            this.save();
+        }
+    }
+    private onDidChangeActiveTextEditor(_e?: TextEditor) {
+        const settings = this.getAutoSaveSettings();
+        if (settings && settings.autoSave === 'onFocusChange') {
+            this.save();
+        }
+    }
+}
diff --git a/src/client/datascience/interactive-ipynb/nativeEditor.ts b/src/client/datascience/interactive-ipynb/nativeEditor.ts
index affa86420c7c..29b4fd644ea7 100644
--- a/src/client/datascience/interactive-ipynb/nativeEditor.ts
+++ b/src/client/datascience/interactive-ipynb/nativeEditor.ts
@@ -9,14 +9,7 @@ import * as path from 'path';
 import * as uuid from 'uuid/v4';
 import { Event, EventEmitter, Memento, Uri, ViewColumn } from 'vscode';
 
-import {
-    IApplicationShell,
-    ICommandManager,
-    IDocumentManager,
-    ILiveShareApi,
-    IWebPanelProvider,
-    IWorkspaceService
-} from '../../common/application/types';
+import { IApplicationShell, ICommandManager, IDocumentManager, ILiveShareApi, IWebPanelProvider, IWorkspaceService } from '../../common/application/types';
 import { ContextKey } from '../../common/contextKey';
 import { traceError } from '../../common/logger';
 import { IFileSystem, TemporaryFile } from '../../common/platform/types';
@@ -28,21 +21,9 @@ import { EXTENSION_ROOT_DIR } from '../../constants';
 import { IInterpreterService } from '../../interpreter/contracts';
 import { captureTelemetry, sendTelemetryEvent } from '../../telemetry';
 import { concatMultilineString } from '../common';
-import {
-    EditorContexts,
-    Identifiers,
-    NativeKeyboardCommandTelemetryLookup,
-    NativeMouseCommandTelemetryLookup,
-    Telemetry
-} from '../constants';
+import { EditorContexts, Identifiers, NativeKeyboardCommandTelemetryLookup, NativeMouseCommandTelemetryLookup, Telemetry } from '../constants';
 import { InteractiveBase } from '../interactive-common/interactiveBase';
-import {
-    IEditCell,
-    INativeCommand,
-    InteractiveWindowMessages,
-    ISaveAll,
-    ISubmitNewCell
-} from '../interactive-common/interactiveWindowTypes';
+import { IEditCell, INativeCommand, InteractiveWindowMessages, ISaveAll, ISubmitNewCell } from '../interactive-common/interactiveWindowTypes';
 import {
     CellState,
     ICell,
@@ -74,6 +55,7 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
     private closedEvent: EventEmitter<INotebookEditor> = new EventEmitter<INotebookEditor>();
     private executedEvent: EventEmitter<INotebookEditor> = new EventEmitter<INotebookEditor>();
     private modifiedEvent: EventEmitter<INotebookEditor> = new EventEmitter<INotebookEditor>();
+    private savedEvent: EventEmitter<INotebookEditor> = new EventEmitter<INotebookEditor>();
     private loadedPromise: Deferred<void> = createDeferred<void>();
     private _file: Uri = Uri.file('');
     private _dirty: boolean = false;
@@ -129,7 +111,8 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
             errorHandler,
             path.join(EXTENSION_ROOT_DIR, 'out', 'datascience-ui', 'native-editor', 'index_bundle.js'),
             localize.DataScience.nativeEditorTitle(),
-            ViewColumn.Active);
+            ViewColumn.Active
+        );
     }
 
     public get visible(): boolean {
@@ -187,6 +170,14 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
         return this.modifiedEvent.event;
     }
 
+    public get saved(): Event<INotebookEditor> {
+        return this.savedEvent.event;
+    }
+
+    public get isDirty(): boolean {
+        return this._dirty;
+    }
+
     // tslint:disable-next-line: no-any
     public onMessage(message: string, payload: any) {
         super.onMessage(message, payload);
@@ -269,9 +260,19 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
             this.submitCode(info.code, Identifiers.EmptyFileName, 0, info.id).ignoreErrors();
 
             // Activate the other side, and send as if came from a file
-            this.ipynbProvider.show(this.file).then(_v => {
-                this.shareMessage(InteractiveWindowMessages.RemoteAddCode, { code: info.code, file: Identifiers.EmptyFileName, line: 0, id: info.id, originator: this.id, debug: false });
-            }).ignoreErrors();
+            this.ipynbProvider
+                .show(this.file)
+                .then(_v => {
+                    this.shareMessage(InteractiveWindowMessages.RemoteAddCode, {
+                        code: info.code,
+                        file: Identifiers.EmptyFileName,
+                        line: 0,
+                        id: info.id,
+                        originator: this.id,
+                        debug: false
+                    });
+                })
+                .ignoreErrors();
         }
     }
 
@@ -289,7 +290,14 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
 
                 // Activate the other side, and send as if came from a file
                 await this.ipynbProvider.show(this.file);
-                this.shareMessage(InteractiveWindowMessages.RemoteReexecuteCode, { code: info.code, file: Identifiers.EmptyFileName, line: 0, id: info.id, originator: this.id, debug: false });
+                this.shareMessage(InteractiveWindowMessages.RemoteReexecuteCode, {
+                    code: info.code,
+                    file: Identifiers.EmptyFileName,
+                    line: 0,
+                    id: info.id,
+                    originator: this.id,
+                    debug: false
+                });
             }
         } catch (exc) {
             // Make this error our cell output
@@ -298,10 +306,12 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
                     data: {
                         source: info.code,
                         cell_type: 'code',
-                        outputs: [{
-                            output_type: 'error',
-                            evalue: exc.toString()
-                        }],
+                        outputs: [
+                            {
+                                output_type: 'error',
+                                evalue: exc.toString()
+                            }
+                        ],
                         metadata: {},
                         execution_count: null
                     },
@@ -318,7 +328,6 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
 
             // Handle an error
             await this.errorHandler.handleError(exc);
-
         }
     }
 
@@ -395,8 +404,7 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
                     cell_type: 'code',
                     outputs: [],
                     source: [],
-                    metadata: {
-                    },
+                    metadata: {},
                     execution_count: null
                 }
             };
@@ -570,7 +578,6 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
             if (contents) {
                 await this.viewDocument(contents);
             }
-
         } catch (e) {
             await this.errorHandler.handleError(e);
         } finally {
@@ -615,8 +622,8 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
                 // Update our file name and dirty state
                 this._file = fileToSaveTo;
                 await this.setClean();
+                this.savedEvent.fire(this);
             }
-
         } catch (e) {
             traceError(e);
         }
diff --git a/src/client/datascience/serviceRegistry.ts b/src/client/datascience/serviceRegistry.ts
index ffba92db2bc1..435b6285d99b 100644
--- a/src/client/datascience/serviceRegistry.ts
+++ b/src/client/datascience/serviceRegistry.ts
@@ -25,6 +25,7 @@ import { DotNetIntellisenseProvider } from './interactive-common/intellisense/do
 import { JediIntellisenseProvider } from './interactive-common/intellisense/jediIntellisenseProvider';
 import { LinkProvider } from './interactive-common/linkProvider';
 import { ShowPlotListener } from './interactive-common/showPlotListener';
+import { AutoSaveService } from './interactive-ipynb/autoSaveService';
 import { NativeEditor } from './interactive-ipynb/nativeEditor';
 import { NativeEditorCommandListener } from './interactive-ipynb/nativeEditorCommandListener';
 import { NativeEditorProvider } from './interactive-ipynb/nativeEditorProvider';
@@ -123,6 +124,7 @@ export function registerTypes(serviceManager: IServiceManager) {
     serviceManager.add<IInteractiveWindowListener>(IInteractiveWindowListener, wrapType(ShowPlotListener));
     serviceManager.add<IInteractiveWindowListener>(IInteractiveWindowListener, wrapType(DebugListener));
     serviceManager.add<IInteractiveWindowListener>(IInteractiveWindowListener, wrapType(GatherListener));
+    serviceManager.add<IInteractiveWindowListener>(IInteractiveWindowListener, wrapType(AutoSaveService));
     serviceManager.addSingleton<IPlotViewerProvider>(IPlotViewerProvider, wrapType(PlotViewerProvider));
     serviceManager.add<IPlotViewer>(IPlotViewer, wrapType(PlotViewer));
     serviceManager.addSingleton<IJupyterDebugger>(IJupyterDebugger, wrapType(JupyterDebugger));
diff --git a/src/client/datascience/types.ts b/src/client/datascience/types.ts
index f0edda8be83b..9b4266655e8c 100644
--- a/src/client/datascience/types.ts
+++ b/src/client/datascience/types.ts
@@ -250,6 +250,11 @@ export interface INotebookEditor extends IInteractiveBase {
     closed: Event<INotebookEditor>;
     executed: Event<INotebookEditor>;
     modified: Event<INotebookEditor>;
+    saved: Event<INotebookEditor>;
+    /**
+     * `true` if there are unpersisted changes.
+     */
+    readonly isDirty: boolean;
     readonly file: Uri;
     readonly visible: boolean;
     readonly active: boolean;
@@ -394,6 +399,11 @@ export interface IJupyterCommandFactory {
 }
 
 // Config settings we pass to our react code
+export type FileSettings = {
+    autoSaveDelay: number;
+    autoSave: 'afterDelay' | 'off' | 'onFocusChange' | 'onWindowChange';
+};
+
 export interface IDataScienceExtraSettings extends IDataScienceSettings {
     extraSettings: {
         editorCursor: string;
diff --git a/src/client/datascience/webViewHost.ts b/src/client/datascience/webViewHost.ts
index 114e8fece340..a28255d4fec0 100644
--- a/src/client/datascience/webViewHost.ts
+++ b/src/client/datascience/webViewHost.ts
@@ -246,6 +246,8 @@ export class WebViewHost<IMapping> implements IDisposable {
             event.affectsConfiguration('editor.fontFamily') ||
             event.affectsConfiguration('editor.cursorStyle') ||
             event.affectsConfiguration('editor.cursorBlinking') ||
+            event.affectsConfiguration('files.autoSave') ||
+            event.affectsConfiguration('files.autoSaveDelay') ||
             event.affectsConfiguration('python.dataScience.enableGather')) {
             // See if the theme changed
             const newSettings = this.generateDataScienceExtraSettings();
diff --git a/src/datascience-ui/interactive-common/mainStateController.ts b/src/datascience-ui/interactive-common/mainStateController.ts
index d40a34e3eb1a..5d5049ec8a9a 100644
--- a/src/datascience-ui/interactive-common/mainStateController.ts
+++ b/src/datascience-ui/interactive-common/mainStateController.ts
@@ -56,10 +56,10 @@ export interface IMainStateControllerProps {
 
 // tslint:disable-next-line: max-func-body-length
 export class MainStateController implements IMessageHandler {
+    protected readonly postOffice: PostOffice = new PostOffice();
     private stackLimit = 10;
     private pendingState: IMainState;
     private renderedState: IMainState;
-    private postOffice: PostOffice = new PostOffice();
     private intellisenseProvider: IntellisenseProvider;
     private onigasmPromise: Deferred<ArrayBuffer> | undefined;
     private tmlangugePromise: Deferred<string> | undefined;
diff --git a/src/datascience-ui/native-editor/nativeEditorStateController.ts b/src/datascience-ui/native-editor/nativeEditorStateController.ts
index 371939f22781..6ceb10dda9a6 100644
--- a/src/datascience-ui/native-editor/nativeEditorStateController.ts
+++ b/src/datascience-ui/native-editor/nativeEditorStateController.ts
@@ -23,7 +23,6 @@ export class NativeEditorStateController extends MainStateController {
     constructor(props: IMainStateControllerProps) {
         super(props);
     }
-
     // tslint:disable-next-line: no-any
     public handleMessage(msg: string, payload?: any) {
         // Handle message before base class so we will
@@ -54,6 +53,9 @@ export class NativeEditorStateController extends MainStateController {
             case InteractiveWindowMessages.NotebookAddCellBelow:
                 this.addNewCell();
                 break;
+            case  InteractiveWindowMessages.DoSave:
+                this.save();
+                break;
 
             default:
                 break;
diff --git a/src/datascience-ui/react-common/postOffice.ts b/src/datascience-ui/react-common/postOffice.ts
index 017c7def8c0b..afb52319e863 100644
--- a/src/datascience-ui/react-common/postOffice.ts
+++ b/src/datascience-ui/react-common/postOffice.ts
@@ -14,10 +14,11 @@ export interface IVsCodeApi {
     getState() : any;
 }
 
-export interface IMessageHandler {
-    // tslint:disable-next-line:no-any
-    handleMessage(type: string, payload?: any) : boolean;
-}
+    export interface IMessageHandler {
+        // tslint:disable-next-line:no-any
+        handleMessage(type: string, payload?: any) : boolean;
+        dispose?(): void;
+    }
 
 // This special function talks to vscode from a web panel
 export declare function acquireVsCodeApi(): IVsCodeApi;
@@ -66,7 +67,7 @@ export class PostOffice implements IDisposable {
         // Only do this once as it crashes if we ask more than once
         // tslint:disable-next-line:no-typeof-undefined
         if (!this.vscodeApi && typeof acquireVsCodeApi !== 'undefined') {
-            this.vscodeApi = acquireVsCodeApi();
+            this.vscodeApi = acquireVsCodeApi(); // NOSONAR
         }
         if (!this.registered) {
             this.registered = true;
diff --git a/src/datascience-ui/react-common/settingsReactSide.ts b/src/datascience-ui/react-common/settingsReactSide.ts
index 4bd071381afa..ca1a370e78a5 100644
--- a/src/datascience-ui/react-common/settingsReactSide.ts
+++ b/src/datascience-ui/react-common/settingsReactSide.ts
@@ -28,7 +28,7 @@ export function updateSettings(jsonSettingsString: string) {
 function load() {
     // tslint:disable-next-line:no-typeof-undefined
     if (typeof getInitialSettings !== 'undefined') {
-        loadedSettings = <IDataScienceExtraSettings>getInitialSettings();
+        loadedSettings = <IDataScienceExtraSettings>getInitialSettings(); // NOSONAR
     } else {
         // Default settings for tests
         loadedSettings = {
diff --git a/src/test/common.ts b/src/test/common.ts
index a5172832b799..83807480abf7 100644
--- a/src/test/common.ts
+++ b/src/test/common.ts
@@ -18,7 +18,7 @@ import { IServiceContainer, IServiceManager } from '../client/ioc/types';
 import {
     EXTENSION_ROOT_DIR_FOR_TESTS, IS_MULTI_ROOT_TEST, IS_PERF_TEST, IS_SMOKE_TEST
 } from './constants';
-import { noop, sleep } from './core';
+import { noop } from './core';
 
 const StreamZip = require('node-stream-zip');
 
@@ -410,27 +410,31 @@ export async function unzip(zipFile: string, targetFolder: string): Promise<void
         });
     });
 }
-
+/**
+ * Wait for a condition to be fulfilled within a timeout.
+ *
+ * @export
+ * @param {() => Promise<boolean>} condition
+ * @param {number} timeoutMs
+ * @param {string} errorMessage
+ * @returns {Promise<void>}
+ */
 export async function waitForCondition(condition: () => Promise<boolean>, timeoutMs: number, errorMessage: string): Promise<void> {
     return new Promise<void>(async (resolve, reject) => {
-        let completed = false;
         const timeout = setTimeout(() => {
-            if (!completed) {
-                reject(new Error(errorMessage));
-            }
-            completed = true;
+            clearTimeout(timeout);
+            // tslint:disable-next-line: no-use-before-declare
+            clearTimeout(timer);
+            reject(new Error(errorMessage));
         }, timeoutMs);
-        for (let i = 0; i < timeoutMs / 1000; i += 1) {
-            if (await condition()) {
-                clearTimeout(timeout);
-                resolve();
-                return;
-            }
-            await sleep(500);
-            if (completed) {
+        const timer = setInterval(async () => {
+            if (!await condition().catch(() => false)) {
                 return;
             }
-        }
+            clearTimeout(timeout);
+            clearTimeout(timer);
+            resolve();
+        }, 10);
     });
 }
 
diff --git a/src/test/datascience/dataScienceIocContainer.ts b/src/test/datascience/dataScienceIocContainer.ts
index 9cd482d3023b..1ff5fdb9cf2b 100644
--- a/src/test/datascience/dataScienceIocContainer.ts
+++ b/src/test/datascience/dataScienceIocContainer.ts
@@ -7,6 +7,7 @@ import { ReactWrapper } from 'enzyme';
 import { interfaces } from 'inversify';
 import * as path from 'path';
 import { SemVer } from 'semver';
+import { anything, instance, mock, when } from 'ts-mockito';
 import * as TypeMoq from 'typemoq';
 import {
     ConfigurationChangeEvent,
@@ -20,7 +21,6 @@ import {
     WorkspaceFolder
 } from 'vscode';
 import * as vsls from 'vsls/vscode';
-
 import { ILanguageServer, ILanguageServerAnalysisOptions } from '../../client/activation/types';
 import { TerminalManager } from '../../client/common/application/terminalManager';
 import {
@@ -37,6 +37,7 @@ import {
     IWorkspaceService,
     WebPanelMessage
 } from '../../client/common/application/types';
+import { WorkspaceService } from '../../client/common/application/workspace';
 import { AsyncDisposableRegistry } from '../../client/common/asyncDisposableRegistry';
 import { PythonSettings } from '../../client/common/configSettings';
 import { EXTENSION_ROOT_DIR } from '../../client/common/constants';
@@ -108,6 +109,7 @@ import { GatherListener } from '../../client/datascience/gather/gatherListener';
 import {
     DotNetIntellisenseProvider
 } from '../../client/datascience/interactive-common/intellisense/dotNetIntellisenseProvider';
+import { AutoSaveService } from '../../client/datascience/interactive-ipynb/autoSaveService';
 import { NativeEditor } from '../../client/datascience/interactive-ipynb/nativeEditor';
 import { NativeEditorCommandListener } from '../../client/datascience/interactive-ipynb/nativeEditorCommandListener';
 import { InteractiveWindow } from '../../client/datascience/interactive-window/interactiveWindow';
@@ -249,6 +251,7 @@ import { MockJupyterManagerFactory } from './mockJupyterManagerFactory';
 import { MockLanguageServer } from './mockLanguageServer';
 import { MockLanguageServerAnalysisOptions } from './mockLanguageServerAnalysisOptions';
 import { MockLiveShareApi } from './mockLiveShare';
+import { MockWorkspaceConfiguration } from './mockWorkspaceConfig';
 import { blurWindow, createMessageEvent } from './reactHelpers';
 import { TestInteractiveWindowProvider } from './testInteractiveWindowProvider';
 import { TestNativeEditorProvider } from './testNativeEditorProvider';
@@ -259,6 +262,8 @@ export class DataScienceIocContainer extends UnitTestIocContainer {
     public wrapper: ReactWrapper<any, Readonly<{}>, React.Component> | undefined;
     public wrapperCreatedPromise: Deferred<boolean> | undefined;
     public postMessage: ((ev: MessageEvent) => void) | undefined;
+    public mockedWorkspaceConfig!: WorkspaceConfiguration;
+    public applicationShell!: TypeMoq.IMock<IApplicationShell>;
     // tslint:disable-next-line:no-any
     private missedMessages: any[] = [];
     private pythonSettings = new class extends PythonSettings {
@@ -391,6 +396,7 @@ export class DataScienceIocContainer extends UnitTestIocContainer {
         this.serviceManager.addSingleton<ILanguageServer>(ILanguageServer, MockLanguageServer);
         this.serviceManager.addSingleton<ILanguageServerAnalysisOptions>(ILanguageServerAnalysisOptions, MockLanguageServerAnalysisOptions);
         this.serviceManager.add<IInteractiveWindowListener>(IInteractiveWindowListener, DotNetIntellisenseProvider);
+        this.serviceManager.add<IInteractiveWindowListener>(IInteractiveWindowListener, AutoSaveService);
         this.serviceManager.add<IProtocolParser>(IProtocolParser, ProtocolParser);
         this.serviceManager.addSingleton<IDebugService>(IDebugService, MockDebuggerService);
         this.serviceManager.addSingleton<ICellHashProvider>(ICellHashProvider, CellHashProvider);
@@ -416,8 +422,9 @@ export class DataScienceIocContainer extends UnitTestIocContainer {
 
         // Also setup a mock execution service and interpreter service
         const condaService = TypeMoq.Mock.ofType<ICondaService>();
-        const appShell = TypeMoq.Mock.ofType<IApplicationShell>();
-        const workspaceService = TypeMoq.Mock.ofType<IWorkspaceService>();
+        const appShell = this.applicationShell = TypeMoq.Mock.ofType<IApplicationShell>();
+        // const workspaceService = TypeMoq.Mock.ofType<IWorkspaceService>();
+        const workspaceService = mock(WorkspaceService);
         const configurationService = TypeMoq.Mock.ofType<IConfigurationService>();
         const interpreterDisplay = TypeMoq.Mock.ofType<IInterpreterDisplay>();
         const datascience = TypeMoq.Mock.ofType<IDataScience>();
@@ -454,18 +461,14 @@ export class DataScienceIocContainer extends UnitTestIocContainer {
             debugJustMyCode: true
         };
 
-        const workspaceConfig: TypeMoq.IMock<WorkspaceConfiguration> = TypeMoq.Mock.ofType<WorkspaceConfiguration>();
-        workspaceConfig.setup(ws => ws.has(TypeMoq.It.isAnyString()))
-            .returns(() => false);
-        workspaceConfig.setup(ws => ws.get(TypeMoq.It.isAnyString()))
-            .returns(() => undefined);
-        workspaceConfig.setup(ws => ws.get(TypeMoq.It.isAnyString(), TypeMoq.It.isAny()))
-            .returns((_s, d) => d);
-
+        const workspaceConfig = this.mockedWorkspaceConfig = mock(MockWorkspaceConfiguration);
         configurationService.setup(c => c.getSettings(TypeMoq.It.isAny())).returns(() => this.pythonSettings);
-        workspaceService.setup(c => c.getConfiguration(TypeMoq.It.isAny())).returns(() => workspaceConfig.object);
-        workspaceService.setup(c => c.getConfiguration(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => workspaceConfig.object);
-        workspaceService.setup(w => w.onDidChangeConfiguration).returns(() => this.configChangeEvent.event);
+        when(workspaceConfig.get(anything(), anything())).thenCall((_, defaultValue) => defaultValue);
+        when(workspaceConfig.has(anything())).thenReturn(false);
+        when((workspaceConfig as any).then).thenReturn(undefined);
+        when(workspaceService.getConfiguration(anything())).thenReturn(instance(workspaceConfig));
+        when(workspaceService.getConfiguration(anything(), anything())).thenReturn(instance(workspaceConfig));
+        when(workspaceService.onDidChangeConfiguration).thenReturn(this.configChangeEvent.event);
         interpreterDisplay.setup(i => i.refresh(TypeMoq.It.isAny())).returns(() => Promise.resolve());
         const startTime = Date.now();
         datascience.setup(d => d.activationStartTime).returns(() => startTime);
@@ -490,18 +493,12 @@ export class DataScienceIocContainer extends UnitTestIocContainer {
                 noop();
             }
         }
-        workspaceService.setup(w => w.createFileSystemWatcher(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => {
-            return new MockFileSystemWatcher();
-        });
-        workspaceService
-            .setup(w => w.hasWorkspaceFolders)
-            .returns(() => true);
+        when(workspaceService.createFileSystemWatcher(anything(), anything(), anything(), anything())).thenReturn(new MockFileSystemWatcher());
+        when(workspaceService.hasWorkspaceFolders).thenReturn(true);
         const testWorkspaceFolder = path.join(EXTENSION_ROOT_DIR, 'src', 'test', 'datascience');
         const workspaceFolder = this.createMoqWorkspaceFolder(testWorkspaceFolder);
-        workspaceService
-            .setup(w => w.workspaceFolders)
-            .returns(() => [workspaceFolder]);
-        workspaceService.setup(w => w.rootPath).returns(() => '~');
+        when(workspaceService.workspaceFolders).thenReturn([workspaceFolder]);
+        when(workspaceService.rootPath).thenReturn('~');
 
         // Look on the path for python
         const pythonPath = this.findPythonPath();
@@ -528,7 +525,7 @@ export class DataScienceIocContainer extends UnitTestIocContainer {
         this.serviceManager.addSingletonInstance<ICondaService>(ICondaService, condaService.object);
         this.serviceManager.addSingletonInstance<IApplicationShell>(IApplicationShell, appShell.object);
         this.serviceManager.addSingletonInstance<IDocumentManager>(IDocumentManager, this.documentManager);
-        this.serviceManager.addSingletonInstance<IWorkspaceService>(IWorkspaceService, workspaceService.object);
+        this.serviceManager.addSingletonInstance<IWorkspaceService>(IWorkspaceService, instance(workspaceService));
         this.serviceManager.addSingletonInstance<IConfigurationService>(IConfigurationService, configurationService.object);
         this.serviceManager.addSingletonInstance<IDataScience>(IDataScience, datascience.object);
         this.serviceManager.addSingleton<IBufferDecoder>(IBufferDecoder, BufferDecoder);
diff --git a/src/test/datascience/mockDocumentManager.ts b/src/test/datascience/mockDocumentManager.ts
index 3ef780303f82..3c8052fc2c08 100644
--- a/src/test/datascience/mockDocumentManager.ts
+++ b/src/test/datascience/mockDocumentManager.ts
@@ -31,7 +31,7 @@ export class MockDocumentManager implements IDocumentManager {
     public textDocuments: TextDocument[] = [];
     public activeTextEditor: TextEditor | undefined;
     public visibleTextEditors: TextEditor[] = [];
-    private didChangeEmitter = new EventEmitter<TextEditor>();
+    public didChangeEmitter = new EventEmitter<TextEditor>();
     private didOpenEmitter = new EventEmitter<TextDocument>();
     private didChangeVisibleEmitter = new EventEmitter<TextEditor[]>();
     private didChangeTextEditorSelectionEmitter = new EventEmitter<TextEditorSelectionChangeEvent>();
diff --git a/src/test/datascience/mockWorkspaceConfig.ts b/src/test/datascience/mockWorkspaceConfig.ts
new file mode 100644
index 000000000000..5a6b6e1fe48e
--- /dev/null
+++ b/src/test/datascience/mockWorkspaceConfig.ts
@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { ConfigurationTarget, WorkspaceConfiguration } from 'vscode';
+
+export class MockWorkspaceConfiguration implements WorkspaceConfiguration {
+    // tslint:disable: no-any
+    public get(key: string): any;
+    public get<T>(section: string): T | undefined;
+    public get<T>(section: string, defaultValue: T): T;
+    public get(section: any, defaultValue?: any): any;
+    public get(_: string, defaultValue?: any): any {
+        return arguments.length > 1 ? defaultValue : (undefined as any);
+    }
+    public has(_section: string): boolean {
+        return false;
+    }
+    public inspect<T>(
+        _section: string
+    ): { key: string; defaultValue?: T | undefined; globalValue?: T | undefined; workspaceValue?: T | undefined; workspaceFolderValue?: T | undefined } | undefined {
+        return;
+    }
+    public update(_section: string, _value: any, _configurationTarget?: boolean | ConfigurationTarget | undefined): Promise<void> {
+        return Promise.resolve();
+    }
+}
diff --git a/src/test/datascience/nativeEditor.functional.test.tsx b/src/test/datascience/nativeEditor.functional.test.tsx
index dc0704d81c01..65d8a4624c11 100644
--- a/src/test/datascience/nativeEditor.functional.test.tsx
+++ b/src/test/datascience/nativeEditor.functional.test.tsx
@@ -3,16 +3,22 @@
 
 'use strict';
 
-import * as assert from 'assert';
+import { assert, expect, use } from 'chai';
+import * as chaiAsPromised from 'chai-as-promised';
 import { ReactWrapper } from 'enzyme';
-import * as monacoEditor from 'monaco-editor/esm/vs/editor/editor.api';
+import { EventEmitter } from 'events';
+import * as fs from 'fs-extra';
 import * as path from 'path';
+import * as sinon from 'sinon';
+import { anything, when } from 'ts-mockito';
 import * as TypeMoq from 'typemoq';
-import { Disposable, TextDocument, TextEditor, Uri } from 'vscode';
+import { Disposable, TextDocument, TextEditor, Uri, WindowState } from 'vscode';
 import { IApplicationShell, IDocumentManager } from '../../client/common/application/types';
 import { createDeferred } from '../../client/common/utils/async';
+import { createTemporaryFile } from '../../client/common/utils/fs';
 import { noop } from '../../client/common/utils/misc';
 import { Identifiers } from '../../client/datascience/constants';
+import { InteractiveWindowMessages } from '../../client/datascience/interactive-common/interactiveWindowTypes';
 import { JupyterExecutionFactory } from '../../client/datascience/jupyter/jupyterExecutionFactory';
 import { ICell, IJupyterExecution, INotebookEditorProvider, INotebookExporter } from '../../client/datascience/types';
 import { PythonInterpreter } from '../../client/interpreter/contracts';
@@ -21,16 +27,14 @@ import { CellOutput } from '../../datascience-ui/interactive-common/cellOutput';
 import { Editor } from '../../datascience-ui/interactive-common/editor';
 import { NativeCell } from '../../datascience-ui/native-editor/nativeCell';
 import { NativeEditor } from '../../datascience-ui/native-editor/nativeEditor';
+import { NativeEditorStateController } from '../../datascience-ui/native-editor/nativeEditorStateController';
 import { IKeyboardEvent } from '../../datascience-ui/react-common/event';
 import { ImageButton } from '../../datascience-ui/react-common/imageButton';
 import { IMonacoEditorState, MonacoEditor } from '../../datascience-ui/react-common/monacoEditor';
+import { waitForCondition } from '../common';
 import { DataScienceIocContainer } from './dataScienceIocContainer';
-import {
-    addCell,
-    closeNotebook,
-    createNewEditor,
-    getNativeCellResults,
-    mountNativeWebView, openEditor, runMountedTest, setupWebview } from './nativeEditorTestHelpers';
+import { MockDocumentManager } from './mockDocumentManager';
+import { addCell, closeNotebook, createNewEditor, getNativeCellResults, mountNativeWebView, openEditor, runMountedTest, setupWebview } from './nativeEditorTestHelpers';
 import { waitForUpdate } from './reactHelpers';
 import {
     addContinuousMockData,
@@ -47,13 +51,13 @@ import {
     verifyHtmlOnCell,
     waitForMessageResponse
 } from './testHelpers';
+use(chaiAsPromised);
 
 //import { asyncDump } from '../common/asyncDump';
 // tslint:disable:max-func-body-length trailing-comma no-any no-multiline-string
 suite('DataScience Native Editor', () => {
-
     function createFileCell(cell: any, data: any): ICell {
-        const newCell = { type: 'preview', id: 'FakeID', file: Identifiers.EmptyFileName, line: 0, state: 2, ...cell};
+        const newCell = { type: 'preview', id: 'FakeID', file: Identifiers.EmptyFileName, line: 0, state: 2, ...cell };
         newCell.data = { cell_type: 'code', execution_count: null, metadata: {}, outputs: [], source: '', ...data };
 
         return newCell;
@@ -287,7 +291,13 @@ suite('DataScience Native Editor', () => {
             await waitForMessageResponse(ioc, () => runAllButton!.simulate('click'));
             await waitForUpdate(wrapper, NativeEditor, 15);
             verifyHtmlOnCell(wrapper, 'NativeCell', `1`, 0);
-        }, () => { return ioc; });
+        },
+        () => {
+                // Disable the warning displayed by nodejs when there are too many listeners.
+                EventEmitter.defaultMaxListeners = 15;
+                return ioc;
+            }
+        );
 
         test('Failure', async () => {
             // Make a dummy class that will fail during launch
@@ -308,7 +318,7 @@ suite('DataScience Native Editor', () => {
         });
     });
 
-    suite('Editor Keyboard tests', () => {
+    suite('Editor tests', () => {
         let wrapper: ReactWrapper<any, Readonly<{}>, React.Component>;
         const disposables: Disposable[] = [];
         let ioc: DataScienceIocContainer;
@@ -317,9 +327,15 @@ suite('DataScience Native Editor', () => {
             { id: 'NotebookImport#1', data: { source: 'b=2\nb' } },
             { id: 'NotebookImport#2', data: { source: 'c=3\nc' } }
         ];
-        setup(async function() {
+        let notebookFile: {
+            filePath: string;
+            cleanupCallback: Function;
+        };
+        function initIoc() {
             ioc = new DataScienceIocContainer();
             ioc.registerDataScienceTypes();
+        }
+        async function setupFunction(this: Mocha.Context) {
             const wrapperPossiblyUndefined = await setupWebview(ioc);
             if (wrapperPossiblyUndefined) {
                 wrapper = wrapperPossiblyUndefined;
@@ -330,13 +346,16 @@ suite('DataScience Native Editor', () => {
                 const runAllCells = baseFile.map(cell => {
                     return createFileCell(cell, cell.data);
                 });
+                // Use a real file so we can save notebook to a file.
+                // This is used in some tests (saving).
+                notebookFile = await createTemporaryFile('.ipynb');
                 const notebook = await ioc.get<INotebookExporter>(INotebookExporter).translateToNotebook(runAllCells, undefined);
-                await Promise.all([waitForUpdate(wrapper, NativeEditor, 1), openEditor(ioc, JSON.stringify(notebook))]);
+                await Promise.all([waitForUpdate(wrapper, NativeEditor, 1), openEditor(ioc, JSON.stringify(notebook), notebookFile.filePath)]);
             } else {
                 // tslint:disable-next-line: no-invalid-this
                 this.skip();
             }
-        });
+        }
 
         teardown(async () => {
             for (const disposable of disposables) {
@@ -350,6 +369,11 @@ suite('DataScience Native Editor', () => {
                 }
             }
             await ioc.dispose();
+            try {
+                notebookFile.cleanupCallback();
+            } catch {
+                noop();
+            }
         });
 
         function clickCell(cellIndex: number) {
@@ -359,6 +383,7 @@ suite('DataScience Native Editor', () => {
                 .simulate('click');
             wrapper.update();
         }
+
         function simulateKeyPressOnCell(cellIndex: number, keyboardEvent: Partial<IKeyboardEvent> & { code: string }) {
             const event = { ...createKeyboardEventForCell(keyboardEvent), ...keyboardEvent };
             wrapper
@@ -369,324 +394,595 @@ suite('DataScience Native Editor', () => {
             wrapper.update();
         }
 
-        test('None of the cells are selected by default', async () => {
-            assert.ok(!isCellSelected(wrapper, 'NativeCell', 0));
-            assert.ok(!isCellSelected(wrapper, 'NativeCell', 1));
-            assert.ok(!isCellSelected(wrapper, 'NativeCell', 2));
-        });
+        suite('Selection/Focus', () => {
+            setup(async function() {
+                initIoc();
+                // tslint:disable-next-line: no-invalid-this
+                await setupFunction.call(this);
+            });
+            test('None of the cells are selected by default', async () => {
+                assert.ok(!isCellSelected(wrapper, 'NativeCell', 0));
+                assert.ok(!isCellSelected(wrapper, 'NativeCell', 1));
+                assert.ok(!isCellSelected(wrapper, 'NativeCell', 2));
+            });
 
-        test('None of the cells are not focused by default', async () => {
-            assert.ok(!isCellFocused(wrapper, 'NativeCell', 0));
-            assert.ok(!isCellFocused(wrapper, 'NativeCell', 1));
-            assert.ok(!isCellFocused(wrapper, 'NativeCell', 2));
-        });
+            test('None of the cells are not focused by default', async () => {
+                assert.ok(!isCellFocused(wrapper, 'NativeCell', 0));
+                assert.ok(!isCellFocused(wrapper, 'NativeCell', 1));
+                assert.ok(!isCellFocused(wrapper, 'NativeCell', 2));
+            });
 
-        test('Select cells by clicking them', async () => {
-            // Click first cell, then second, then third.
-            clickCell(0);
-            assert.ok(isCellSelected(wrapper, 'NativeCell', 0));
-            assert.equal(isCellSelected(wrapper, 'NativeCell', 1), false);
-            assert.equal(isCellSelected(wrapper, 'NativeCell', 2), false);
-
-            clickCell(1);
-            assert.ok(isCellSelected(wrapper, 'NativeCell', 1));
-            assert.equal(isCellSelected(wrapper, 'NativeCell', 0), false);
-            assert.equal(isCellSelected(wrapper, 'NativeCell', 2), false);
-
-            clickCell(2);
-            assert.ok(isCellSelected(wrapper, 'NativeCell', 2));
-            assert.equal(isCellSelected(wrapper, 'NativeCell', 0), false);
-            assert.equal(isCellSelected(wrapper, 'NativeCell', 1), false);
-        });
+            test('Select cells by clicking them', async () => {
+                // Click first cell, then second, then third.
+                clickCell(0);
+                assert.ok(isCellSelected(wrapper, 'NativeCell', 0));
+                assert.equal(isCellSelected(wrapper, 'NativeCell', 1), false);
+                assert.equal(isCellSelected(wrapper, 'NativeCell', 2), false);
 
-        test('Traverse cells by using ArrowUp and ArrowDown, k and j', async () => {
-            const keyCodesAndPositions = [
-                // When we press arrow down in the first cell, then second cell gets selected.
-                { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 0, expectedSelectedCell: 1 },
-                { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 1, expectedSelectedCell: 2 },
-                // Arrow down on last cell is a noop.
-                { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 2, expectedSelectedCell: 2 },
-                // When we press arrow up in the last cell, then second cell (from bottom) gets selected.
-                { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 2, expectedSelectedCell: 1 },
-                { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 1, expectedSelectedCell: 0 },
-                // Arrow up on last cell is a noop.
-                { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 0, expectedSelectedCell: 0 },
-
-                // Same tests as above with k and j.
-                { keyCode: 'j', cellIndexToPressKeysOn: 0, expectedSelectedCell: 1 },
-                { keyCode: 'j', cellIndexToPressKeysOn: 1, expectedSelectedCell: 2 },
-                // Arrow down on last cell is a noop.
-                { keyCode: 'j', cellIndexToPressKeysOn: 2, expectedSelectedCell: 2 },
-                { keyCode: 'k', cellIndexToPressKeysOn: 2, expectedSelectedCell: 1 },
-                { keyCode: 'k', cellIndexToPressKeysOn: 1, expectedSelectedCell: 0 },
-                // Arrow up on last cell is a noop.
-                { keyCode: 'k', cellIndexToPressKeysOn: 0, expectedSelectedCell: 0 }
-            ];
-
-            // keypress on first cell, then second, then third.
-            // Test navigation through all cells, by traversing up and down.
-            for (const testItem of keyCodesAndPositions) {
-                simulateKeyPressOnCell(testItem.cellIndexToPressKeysOn, { code: testItem.keyCode });
-
-                // Check if it is selected.
-                // Only the cell at the index should be selected, as that's what we click.
-                assert.ok(isCellSelected(wrapper, 'NativeCell', testItem.expectedSelectedCell) === true);
-            }
-        });
+                clickCell(1);
+                assert.ok(isCellSelected(wrapper, 'NativeCell', 1));
+                assert.equal(isCellSelected(wrapper, 'NativeCell', 0), false);
+                assert.equal(isCellSelected(wrapper, 'NativeCell', 2), false);
 
-        test('Traverse cells by using ArrowUp and ArrowDown, k and j', async () => {
-            const keyCodesAndPositions = [
-                // When we press arrow down in the first cell, then second cell gets selected.
-                { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 0, expectedIndex: 1 },
-                { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 1, expectedIndex: 2 },
-                // Arrow down on last cell is a noop.
-                { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 2, expectedIndex: 2 },
-                // When we press arrow up in the last cell, then second cell (from bottom) gets selected.
-                { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 2, expectedIndex: 1 },
-                { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 1, expectedIndex: 0 },
-                // Arrow up on last cell is a noop.
-                { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 0, expectedIndex: 0 }
-            ];
-
-            // keypress on first cell, then second, then third.
-            // Test navigation through all cells, by traversing up and down.
-            for (const testItem of keyCodesAndPositions) {
-                simulateKeyPressOnCell(testItem.cellIndexToPressKeysOn, { code: testItem.keyCode });
-
-                // Check if it is selected.
-                // Only the cell at the index should be selected, as that's what we click.
-                assert.ok(isCellSelected(wrapper, 'NativeCell', testItem.expectedIndex) === true);
-            }
+                clickCell(2);
+                assert.ok(isCellSelected(wrapper, 'NativeCell', 2));
+                assert.equal(isCellSelected(wrapper, 'NativeCell', 0), false);
+                assert.equal(isCellSelected(wrapper, 'NativeCell', 1), false);
+            });
         });
 
-        test('Pressing \'Enter\' on a selected cell, results in focus being set to the code', async () => {
-            // For some reason we cannot allow setting focus to monaco editor.
-            // Tests are known to fall over if allowed.
-            const editor = wrapper
-                .find(NativeCell)
-                .at(1)
-                .find(Editor)
-                .first();
-            (editor.instance() as Editor).giveFocus = () => editor.props().focused!();
-
-            const update = waitForUpdate(wrapper, NativeEditor, 1);
-            clickCell(1);
-            simulateKeyPressOnCell(1, { code: 'Enter', editorInfo: undefined });
-            await update;
-
-            // The second cell should be selected.
-            assert.ok(isCellFocused(wrapper, 'NativeCell', 1));
-        });
+        suite('Keyboard Shortcuts', () => {
+            setup(async function() {
+                initIoc();
+                // tslint:disable-next-line: no-invalid-this
+                await setupFunction.call(this);
+            });
 
-        test('Pressing \'Escape\' on a focused cell results in the cell being selected', async () => {
-            // First focus the cell.
-            let update = waitForUpdate(wrapper, NativeEditor, 1);
-            clickCell(1);
-            simulateKeyPressOnCell(1, { code: 'Enter', editorInfo: undefined });
-            await update;
-
-            // The second cell should be selected.
-            assert.equal(isCellSelected(wrapper, 'NativeCell', 1), false);
-            assert.equal(isCellFocused(wrapper, 'NativeCell', 1), true);
-
-            // Now hit escape.
-            update = waitForUpdate(wrapper, NativeEditor, 1);
-            simulateKeyPressOnCell(1, { code: 'Escape' });
-            await update;
-
-            // Confirm it is no longer focused, and it is selected.
-            assert.equal(isCellSelected(wrapper, 'NativeCell', 1), true);
-            assert.equal(isCellFocused(wrapper, 'NativeCell', 1), false);
-        });
+            test('Traverse cells by using ArrowUp and ArrowDown, k and j', async () => {
+                const keyCodesAndPositions = [
+                    // When we press arrow down in the first cell, then second cell gets selected.
+                    { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 0, expectedSelectedCell: 1 },
+                    { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 1, expectedSelectedCell: 2 },
+                    // Arrow down on last cell is a noop.
+                    { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 2, expectedSelectedCell: 2 },
+                    // When we press arrow up in the last cell, then second cell (from bottom) gets selected.
+                    { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 2, expectedSelectedCell: 1 },
+                    { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 1, expectedSelectedCell: 0 },
+                    // Arrow up on last cell is a noop.
+                    { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 0, expectedSelectedCell: 0 },
+
+                    // Same tests as above with k and j.
+                    { keyCode: 'j', cellIndexToPressKeysOn: 0, expectedSelectedCell: 1 },
+                    { keyCode: 'j', cellIndexToPressKeysOn: 1, expectedSelectedCell: 2 },
+                    // Arrow down on last cell is a noop.
+                    { keyCode: 'j', cellIndexToPressKeysOn: 2, expectedSelectedCell: 2 },
+                    { keyCode: 'k', cellIndexToPressKeysOn: 2, expectedSelectedCell: 1 },
+                    { keyCode: 'k', cellIndexToPressKeysOn: 1, expectedSelectedCell: 0 },
+                    // Arrow up on last cell is a noop.
+                    { keyCode: 'k', cellIndexToPressKeysOn: 0, expectedSelectedCell: 0 }
+                ];
+
+                // keypress on first cell, then second, then third.
+                // Test navigation through all cells, by traversing up and down.
+                for (const testItem of keyCodesAndPositions) {
+                    simulateKeyPressOnCell(testItem.cellIndexToPressKeysOn, { code: testItem.keyCode });
+
+                    // Check if it is selected.
+                    // Only the cell at the index should be selected, as that's what we click.
+                    assert.ok(isCellSelected(wrapper, 'NativeCell', testItem.expectedSelectedCell) === true);
+                }
+            });
 
-        test('Pressing \'Shift+Enter\' on a selected cell executes the cell and advances to the next cell', async () => {
-            clickCell(1);
-            const update = waitForUpdate(wrapper, NativeEditor, 7);
-            simulateKeyPressOnCell(1, { code: 'Enter', shiftKey: true, editorInfo: undefined });
-            await update;
-            wrapper.update();
+            test('Traverse cells by using ArrowUp and ArrowDown, k and j', async () => {
+                const keyCodesAndPositions = [
+                    // When we press arrow down in the first cell, then second cell gets selected.
+                    { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 0, expectedIndex: 1 },
+                    { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 1, expectedIndex: 2 },
+                    // Arrow down on last cell is a noop.
+                    { keyCode: 'ArrowDown', cellIndexToPressKeysOn: 2, expectedIndex: 2 },
+                    // When we press arrow up in the last cell, then second cell (from bottom) gets selected.
+                    { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 2, expectedIndex: 1 },
+                    { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 1, expectedIndex: 0 },
+                    // Arrow up on last cell is a noop.
+                    { keyCode: 'ArrowUp', cellIndexToPressKeysOn: 0, expectedIndex: 0 }
+                ];
+
+                // keypress on first cell, then second, then third.
+                // Test navigation through all cells, by traversing up and down.
+                for (const testItem of keyCodesAndPositions) {
+                    simulateKeyPressOnCell(testItem.cellIndexToPressKeysOn, { code: testItem.keyCode });
+
+                    // Check if it is selected.
+                    // Only the cell at the index should be selected, as that's what we click.
+                    assert.ok(isCellSelected(wrapper, 'NativeCell', testItem.expectedIndex) === true);
+                }
+            });
 
-            // Ensure cell was executed.
-            verifyHtmlOnCell(wrapper, 'NativeCell', '<span>2</span>', 1);
+            test('Pressing \'Enter\' on a selected cell, results in focus being set to the code', async () => {
+                // For some reason we cannot allow setting focus to monaco editor.
+                // Tests are known to fall over if allowed.
+                const editor = wrapper
+                    .find(NativeCell)
+                    .at(1)
+                    .find(Editor)
+                    .first();
+                (editor.instance() as Editor).giveFocus = () => editor.props().focused!();
+
+                const update = waitForUpdate(wrapper, NativeEditor, 1);
+                clickCell(1);
+                simulateKeyPressOnCell(1, { code: 'Enter', editorInfo: undefined });
+                await update;
 
-            // The third cell should be selected.
-            assert.ok(isCellSelected(wrapper, 'NativeCell', 2));
-        });
+                // The second cell should be selected.
+                assert.ok(isCellFocused(wrapper, 'NativeCell', 1));
+            });
 
-        test('Pressing \'Ctrl+Enter\' on a selected cell executes the cell and cell selection is not changed', async () => {
-            const update = waitForUpdate(wrapper, NativeEditor, 7);
-            clickCell(1);
-            simulateKeyPressOnCell(1, { code: 'Enter', ctrlKey: true, editorInfo: undefined });
-            await update;
+            test('Pressing \'Escape\' on a focused cell results in the cell being selected', async () => {
+                // First focus the cell.
+                let update = waitForUpdate(wrapper, NativeEditor, 1);
+                clickCell(1);
+                simulateKeyPressOnCell(1, { code: 'Enter', editorInfo: undefined });
+                await update;
 
-            // Ensure cell was executed.
-            verifyHtmlOnCell(wrapper, 'NativeCell', '<span>2</span>', 1);
+                // The second cell should be selected.
+                assert.equal(isCellSelected(wrapper, 'NativeCell', 1), false);
+                assert.equal(isCellFocused(wrapper, 'NativeCell', 1), true);
 
-            // The first cell should be selected.
-            assert.ok(isCellSelected(wrapper, 'NativeCell', 1));
-        });
+                // Now hit escape.
+                update = waitForUpdate(wrapper, NativeEditor, 1);
+                simulateKeyPressOnCell(1, { code: 'Escape' });
+                await update;
 
-        test('Pressing \'Altr+Enter\' on a selected cell adds a new cell below it', async () => {
-            // Initially 3 cells.
-            assert.equal(wrapper.find('NativeCell').length, 3);
+                // Confirm it is no longer focused, and it is selected.
+                assert.equal(isCellSelected(wrapper, 'NativeCell', 1), true);
+                assert.equal(isCellFocused(wrapper, 'NativeCell', 1), false);
+            });
 
-            const update = waitForUpdate(wrapper, NativeEditor, 1);
-            clickCell(1);
-            simulateKeyPressOnCell(1, { code: 'Enter', altKey: true, editorInfo: undefined });
-            await update;
+            test('Pressing \'Shift+Enter\' on a selected cell executes the cell and advances to the next cell', async () => {
+                clickCell(1);
+                const update = waitForUpdate(wrapper, NativeEditor, 7);
+                simulateKeyPressOnCell(1, { code: 'Enter', shiftKey: true, editorInfo: undefined });
+                await update;
+                wrapper.update();
 
-            // The second cell should be selected.
-            assert.ok(isCellSelected(wrapper, 'NativeCell', 2));
-            // There should be 4 cells.
-            assert.equal(wrapper.find('NativeCell').length, 4);
-        });
+                // Ensure cell was executed.
+                verifyHtmlOnCell(wrapper, 'NativeCell', '<span>2</span>', 1);
 
-        test('Pressing \'d\' on a selected cell twice deletes the cell', async () => {
-            // Initially 3 cells.
-            assert.equal(wrapper.find('NativeCell').length, 3);
+                // The third cell should be selected.
+                assert.ok(isCellSelected(wrapper, 'NativeCell', 2));
+            });
 
-            clickCell(2);
-            simulateKeyPressOnCell(2, { code: 'd' });
-            simulateKeyPressOnCell(2, { code: 'd' });
+            test('Pressing \'Ctrl+Enter\' on a selected cell executes the cell and cell selection is not changed', async () => {
+                const update = waitForUpdate(wrapper, NativeEditor, 7);
+                clickCell(1);
+                simulateKeyPressOnCell(1, { code: 'Enter', ctrlKey: true, editorInfo: undefined });
+                await update;
 
-            // There should be 2 cells.
-            assert.equal(wrapper.find('NativeCell').length, 2);
-        });
+                // Ensure cell was executed.
+                verifyHtmlOnCell(wrapper, 'NativeCell', '<span>2</span>', 1);
 
-        test('Pressing \'a\' on a selected cell adds a cell at the current position', async () => {
-            // Initially 3 cells.
-            assert.equal(wrapper.find('NativeCell').length, 3);
+                // The first cell should be selected.
+                assert.ok(isCellSelected(wrapper, 'NativeCell', 1));
+            });
+
+            test('Pressing \'Altr+Enter\' on a selected cell adds a new cell below it', async () => {
+                // Initially 3 cells.
+                assert.equal(wrapper.find('NativeCell').length, 3);
 
-            // const secondCell = wrapper.find('NativeCell').at(1);
+                const update = waitForUpdate(wrapper, NativeEditor, 1);
+                clickCell(1);
+                simulateKeyPressOnCell(1, { code: 'Enter', altKey: true, editorInfo: undefined });
+                await update;
 
-            clickCell(0);
-            const update = waitForUpdate(wrapper, NativeEditor, 1);
-            simulateKeyPressOnCell(0, { code: 'a' });
-            await update;
+                // The second cell should be selected.
+                assert.ok(isCellSelected(wrapper, 'NativeCell', 2));
+                // There should be 4 cells.
+                assert.equal(wrapper.find('NativeCell').length, 4);
+            });
 
-            // There should be 4 cells.
-            assert.equal(wrapper.find('NativeCell').length, 4);
+            test('Pressing \'d\' on a selected cell twice deletes the cell', async () => {
+                // Initially 3 cells.
+                assert.equal(wrapper.find('NativeCell').length, 3);
 
-            // Verify cell indexes of old items.
-            verifyCellIndex(wrapper, 'div[id="NotebookImport#0"]', 1);
-            verifyCellIndex(wrapper, 'div[id="NotebookImport#1"]', 2);
-            verifyCellIndex(wrapper, 'div[id="NotebookImport#2"]', 3);
-        });
+                clickCell(2);
+                simulateKeyPressOnCell(2, { code: 'd' });
+                simulateKeyPressOnCell(2, { code: 'd' });
 
-        test('Pressing \'b\' on a selected cell adds a cell after the current position', async () => {
-            // Initially 3 cells.
-            assert.equal(wrapper.find('NativeCell').length, 3);
+                // There should be 2 cells.
+                assert.equal(wrapper.find('NativeCell').length, 2);
+            });
 
-            clickCell(1);
-            const update = waitForUpdate(wrapper, NativeEditor, 1);
-            simulateKeyPressOnCell(1, { code: 'b' });
-            await update;
+            test('Pressing \'a\' on a selected cell adds a cell at the current position', async () => {
+                // Initially 3 cells.
+                assert.equal(wrapper.find('NativeCell').length, 3);
 
-            // There should be 4 cells.
-            assert.equal(wrapper.find('NativeCell').length, 4);
+                // const secondCell = wrapper.find('NativeCell').at(1);
 
-            // Verify cell indexes of old items.
-            verifyCellIndex(wrapper, 'div[id="NotebookImport#0"]', 0);
-            verifyCellIndex(wrapper, 'div[id="NotebookImport#1"]', 1);
-            verifyCellIndex(wrapper, 'div[id="NotebookImport#2"]', 3);
-        });
+                clickCell(0);
+                const update = waitForUpdate(wrapper, NativeEditor, 1);
+                simulateKeyPressOnCell(0, { code: 'a' });
+                await update;
+
+                // There should be 4 cells.
+                assert.equal(wrapper.find('NativeCell').length, 4);
+
+                // Verify cell indexes of old items.
+                verifyCellIndex(wrapper, 'div[id="NotebookImport#0"]', 1);
+                verifyCellIndex(wrapper, 'div[id="NotebookImport#1"]', 2);
+                verifyCellIndex(wrapper, 'div[id="NotebookImport#2"]', 3);
+            });
 
-        test('Toggle visibility of output', async () => {
-            // First execute contents of last cell.
-            let update = waitForUpdate(wrapper, NativeEditor, 7);
-            clickCell(2);
-            simulateKeyPressOnCell(2, { code: 'Enter', ctrlKey: true, editorInfo: undefined });
-            await update;
+            test('Pressing \'b\' on a selected cell adds a cell after the current position', async () => {
+                // Initially 3 cells.
+                assert.equal(wrapper.find('NativeCell').length, 3);
 
-            // Ensure cell was executed.
-            verifyHtmlOnCell(wrapper, 'NativeCell', '<span>3</span>', 2);
+                clickCell(1);
+                const update = waitForUpdate(wrapper, NativeEditor, 1);
+                simulateKeyPressOnCell(1, { code: 'b' });
+                await update;
 
-            // Hide the output
-            update = waitForUpdate(wrapper, NativeEditor, 1);
-            simulateKeyPressOnCell(2, { code: 'o' });
-            await update;
+                // There should be 4 cells.
+                assert.equal(wrapper.find('NativeCell').length, 4);
 
-            // Ensure cell output is hidden (looking for cell results will throw an exception).
-            assert.throws(() => verifyHtmlOnCell(wrapper, 'NativeCell', '<span>3</span>', 2));
+                // Verify cell indexes of old items.
+                verifyCellIndex(wrapper, 'div[id="NotebookImport#0"]', 0);
+                verifyCellIndex(wrapper, 'div[id="NotebookImport#1"]', 1);
+                verifyCellIndex(wrapper, 'div[id="NotebookImport#2"]', 3);
+            });
 
-            // Display the output
-            update = waitForUpdate(wrapper, NativeEditor, 1);
-            simulateKeyPressOnCell(2, { code: 'o' });
-            await update;
+            test('Toggle visibility of output', async () => {
+                // First execute contents of last cell.
+                let update = waitForUpdate(wrapper, NativeEditor, 7);
+                clickCell(2);
+                simulateKeyPressOnCell(2, { code: 'Enter', ctrlKey: true, editorInfo: undefined });
+                await update;
 
-            // Ensure cell output is visible again.
-            verifyHtmlOnCell(wrapper, 'NativeCell', '<span>3</span>', 2);
-        });
+                // Ensure cell was executed.
+                verifyHtmlOnCell(wrapper, 'NativeCell', '<span>3</span>', 2);
 
-        test('Toggle line numbers using the \'l\' key', async () => {
-            clickCell(1);
+                // Hide the output
+                update = waitForUpdate(wrapper, NativeEditor, 1);
+                simulateKeyPressOnCell(2, { code: 'o' });
+                await update;
 
-            const monacoEditorComponent = wrapper.find(NativeCell).at(1).find(MonacoEditor).first();
-            const editor = (monacoEditorComponent.instance().state as IMonacoEditorState).editor!;
-            const oldUpdateOptions = editor.updateOptions.bind(editor);
+                // Ensure cell output is hidden (looking for cell results will throw an exception).
+                assert.throws(() => verifyHtmlOnCell(wrapper, 'NativeCell', '<span>3</span>', 2));
 
-            let lineNumberSetting: any = '';
-            editor.updateOptions = (options: monacoEditor.editor.IEditorConstructionOptions) => {
-                lineNumberSetting = options.lineNumbers;
-                oldUpdateOptions(options);
-            };
+                // Display the output
+                update = waitForUpdate(wrapper, NativeEditor, 1);
+                simulateKeyPressOnCell(2, { code: 'o' });
+                await update;
+
+                // Ensure cell output is visible again.
+                verifyHtmlOnCell(wrapper, 'NativeCell', '<span>3</span>', 2);
+            });
+
+            test('Toggle line numbers using the \'l\' key', async () => {
+                clickCell(1);
+
+                const monacoEditorComponent = wrapper
+                    .find(NativeCell)
+                    .at(1)
+                    .find(MonacoEditor)
+                    .first();
+                const editor = (monacoEditorComponent.instance().state as IMonacoEditorState).editor!;
+                const optionsUpdated = sinon.spy(editor, 'updateOptions');
+
+                // Display line numbers.
+                simulateKeyPressOnCell(1, { code: 'l' });
+                // Confirm monaco editor got updated with line numbers set to turned on.
+                assert.equal(optionsUpdated.lastCall.args[0].lineNumbers, 'on');
+
+                // toggle the display of line numbers.
+                simulateKeyPressOnCell(1, { code: 'l' });
+                // Confirm monaco editor got updated with line numbers set to turned ff.
+                assert.equal(optionsUpdated.lastCall.args[0].lineNumbers, 'off');
+            });
 
-            // Display line numbers.
-            simulateKeyPressOnCell(1, { code: 'l' });
-            assert.equal(lineNumberSetting, 'on');
+            test('Toggle markdown and code modes using \'y\' and \'m\' keys', async () => {
+                clickCell(1);
+
+                // Switch to markdown
+                simulateKeyPressOnCell(1, { code: 'm' });
+
+                // Confirm output cell is rendered and monaco editor is not.
+                assert.equal(
+                    wrapper
+                        .find(NativeCell)
+                        .at(1)
+                        .find(CellOutput).length,
+                    1
+                );
+                assert.equal(
+                    wrapper
+                        .find(NativeCell)
+                        .at(1)
+                        .find(MonacoEditor).length,
+                    0
+                );
+
+                // Switch back to code mode.
+                // At this moment, there's no cell input element, hence send key strokes to the wrapper.
+                const wrapperElement = wrapper
+                    .find(NativeCell)
+                    .at(1)
+                    .find('.cell-wrapper')
+                    .first();
+                wrapperElement.simulate('keyDown', { key: 'y' });
+
+                // Confirm output cell is not rendered (remember we don't have any output) and monaco editor is rendered.
+                assert.equal(
+                    wrapper
+                        .find(NativeCell)
+                        .at(1)
+                        .find(CellOutput).length,
+                    0
+                );
+                assert.equal(
+                    wrapper
+                        .find(NativeCell)
+                        .at(1)
+                        .find(MonacoEditor).length,
+                    1
+                );
+            });
 
-            // toggle the display of line numbers.
-            simulateKeyPressOnCell(1, { code: 'l' });
-            assert.equal(lineNumberSetting, 'off');
+            test('Test undo using the key \'z\'', async () => {
+                clickCell(0);
+
+                // Add, then undo, keep doing at least 3 times and confirm it works as expected.
+                for (let i = 0; i < 3; i += 1) {
+                    // Add a new cell
+                    let update = waitForUpdate(wrapper, NativeEditor, 1);
+                    simulateKeyPressOnCell(0, { code: 'a' });
+                    await update;
+
+                    // There should be 4 cells and first cell is selected & nothing focused.
+                    assert.equal(isCellSelected(wrapper, 'NativeCell', 0), true);
+                    assert.equal(isCellSelected(wrapper, 'NativeCell', 1), false);
+                    assert.equal(isCellFocused(wrapper, 'NativeCell', 0), false);
+                    assert.equal(isCellFocused(wrapper, 'NativeCell', 1), false);
+                    assert.equal(wrapper.find('NativeCell').length, 4);
+
+                    // Press 'z' to undo.
+                    update = waitForUpdate(wrapper, NativeEditor, 1);
+                    simulateKeyPressOnCell(0, { code: 'z' });
+                    await update;
+
+                    // There should be 3 cells and first cell is selected & nothing focused.
+                    assert.equal(isCellSelected(wrapper, 'NativeCell', 0), true);
+                    assert.equal(isCellSelected(wrapper, 'NativeCell', 1), false);
+                    assert.equal(wrapper.find('NativeCell').length, 3);
+                }
+            });
         });
 
-        test('Toggle markdown and code modes using \'y\' and \'m\' keys', async () => {
-            clickCell(1);
+        suite('Auto Save', () => {
+            let controller: NativeEditorStateController;
+            let windowStateChangeHandlers: ((e: WindowState) => any)[] = [];
+            let handleMessageSpy: sinon.SinonSpy<[string, any?], boolean>;
+            setup(async function() {
+                handleMessageSpy = sinon.spy(NativeEditorStateController.prototype, 'handleMessage');
+                initIoc();
 
-            // Switch to markdown
-            simulateKeyPressOnCell(1, { code: 'm' });
+                windowStateChangeHandlers = [];
+                // Keep track of all handlers for the onDidChangeWindowState event.
+                ioc.applicationShell.setup(app => app.onDidChangeWindowState(TypeMoq.It.isAny())).callback(cb => windowStateChangeHandlers.push(cb));
 
-            // Confirm output cell is rendered and monaco editor is not.
-            assert.equal(wrapper.find(NativeCell).at(1).find(CellOutput).length, 1);
-            assert.equal(wrapper.find(NativeCell).at(1).find(MonacoEditor).length, 0);
+                // tslint:disable-next-line: no-invalid-this
+                await setupFunction.call(this);
 
-            // Switch back to code mode.
-            // At this moment, there's no cell input element, hence send key strokes to the wrapper.
-            const wrapperElement = wrapper.find(NativeCell).at(1).find('.cell-wrapper').first();
-            wrapperElement.simulate('keyDown', {key: 'y'});
+                controller = (wrapper
+                    .find(NativeEditor)
+                    .first()
+                    .instance() as NativeEditor).stateController;
+            });
+            teardown(() => sinon.restore());
+
+            /**
+             * Wait for a particular message to be received by the editor component.
+             * If message isn't reiceived within a time out, then reject with a timeout error message.
+             *
+             * @param {string} message
+             * @param {number} timeout
+             * @returns {Promise<void>}
+             */
+            async function waitForMessageReceivedEditorComponent(message: string, timeout: number = 5000): Promise<void> {
+                const errorMessage = `Timeout waiting for message ${message}`;
+                await waitForCondition(async () => handleMessageSpy.calledWith(message, sinon.match.any), timeout, errorMessage);
+            }
 
-            // Confirm output cell is not rendered (remember we don't have any output) and monaco editor is rendered.
-            assert.equal(wrapper.find(NativeCell).at(1).find(CellOutput).length, 0);
-            assert.equal(wrapper.find(NativeCell).at(1).find(MonacoEditor).length, 1);
-        });
+            /**
+             * Wait for notebook to be marked as dirty (within a timeout of 5s).
+             *
+             * @param {boolean} [dirty=true]
+             * @returns {Promise<void>}
+             */
+            async function waitForNotebookToBeDirty(): Promise<void> {
+                // Wait for the notebook to be marked as dirty (the NotebookDirty message will be sent).
+                await waitForMessageReceivedEditorComponent(InteractiveWindowMessages.NotebookDirty, 5_000);
+                // Wait for the state to get updated.
+                await waitForCondition(async () => controller.getState().dirty === true, 1_000, `Timeout waiting for dirty state to get updated to true`);
+            }
 
-        test('Test undo using the key \'z\'', async () => {
-            clickCell(0);
+            /**
+             * Wait for notebook to be marked as clean (within a timeout of 5s).
+             *
+             * @param {boolean} [dirty=true]
+             * @returns {Promise<void>}
+             */
+            async function waitForNotebookToBeClean(): Promise<void> {
+                // Wait for the notebook to be marked as dirty (the NotebookDirty message will be sent).
+                await waitForMessageReceivedEditorComponent(InteractiveWindowMessages.NotebookDirty, 5_000);
+
+                // Wait for the state to get updated.
+                await waitForCondition(async () => controller.getState().dirty === false, 1_000, `Timeout waiting for dirty state to get updated to false`);
+            }
 
-            // Add, then undo, keep doing at least 3 times and confirm it works as expected.
-            for (let i = 0; i < 3; i += 1){
-                // Add a new cell
-                let update = waitForUpdate(wrapper, NativeEditor, 1);
+            /**
+             * Make some kind of a change to the notebook.
+             *
+             * @param {number} cellIndex
+             */
+            async function modifyNotebook() {
+                // (Add a cell into the UI and wait for it to render)
+                clickCell(0);
+                const update = waitForUpdate(wrapper, NativeEditor, 2);
                 simulateKeyPressOnCell(0, { code: 'a' });
                 await update;
+            }
 
-                // There should be 4 cells and first cell is selected & nothing focused.
-                assert.equal(isCellSelected(wrapper, 'NativeCell', 0), true);
-                assert.equal(isCellSelected(wrapper, 'NativeCell', 1), false);
-                assert.equal(isCellFocused(wrapper, 'NativeCell', 0), false);
-                assert.equal(isCellFocused(wrapper, 'NativeCell', 1), false);
-                assert.equal(wrapper.find('NativeCell').length, 4);
+            test('Auto save notebook every 1s', async () => {
+                // Configure notebook to save automatically ever 1s.
+                when(ioc.mockedWorkspaceConfig.get('autoSave', 'off')).thenReturn('afterDelay');
+                when(ioc.mockedWorkspaceConfig.get<number>('autoSaveDelay', anything())).thenReturn(1_000);
+                ioc.forceSettingsChanged(ioc.getSettings().pythonPath);
+
+                /**
+                 * Make some changes to a cell of a notebook, then verify the notebook is auto saved.
+                 *
+                 * @param {number} cellIndex
+                 */
+                async function makeChangesAndConfirmFileIsUpdated() {
+                    const notebookFileContents = await fs.readFile(notebookFile.filePath, 'utf8');
+
+                    await modifyNotebook();
+                    await waitForNotebookToBeDirty();
+
+                    // At this point a message should be sent to extension asking it to save.
+                    // After the save, the extension should send a message to react letting it know that it was saved successfully.
+
+                    await waitForNotebookToBeClean();
+                    // Confirm file has been updated as well.
+                    const newFileContents = await fs.readFile(notebookFile.filePath, 'utf8');
+                    assert.notEqual(newFileContents, notebookFileContents);
+                }
 
-                // Press 'z' to undo.
-                update = waitForUpdate(wrapper, NativeEditor, 1);
-                simulateKeyPressOnCell(0, { code: 'z' });
-                await update;
+                // Make changes & validate (try a couple of times).
+                await makeChangesAndConfirmFileIsUpdated();
+                await makeChangesAndConfirmFileIsUpdated();
+                await makeChangesAndConfirmFileIsUpdated();
+            });
 
-                // There should be 3 cells and first cell is selected & nothing focused.
-                assert.equal(isCellSelected(wrapper, 'NativeCell', 0), true);
-                assert.equal(isCellSelected(wrapper, 'NativeCell', 1), false);
-                assert.equal(wrapper.find('NativeCell').length, 3);
+            test('Should not auto save notebook, ever', async () => {
+                const notebookFileContents = await fs.readFile(notebookFile.filePath, 'utf8');
+
+                // Configure notebook to to never save.
+                when(ioc.mockedWorkspaceConfig.get('autoSave', 'off')).thenReturn('off');
+                when(ioc.mockedWorkspaceConfig.get<number>('autoSaveDelay', anything())).thenReturn(1000);
+                // Update the settings and wait for the component to receive it and process it.
+                const promise = waitForMessageReceivedEditorComponent(InteractiveWindowMessages.UpdateSettings, 1_000);
+                ioc.forceSettingsChanged(ioc.getSettings().pythonPath);
+                await promise;
+
+                await modifyNotebook();
+                await waitForNotebookToBeDirty();
+
+                // Now that the notebook is dirty, change the active editor.
+                const docManager = ioc.get<IDocumentManager>(IDocumentManager) as MockDocumentManager;
+                docManager.didChangeEmitter.fire();
+                // Also, send notification about changes to window state.
+                windowStateChangeHandlers.forEach(item => item({ focused: false }));
+                windowStateChangeHandlers.forEach(item => item({ focused: true }));
+
+                // Confirm the message is not clean, trying to wait for it to get saved will timeout (i.e. rejected).
+                await expect(waitForNotebookToBeClean()).to.eventually.be.rejected;
+                // Confirm file has not been updated as well.
+                assert.equal(await fs.readFile(notebookFile.filePath, 'utf8'), notebookFileContents);
+            });
+
+            async function testAutoSavingWhenEditorFocusChanges(newEditor: TextEditor | undefined) {
+                const notebookFileContents = await fs.readFile(notebookFile.filePath, 'utf8');
+
+                await modifyNotebook();
+                await waitForNotebookToBeDirty();
+
+                // Configure notebook to save when active editor changes.
+                when(ioc.mockedWorkspaceConfig.get('autoSave', 'off')).thenReturn('onFocusChange');
+                ioc.forceSettingsChanged(ioc.getSettings().pythonPath);
+
+                // Now that the notebook is dirty, change the active editor.
+                const docManager = ioc.get<IDocumentManager>(IDocumentManager) as MockDocumentManager;
+                docManager.didChangeEmitter.fire(newEditor);
+
+                // At this point a message should be sent to extension asking it to save.
+                // After the save, the extension should send a message to react letting it know that it was saved successfully.
+
+                await waitForNotebookToBeClean();
+                // Confirm file has been updated as well.
+                assert.notEqual(await fs.readFile(notebookFile.filePath, 'utf8'), notebookFileContents);
+            }
+
+            test('Auto save notebook when focus changes from active editor to none', () => testAutoSavingWhenEditorFocusChanges(undefined));
+
+            test('Auto save notebook when focus changes from active editor to something else', () =>
+                testAutoSavingWhenEditorFocusChanges(TypeMoq.Mock.ofType<TextEditor>().object));
+
+            test('Should not auto save notebook when active editor changes', async () => {
+                const notebookFileContents = await fs.readFile(notebookFile.filePath, 'utf8');
+
+                await modifyNotebook();
+                await waitForNotebookToBeDirty();
+
+                // Configure notebook to save when window state changes.
+                when(ioc.mockedWorkspaceConfig.get('autoSave', 'off')).thenReturn('onWindowChange');
+                ioc.forceSettingsChanged(ioc.getSettings().pythonPath);
+
+                // Now that the notebook is dirty, change the active editor.
+                // This should not trigger a save of notebook (as its configured to save only when window state changes).
+                const docManager = ioc.get<IDocumentManager>(IDocumentManager) as MockDocumentManager;
+                docManager.didChangeEmitter.fire();
+
+                // Confirm the message is not clean, trying to wait for it to get saved will timeout (i.e. rejected).
+                await expect(waitForNotebookToBeClean()).to.eventually.be.rejected;
+                // Confirm file has not been updated as well.
+                assert.equal(await fs.readFile(notebookFile.filePath, 'utf8'), notebookFileContents);
+            });
+
+            async function testAutoSavingWithChangesToWindowState(focused: boolean) {
+                const notebookFileContents = await fs.readFile(notebookFile.filePath, 'utf8');
+
+                await modifyNotebook();
+                await waitForNotebookToBeDirty();
+
+                // Configure notebook to save when active editor changes.
+                when(ioc.mockedWorkspaceConfig.get('autoSave', 'off')).thenReturn('onWindowChange');
+                ioc.forceSettingsChanged(ioc.getSettings().pythonPath);
+
+                // Now that the notebook is dirty, send notification about changes to window state.
+                windowStateChangeHandlers.forEach(item => item({ focused }));
+
+                // At this point a message should be sent to extension asking it to save.
+                // After the save, the extension should send a message to react letting it know that it was saved successfully.
+
+                await waitForNotebookToBeClean();
+                // Confirm file has been updated as well.
+                assert.notEqual(await fs.readFile(notebookFile.filePath, 'utf8'), notebookFileContents);
             }
+
+            test('Auto save notebook when window state changes to being not focused', async () => testAutoSavingWithChangesToWindowState(false));
+            test('Auto save notebook when window state changes to being focused', async () => testAutoSavingWithChangesToWindowState(true));
+
+            test('Should not auto save notebook when window state changes', async () => {
+                const notebookFileContents = await fs.readFile(notebookFile.filePath, 'utf8');
+
+                await modifyNotebook();
+                await waitForNotebookToBeDirty();
+
+                // Configure notebook to save when active editor changes.
+                when(ioc.mockedWorkspaceConfig.get('autoSave', 'off')).thenReturn('onFocusChange');
+                ioc.forceSettingsChanged(ioc.getSettings().pythonPath);
+
+                // Now that the notebook is dirty, change window state.
+                // This should not trigger a save of notebook (as its configured to save only when focus is changed).
+                windowStateChangeHandlers.forEach(item => item({ focused: false }));
+                windowStateChangeHandlers.forEach(item => item({ focused: true }));
+
+                // Confirm the message is not clean, trying to wait for it to get saved will timeout (i.e. rejected).
+                await expect(waitForNotebookToBeClean()).to.eventually.be.rejected;
+                // Confirm file has not been updated as well.
+                assert.equal(await fs.readFile(notebookFile.filePath, 'utf8'), notebookFileContents);
+            });
         });
     });
 });
diff --git a/src/test/datascience/nativeEditorTestHelpers.tsx b/src/test/datascience/nativeEditorTestHelpers.tsx
index d0421752c580..0ddb5ee20e18 100644
--- a/src/test/datascience/nativeEditorTestHelpers.tsx
+++ b/src/test/datascience/nativeEditorTestHelpers.tsx
@@ -31,9 +31,9 @@ export async function createNewEditor(ioc: DataScienceIocContainer): Promise<INo
     return result;
 }
 
-export async function openEditor(ioc: DataScienceIocContainer, contents: string): Promise<INotebookEditor> {
+export async function openEditor(ioc: DataScienceIocContainer, contents: string, filePath: string = '/usr/home/test.ipynb'): Promise<INotebookEditor> {
     const loaded = waitForMessage(ioc, InteractiveWindowMessages.LoadAllCellsComplete);
-    const uri = Uri.parse('file:////usr/home/test.ipynb');
+    const uri = Uri.file(filePath);
     const result = await getOrCreateNativeEditor(ioc, uri, contents);
     await loaded;
     return result;

From 2c5c54b28eba79ce081fb48f110931f8b5662f65 Mon Sep 17 00:00:00 2001
From: Rich Chiodo <rchiodo@users.noreply.github.com>
Date: Fri, 11 Oct 2019 12:59:54 -0700
Subject: [PATCH 23/36] Fix ctrl+s to work in the notebook editor (#7919)

* Fix ctrl+s to work in the notebook editor

* Fix linting error

* More linter fixes
---
 news/2 Fixes/7904.md                          |  1 +
 .../native-editor/nativeCell.tsx              |  7 ++++
 .../nativeEditor.functional.test.tsx          | 35 ++++++++++++++++---
 3 files changed, 39 insertions(+), 4 deletions(-)
 create mode 100644 news/2 Fixes/7904.md

diff --git a/news/2 Fixes/7904.md b/news/2 Fixes/7904.md
new file mode 100644
index 000000000000..6680937198b7
--- /dev/null
+++ b/news/2 Fixes/7904.md	
@@ -0,0 +1 @@
+CTRL+S is not saving a Notebook file.
diff --git a/src/datascience-ui/native-editor/nativeCell.tsx b/src/datascience-ui/native-editor/nativeCell.tsx
index d641cac7ec5b..90836d1a9faa 100644
--- a/src/datascience-ui/native-editor/nativeCell.tsx
+++ b/src/datascience-ui/native-editor/nativeCell.tsx
@@ -248,6 +248,13 @@ export class NativeCell extends React.Component<INativeCellProps> {
                     this.arrowDownFromCell(e);
                 }
                 break;
+            case 's':
+                if (e.ctrlKey) {
+                    // This is save, save our cells
+                    this.props.stateController.save();
+                }
+                break;
+
             case 'Escape':
                 if (isFocusedWhenNotSuggesting) {
                     this.escapeCell(e);
diff --git a/src/test/datascience/nativeEditor.functional.test.tsx b/src/test/datascience/nativeEditor.functional.test.tsx
index 65d8a4624c11..590d50040f05 100644
--- a/src/test/datascience/nativeEditor.functional.test.tsx
+++ b/src/test/datascience/nativeEditor.functional.test.tsx
@@ -1,8 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
-
 'use strict';
-
 import { assert, expect, use } from 'chai';
 import * as chaiAsPromised from 'chai-as-promised';
 import { ReactWrapper } from 'enzyme';
@@ -13,8 +11,9 @@ import * as sinon from 'sinon';
 import { anything, when } from 'ts-mockito';
 import * as TypeMoq from 'typemoq';
 import { Disposable, TextDocument, TextEditor, Uri, WindowState } from 'vscode';
+
 import { IApplicationShell, IDocumentManager } from '../../client/common/application/types';
-import { createDeferred } from '../../client/common/utils/async';
+import { createDeferred, waitForPromise } from '../../client/common/utils/async';
 import { createTemporaryFile } from '../../client/common/utils/fs';
 import { noop } from '../../client/common/utils/misc';
 import { Identifiers } from '../../client/datascience/constants';
@@ -34,7 +33,16 @@ import { IMonacoEditorState, MonacoEditor } from '../../datascience-ui/react-com
 import { waitForCondition } from '../common';
 import { DataScienceIocContainer } from './dataScienceIocContainer';
 import { MockDocumentManager } from './mockDocumentManager';
-import { addCell, closeNotebook, createNewEditor, getNativeCellResults, mountNativeWebView, openEditor, runMountedTest, setupWebview } from './nativeEditorTestHelpers';
+import {
+    addCell,
+    closeNotebook,
+    createNewEditor,
+    getNativeCellResults,
+    mountNativeWebView,
+    openEditor,
+    runMountedTest,
+    setupWebview
+} from './nativeEditorTestHelpers';
 import { waitForUpdate } from './reactHelpers';
 import {
     addContinuousMockData,
@@ -51,6 +59,7 @@ import {
     verifyHtmlOnCell,
     waitForMessageResponse
 } from './testHelpers';
+
 use(chaiAsPromised);
 
 //import { asyncDump } from '../common/asyncDump';
@@ -755,6 +764,24 @@ suite('DataScience Native Editor', () => {
                     assert.equal(wrapper.find('NativeCell').length, 3);
                 }
             });
+
+            test('Test save using the key \'s\'', async () => {
+                clickCell(0);
+
+                await addCell(wrapper, 'a=1\na', true);
+
+                const notebookProvider = ioc.get<INotebookEditorProvider>(INotebookEditorProvider);
+                const editor = notebookProvider.editors[0];
+                assert.ok(editor, 'No editor when saving');
+                const savedPromise = createDeferred();
+                editor.saved(() => savedPromise.resolve());
+
+                simulateKeyPressOnCell(1, { code: 's', ctrlKey: true });
+
+                await waitForPromise(savedPromise.promise, 1_000);
+
+                assert.ok(!editor!.isDirty, 'Editor should not be dirty after saving');
+            });
         });
 
         suite('Auto Save', () => {

From 2de46ccc420e1b956c1aca931b22aba3a20f8f45 Mon Sep 17 00:00:00 2001
From: Don Jayamanne <don.jayamanne@yahoo.com>
Date: Mon, 14 Oct 2019 14:14:23 -0700
Subject: [PATCH 24/36] Cherry pick commit
 b6545e38d7de2239edbbaefe10fa678547a3b3cd

---
 package-lock.json                             |  12 +-
 .../interactive-common/mainState.ts           |   6 +-
 .../activation/activationService.unit.test.ts |   2 +-
 src/test/datascience/datascience.unit.test.ts |  10 +-
 .../cellhashprovider.unit.test.ts             |   8 +-
 .../codewatcher.unit.test.ts                  |  52 +-
 .../datascience/editor-integration/helpers.ts |   4 +-
 .../datascience/intellisense.unit.test.ts     |   3 +-
 .../interactiveWindow.functional.test.tsx     |  10 +-
 .../interactiveWindowTestHelpers.tsx          |   3 +-
 .../datascience/liveshare.functional.test.tsx |  10 +-
 src/test/datascience/mockDocumentManager.ts   |   2 +-
 src/test/datascience/mockJupyterManager.ts    |  27 +-
 src/test/datascience/mockLiveShare.ts         |   4 +-
 .../nativeEditor.functional.test.tsx          |   2 +-
 .../datascience/notebook.functional.test.ts   |   2 +-
 .../resolvers/attach.unit.test.ts             |  56 +-
 .../resolvers/launch.unit.test.ts             |  43 +-
 src/test/mocks/vsc/charCode.ts                | 427 ++++++++++++++++
 src/test/mocks/vsc/index.ts                   |  52 +-
 src/test/mocks/vsc/uri.ts                     | 480 +++++++++++++-----
 .../testing/codeLenses/testFiles.unit.test.ts |  12 +-
 .../services/discoveryService.unit.test.ts    |  12 +-
 src/test/vscode-mock.ts                       |   2 +-
 24 files changed, 963 insertions(+), 278 deletions(-)
 create mode 100644 src/test/mocks/vsc/charCode.ts

diff --git a/package-lock.json b/package-lock.json
index 6cbf43e4b2e2..829d0742db09 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -19635,6 +19635,13 @@
             "requires": {
                 "vscode-languageserver-protocol": "3.14.1",
                 "vscode-uri": "^1.0.6"
+            },
+            "dependencies": {
+                "vscode-uri": {
+                    "version": "1.0.8",
+                    "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-1.0.8.tgz",
+                    "integrity": "sha512-obtSWTlbJ+a+TFRYGaUumtVwb+InIUVI0Lu0VBUAPmj2cU5JutEXg3xUE0c2J5Tcy7h2DEKVJBFi+Y9ZSFzzPQ=="
+                }
             }
         },
         "vscode-languageserver-protocol": {
@@ -19661,11 +19668,6 @@
                 "https-proxy-agent": "^2.2.1"
             }
         },
-        "vscode-uri": {
-            "version": "1.0.8",
-            "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-1.0.8.tgz",
-            "integrity": "sha512-obtSWTlbJ+a+TFRYGaUumtVwb+InIUVI0Lu0VBUAPmj2cU5JutEXg3xUE0c2J5Tcy7h2DEKVJBFi+Y9ZSFzzPQ=="
-        },
         "vsls": {
             "version": "0.3.1291",
             "resolved": "https://registry.npmjs.org/vsls/-/vsls-0.3.1291.tgz",
diff --git a/src/datascience-ui/interactive-common/mainState.ts b/src/datascience-ui/interactive-common/mainState.ts
index 49ca98e6a586..687cffe8904b 100644
--- a/src/datascience-ui/interactive-common/mainState.ts
+++ b/src/datascience-ui/interactive-common/mainState.ts
@@ -211,10 +211,14 @@ export function generateCells(filePath: string, repetitions: number): ICell[] {
     for (let i = 0; i < repetitions; i += 1) {
         cellData = [...cellData, ...generateCellData()];
     }
+    // Dynamically require vscode, this is testing code.
+    // Obfuscate the import to prevent webpack from picking this up.
+    // tslint:disable-next-line: no-eval (webpack is smart enough to look for `require` and `eval`).
+    const Uri = eval('req' + 'uire')('vscode').Uri;
     return cellData.map((data: nbformat.ICodeCell | nbformat.IMarkdownCell | nbformat.IRawCell | IMessageCell, key: number) => {
         return {
             id: key.toString(),
-            file: path.join(filePath, 'foo.py'),
+            file: Uri.file(path.join(filePath, 'foo.py')).fsPath,
             line: 1,
             state: key === cellData.length - 1 ? CellState.executing : CellState.finished,
             type: key === 3 ? 'preview' : 'execute',
diff --git a/src/test/activation/activationService.unit.test.ts b/src/test/activation/activationService.unit.test.ts
index c6d4771f7e60..2930e5769de1 100644
--- a/src/test/activation/activationService.unit.test.ts
+++ b/src/test/activation/activationService.unit.test.ts
@@ -380,7 +380,7 @@ suite('Activation - ActivationService', () => {
                     resource: Resource
                 ) {
                     activator
-                        .setup(a => a.activate(resource))
+                        .setup(a => a.activate(TypeMoq.It.isValue(resource)))
                         .returns(() => Promise.resolve())
                         .verifiable(TypeMoq.Times.once());
                     lsNotSupportedDiagnosticService
diff --git a/src/test/datascience/datascience.unit.test.ts b/src/test/datascience/datascience.unit.test.ts
index 38cbfaa36550..5cae8974efa4 100644
--- a/src/test/datascience/datascience.unit.test.ts
+++ b/src/test/datascience/datascience.unit.test.ts
@@ -42,13 +42,13 @@ suite('Data Science Tests', () => {
 
         assert.equal(expandWorkingDir(undefined, 'bar/foo.baz', inst), 'bar');
         assert.equal(expandWorkingDir(undefined, 'bar/bip/foo.baz', inst), 'bar/bip');
-        assert.equal(expandWorkingDir('${file}', 'bar/bip/foo.baz', inst), 'bar/bip/foo.baz');
-        assert.equal(expandWorkingDir('${fileDirname}', 'bar/bip/foo.baz', inst), 'bar/bip');
+        assert.equal(expandWorkingDir('${file}', 'bar/bip/foo.baz', inst), Uri.file('bar/bip/foo.baz').fsPath);
+        assert.equal(expandWorkingDir('${fileDirname}', 'bar/bip/foo.baz', inst), Uri.file('bar/bip').fsPath);
         assert.equal(expandWorkingDir('${relativeFile}', 'test/xyz/bip/foo.baz', inst), relativeFilePath);
         assert.equal(expandWorkingDir('${relativeFileDirname}', 'test/xyz/bip/foo.baz', inst), relativeFileDir);
-        assert.equal(expandWorkingDir('${cwd}', 'test/xyz/bip/foo.baz', inst), 'test/bar');
-        assert.equal(expandWorkingDir('${workspaceFolder}', 'test/xyz/bip/foo.baz', inst), 'test/bar');
-        assert.equal(expandWorkingDir('${cwd}-${file}', 'bar/bip/foo.baz', inst), 'test/bar-bar/bip/foo.baz');
+        assert.equal(expandWorkingDir('${cwd}', 'test/xyz/bip/foo.baz', inst), Uri.file('test/bar').fsPath);
+        assert.equal(expandWorkingDir('${workspaceFolder}', 'test/xyz/bip/foo.baz', inst), Uri.file('test/bar').fsPath);
+        assert.equal(expandWorkingDir('${cwd}-${file}', 'bar/bip/foo.baz', inst), `${Uri.file('test/bar').fsPath}-${Uri.file('bar/bip/foo.baz').fsPath}`);
     });
 
     test('input history', async () => {
diff --git a/src/test/datascience/editor-integration/cellhashprovider.unit.test.ts b/src/test/datascience/editor-integration/cellhashprovider.unit.test.ts
index dd8c43068637..8fde0bd86f40 100644
--- a/src/test/datascience/editor-integration/cellhashprovider.unit.test.ts
+++ b/src/test/datascience/editor-integration/cellhashprovider.unit.test.ts
@@ -3,7 +3,7 @@
 'use strict';
 import { assert } from 'chai';
 import * as TypeMoq from 'typemoq';
-import { Position, Range } from 'vscode';
+import { Position, Range, Uri } from 'vscode';
 
 import { IDebugService } from '../../../client/common/application/types';
 import { IConfigurationService, IDataScienceSettings, IPythonSettings } from '../../../client/common/types';
@@ -52,7 +52,7 @@ suite('CellHashProvider Unit Tests', () => {
 
     function sendCode(code: string, line: number, file?: string): Promise<void> {
         const cell: ICell = {
-            file: file ? file : 'foo.py',
+            file: Uri.file(file ? file : 'foo.py').fsPath,
             line,
             data: {
                 source: code,
@@ -279,8 +279,8 @@ suite('CellHashProvider Unit Tests', () => {
         // Execution count should go up, but still only have two cells.
         const hashes = hashProvider.getHashes();
         assert.equal(hashes.length, 2, 'Wrong number of hashes');
-        const fooHash = hashes.find(h => h.file === 'foo.py');
-        const barHash = hashes.find(h => h.file === 'bar.py');
+        const fooHash = hashes.find(h => h.file === Uri.file('foo.py').fsPath);
+        const barHash = hashes.find(h => h.file === Uri.file('bar.py').fsPath);
         assert.ok(fooHash, 'No hash for foo.py');
         assert.ok(barHash, 'No hash for bar.py');
         assert.equal(fooHash!.hashes.length, 2, 'Not enough hashes found');
diff --git a/src/test/datascience/editor-integration/codewatcher.unit.test.ts b/src/test/datascience/editor-integration/codewatcher.unit.test.ts
index 420a09e6cfe6..35ef07ecc483 100644
--- a/src/test/datascience/editor-integration/codewatcher.unit.test.ts
+++ b/src/test/datascience/editor-integration/codewatcher.unit.test.ts
@@ -5,7 +5,7 @@
 // Disable whitespace / multiline as we use that to pass in our fake file strings
 import { expect } from 'chai';
 import * as TypeMoq from 'typemoq';
-import { CancellationTokenSource, CodeLens, Disposable, Range, Selection, TextEditor } from 'vscode';
+import { CancellationTokenSource, CodeLens, Disposable, Range, Selection, TextEditor, Uri } from 'vscode';
 
 import { ICommandManager, IDebugService, IDocumentManager } from '../../../client/common/application/types';
 import { PythonSettings } from '../../../client/common/configSettings';
@@ -176,7 +176,7 @@ suite('DataScience Code Watcher Unit Tests', () => {
     }
 
     test('Add a file with just a #%% mark to a code watcher', () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText = `#%%`;
         const document = createDocument(inputText, fileName, version, TypeMoq.Times.atLeastOnce());
@@ -197,7 +197,7 @@ suite('DataScience Code Watcher Unit Tests', () => {
     });
 
     test('Add a file without a mark to a code watcher', () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText = `dummy`;
         const document = createDocument(inputText, fileName, version, TypeMoq.Times.atLeastOnce());
@@ -217,7 +217,7 @@ suite('DataScience Code Watcher Unit Tests', () => {
     });
 
     test('Add a file with multiple marks to a code watcher', () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText =
             `first line
@@ -248,7 +248,7 @@ fourth line`;
     });
 
     test('Add a file with custom marks to a code watcher', () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText =
             `first line
@@ -286,7 +286,7 @@ fourth line
     });
 
     test('Make sure invalid regex from a user still work', () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText =
             `first line
@@ -324,7 +324,7 @@ fourth line
     });
 
     test('Test the RunCell command', async () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const testString = '#%%\ntesting';
         const document = createDocument(testString, fileName, version, TypeMoq.Times.atLeastOnce(), true);
@@ -350,7 +350,7 @@ fourth line
     });
 
     test('Test the RunFileInteractive command', async () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText =
             `#%%
@@ -364,7 +364,7 @@ testing2`; // Command tests override getText, so just need the ranges here
         // Set up our expected calls to add code
         // RunFileInteractive should run the entire file in one block, not cell by cell like RunAllCells
         activeInteractiveWindow.setup(h => h.addCode(TypeMoq.It.isValue(inputText),
-            TypeMoq.It.isValue('test.py'),
+            TypeMoq.It.isValue(fileName),
             TypeMoq.It.isValue(0),
             TypeMoq.It.isAny(),
             TypeMoq.It.isAny()
@@ -378,7 +378,7 @@ testing2`; // Command tests override getText, so just need the ranges here
     });
 
     test('Test the RunAllCells command', async () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText =
             `#%%
@@ -399,14 +399,14 @@ testing2`; // Command tests override getText, so just need the ranges here
 
         // Set up our expected calls to add code
         activeInteractiveWindow.setup(h => h.addCode(TypeMoq.It.isValue(testString1),
-            TypeMoq.It.isValue('test.py'),
+            TypeMoq.It.isValue(fileName),
             TypeMoq.It.isValue(0),
             TypeMoq.It.isAny(),
             TypeMoq.It.isAny()
         )).returns(() => Promise.resolve(true)).verifiable(TypeMoq.Times.once());
 
         activeInteractiveWindow.setup(h => h.addCode(TypeMoq.It.isValue(testString2),
-            TypeMoq.It.isValue('test.py'),
+            TypeMoq.It.isValue(fileName),
             TypeMoq.It.isValue(2),
             TypeMoq.It.isAny(),
             TypeMoq.It.isAny()
@@ -420,7 +420,7 @@ testing2`; // Command tests override getText, so just need the ranges here
     });
 
     test('Test the RunCurrentCell command', async () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText =
             `#%%
@@ -453,7 +453,7 @@ testing2`;
     });
 
     test('Test the RunCellAndAllBelow command', async () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText =
             `#%%
@@ -497,7 +497,7 @@ testing3`;
     });
 
     test('Test the RunAllCellsAbove command', async () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText =
             `#%%
@@ -541,7 +541,7 @@ testing2`;
     });
 
     test('Test the RunToLine command', async () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText =
             `#%%
@@ -574,7 +574,7 @@ testing1`;
     });
 
     test('Test the RunToLine command with nothing on the lines', async () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText =
             `
@@ -603,7 +603,7 @@ print('testing')`;
     });
 
     test('Test the RunFromLine command', async () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText =
             `#%%
@@ -639,7 +639,7 @@ testing3`;
     });
 
     test('Test the RunSelection command', async () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText =
             `#%%
@@ -677,7 +677,7 @@ testing2`;
     });
 
     test('Test the RunCellAndAdvance command with next cell', async () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText =
             `#%%
@@ -693,7 +693,7 @@ testing2`; // Command tests override getText, so just need the ranges here
 
         // Set up our expected calls to add code
         activeInteractiveWindow.setup(h => h.addCode(TypeMoq.It.isValue(testString),
-            TypeMoq.It.isValue('test.py'),
+            TypeMoq.It.isValue(fileName),
             TypeMoq.It.isValue(0),
             TypeMoq.It.is((ed: TextEditor) => {
                 return textEditor.object === ed;
@@ -732,7 +732,7 @@ testing2`; // Command tests override getText, so just need the ranges here
 
     test('CodeLens returned after settings changed is different', () => {
         // Create our document
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText = '#%% foobar';
         const document = createDocument(inputText, fileName, version, TypeMoq.Times.atLeastOnce());
@@ -764,7 +764,7 @@ testing2`; // Command tests override getText, so just need the ranges here
     });
 
     test('Test the RunAllCellsAbove command with an error', async () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText =
             `#%%
@@ -808,7 +808,7 @@ testing2`;
     });
 
     test('Test the RunAllCells command with an error', async () => {
-        const fileName = 'test.py';
+        const fileName = Uri.file('test.py').fsPath;
         const version = 1;
         const inputText =
             `#%%
@@ -829,14 +829,14 @@ testing2`; // Command tests override getText, so just need the ranges here
 
         // Set up our expected calls to add code
         activeInteractiveWindow.setup(h => h.addCode(TypeMoq.It.isValue(testString1),
-            TypeMoq.It.isValue('test.py'),
+            TypeMoq.It.isValue(fileName),
             TypeMoq.It.isValue(0),
             TypeMoq.It.isAny(),
             TypeMoq.It.isAny()
         )).returns(() => Promise.resolve(false)).verifiable(TypeMoq.Times.once());
 
         activeInteractiveWindow.setup(h => h.addCode(TypeMoq.It.isValue(testString2),
-            TypeMoq.It.isValue('test.py'),
+            TypeMoq.It.isValue(fileName),
             TypeMoq.It.isValue(2),
             TypeMoq.It.isAny(),
             TypeMoq.It.isAny()
diff --git a/src/test/datascience/editor-integration/helpers.ts b/src/test/datascience/editor-integration/helpers.ts
index 384e185514a3..bd363fb16ba2 100644
--- a/src/test/datascience/editor-integration/helpers.ts
+++ b/src/test/datascience/editor-integration/helpers.ts
@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 'use strict';
 import * as TypeMoq from 'typemoq';
-import { Range, TextDocument, TextLine } from 'vscode';
+import { Range, TextDocument, TextLine, Uri } from 'vscode';
 
 // tslint:disable:max-func-body-length no-trailing-whitespace no-multiline-string
 // Disable whitespace / multiline as we use that to pass in our fake file strings
@@ -18,7 +18,7 @@ export function createDocument(inputText: string, fileName: string, fileVersion:
     document.setup(d => d.languageId).returns(() => 'python');
 
     // First set the metadata
-    document.setup(d => d.fileName).returns(() => fileName).verifiable(times);
+    document.setup(d => d.fileName).returns(() => Uri.file(fileName).fsPath).verifiable(times);
     document.setup(d => d.version).returns(() => fileVersion).verifiable(times);
 
     // Next add the lines in
diff --git a/src/test/datascience/intellisense.unit.test.ts b/src/test/datascience/intellisense.unit.test.ts
index 51d5418d7db7..fe1e860a53fb 100644
--- a/src/test/datascience/intellisense.unit.test.ts
+++ b/src/test/datascience/intellisense.unit.test.ts
@@ -5,6 +5,7 @@ import { expect } from 'chai';
 import * as monacoEditor from 'monaco-editor/esm/vs/editor/editor.api';
 import * as TypeMoq from 'typemoq';
 
+import { Uri } from 'vscode';
 import { ILanguageServer, ILanguageServerAnalysisOptions } from '../../client/activation/types';
 import { IWorkspaceService } from '../../client/common/application/types';
 import { PythonSettings } from '../../client/common/configSettings';
@@ -96,7 +97,7 @@ suite('DataScience Intellisense Unit Tests', () => {
     }
 
     function addCell(code: string, id: string): Promise<void> {
-        return sendMessage(InteractiveWindowMessages.AddCell, { fullText: code, currentText: code, file: 'foo.py', id });
+        return sendMessage(InteractiveWindowMessages.AddCell, { fullText: code, currentText: code, file: Uri.file('foo.py').fsPath, id });
     }
 
     function updateCell(newCode: string, oldCode: string, id: string): Promise<void> {
diff --git a/src/test/datascience/interactiveWindow.functional.test.tsx b/src/test/datascience/interactiveWindow.functional.test.tsx
index 90b70372488a..6a71f86444a6 100644
--- a/src/test/datascience/interactiveWindow.functional.test.tsx
+++ b/src/test/datascience/interactiveWindow.functional.test.tsx
@@ -7,7 +7,7 @@ import { parse } from 'node-html-parser';
 import * as os from 'os';
 import * as path from 'path';
 import * as TypeMoq from 'typemoq';
-import { Disposable, Selection, TextDocument, TextEditor } from 'vscode';
+import { Disposable, Selection, TextDocument, TextEditor, Uri } from 'vscode';
 
 import { IApplicationShell, IDocumentManager } from '../../client/common/application/types';
 import { createDeferred, waitForPromise } from '../../client/common/utils/async';
@@ -254,7 +254,7 @@ for _ in range(50):
         const docManager = TypeMoq.Mock.ofType<IDocumentManager>();
         const visibleEditor = TypeMoq.Mock.ofType<TextEditor>();
         const dummyDocument = TypeMoq.Mock.ofType<TextDocument>();
-        dummyDocument.setup(d => d.fileName).returns(() => 'foo.py');
+        dummyDocument.setup(d => d.fileName).returns(() => Uri.file('foo.py').fsPath);
         visibleEditor.setup(v => v.show()).returns(() => showedEditor.resolve());
         visibleEditor.setup(v => v.revealRange(TypeMoq.It.isAny())).returns(noop);
         visibleEditor.setup(v => v.document).returns(() => dummyDocument.object);
@@ -394,7 +394,7 @@ for _ in range(50):
         const updatePromise = waitForUpdate(wrapper, InteractivePanel);
 
         // Send some code to the interactive window
-        await interactiveWindow.addCode('a=1\na', 'foo.py', 2);
+        await interactiveWindow.addCode('a=1\na', Uri.file('foo.py').fsPath, 2);
 
         // Wait for the render to go through
         await updatePromise;
@@ -533,13 +533,13 @@ for _ in range(50):
         const executed = createDeferred();
         // We have to wait until the execute goes through before we reset.
         interactiveWindow.onExecutedCode(() => executed.resolve());
-        const added = interactiveWindow.addCode('import time\r\ntime.sleep(1000)', 'foo', 0);
+        const added = interactiveWindow.addCode('import time\r\ntime.sleep(1000)', Uri.file('foo').fsPath, 0);
         await executed.promise;
         await interactiveWindow.restartKernel();
         await added;
 
         // Now see if our wrapper still works. Interactive window should have forced a restart
-        await interactiveWindow.addCode('a=1\na', 'foo', 0);
+        await interactiveWindow.addCode('a=1\na', Uri.file('foo').fsPath, 0);
         verifyHtmlOnCell(wrapper, 'InteractiveCell', '<span>1</span>', CellPosition.Last);
 
     }, () => { return ioc; });
diff --git a/src/test/datascience/interactiveWindowTestHelpers.tsx b/src/test/datascience/interactiveWindowTestHelpers.tsx
index 05bf07e76361..a5d02690d572 100644
--- a/src/test/datascience/interactiveWindowTestHelpers.tsx
+++ b/src/test/datascience/interactiveWindowTestHelpers.tsx
@@ -5,6 +5,7 @@ import * as assert from 'assert';
 import { ReactWrapper } from 'enzyme';
 import * as React from 'react';
 
+import { Uri } from 'vscode';
 import { IInteractiveWindow, IInteractiveWindowProvider, IJupyterExecution } from '../../client/datascience/types';
 import { InteractivePanel } from '../../datascience-ui/history-react/interactivePanel';
 import { DataScienceIocContainer } from './dataScienceIocContainer';
@@ -46,7 +47,7 @@ export async function addCode(ioc: DataScienceIocContainer, wrapper: ReactWrappe
     // 5) Status finished
     return getInteractiveCellResults(wrapper, expectedRenderCount, async () => {
         const history = await getOrCreateInteractiveWindow(ioc);
-        const success = await history.addCode(code, 'foo.py', 2);
+        const success = await history.addCode(code, Uri.file('foo.py').fsPath, 2);
         if (expectError) {
             assert.equal(success, false, `${code} did not produce an error`);
         }
diff --git a/src/test/datascience/liveshare.functional.test.tsx b/src/test/datascience/liveshare.functional.test.tsx
index 1ff19cafed39..32380c0d9ed9 100644
--- a/src/test/datascience/liveshare.functional.test.tsx
+++ b/src/test/datascience/liveshare.functional.test.tsx
@@ -137,7 +137,7 @@ suite('DataScience LiveShare tests', () => {
         return waitForResults(role, async (both: boolean) => {
             if (!both) {
                 const history = await getOrCreateInteractiveWindow(role);
-                await history.addCode(code, 'foo.py', 2);
+                await history.addCode(code, Uri.file('foo.py').fsPath, 2);
             } else {
                 // Add code to the apropriate container
                 const host = await getOrCreateInteractiveWindow(vsls.Role.Host);
@@ -145,9 +145,9 @@ suite('DataScience LiveShare tests', () => {
                 // Make sure guest is still creatable
                 if (isSessionStarted(vsls.Role.Guest)) {
                     const guest = await getOrCreateInteractiveWindow(vsls.Role.Guest);
-                    (role === vsls.Role.Host ? await host.addCode(code, 'foo.py', 2) : await guest.addCode(code, 'foo.py', 2));
+                    (role === vsls.Role.Host ? await host.addCode(code, Uri.file('foo.py').fsPath, 2) : await guest.addCode(code, Uri.file('foo.py').fsPath, 2));
                 } else {
-                    await host.addCode(code, 'foo.py', 2);
+                    await host.addCode(code, Uri.file('foo.py').fsPath, 2);
                 }
             }
         }, expectedRenderCount);
@@ -319,7 +319,7 @@ suite('DataScience LiveShare tests', () => {
         await startSession(vsls.Role.Guest);
 
         // Create a document on the guest
-        guestContainer!.addDocument('#%%\na=1\na', 'foo.py');
+        guestContainer!.addDocument('#%%\na=1\na', Uri.file('foo.py').fsPath);
         guestContainer!.get<IDocumentManager>(IDocumentManager).showTextDocument(Uri.file('foo.py'));
 
         // Attempt to export a file from the guest by running an ExportFileAndOutputAsNotebook
@@ -327,7 +327,7 @@ suite('DataScience LiveShare tests', () => {
         assert.ok(executePromise, 'Export file did not return a promise');
         const savedUri = await executePromise;
         assert.ok(savedUri, 'Uri not returned from export');
-        assert.equal(savedUri.fsPath, 'test.ipynb', 'Export did not work');
+        assert.equal(savedUri.fsPath, Uri.file('test.ipynb').fsPath, 'Export did not work');
         assert.ok(outputContents, 'Output not exported');
         assert.ok(outputContents!.includes('data'), 'Output is empty');
     });
diff --git a/src/test/datascience/mockDocumentManager.ts b/src/test/datascience/mockDocumentManager.ts
index 3c8052fc2c08..a3ded873a19b 100644
--- a/src/test/datascience/mockDocumentManager.ts
+++ b/src/test/datascience/mockDocumentManager.ts
@@ -94,7 +94,7 @@ export class MockDocumentManager implements IDocumentManager {
     }
 
     public changeDocument(file: string, changes: { range: Range; newText: string }[]) {
-        const doc = this.textDocuments.find(d => d.fileName === file) as MockDocument;
+        const doc = this.textDocuments.find(d => d.uri.fsPath === Uri.file(file).fsPath) as MockDocument;
         if (doc) {
             const contentChanges = changes.map(c => {
                 const startOffset = doc.offsetAt(c.range.start);
diff --git a/src/test/datascience/mockJupyterManager.ts b/src/test/datascience/mockJupyterManager.ts
index d2671fd8d382..e5320ed826c0 100644
--- a/src/test/datascience/mockJupyterManager.ts
+++ b/src/test/datascience/mockJupyterManager.ts
@@ -9,7 +9,7 @@ import * as path from 'path';
 import { Observable } from 'rxjs/Observable';
 import * as TypeMoq from 'typemoq';
 import * as uuid from 'uuid/v4';
-import { EventEmitter } from 'vscode';
+import { EventEmitter, Uri } from 'vscode';
 import { CancellationToken } from 'vscode-jsonrpc';
 
 import { Cancellation } from '../../client/common/cancellation';
@@ -107,13 +107,26 @@ export class MockJupyterManager implements IJupyterSessionManager {
         this.addCell('matplotlib.style.use(\'dark_background\')');
         this.addCell(`matplotlib.rcParams.update(${Identifiers.MatplotLibDefaultParams})`);
         this.addCell(`%cd "${path.join(EXTENSION_ROOT_DIR, 'src', 'test', 'datascience')}"`);
+        // When we have windows file names, we replace `\` with `\\`.
+        // Code is as follows `await this.notebook.execute(`__file__ = '${file.replace(/\\/g, '\\\\')}'`, file, line, uuid(), undefined, true);
+        // Found in src\client\datascience\interactive-common\interactiveBase.ts.
+        this.addCell(`%cd "${Uri.file(path.join(EXTENSION_ROOT_DIR, 'src', 'test', 'datascience')).fsPath}`);
         this.addCell('import sys\r\nsys.version', '1.1.1.1');
         this.addCell('import sys\r\nsys.executable', 'python');
         this.addCell('import notebook\r\nnotebook.version_info', '1.1.1.1');
-        this.addCell(`__file__ = 'foo.py'`);
-        this.addCell(`__file__ = 'bar.py'`);
-        this.addCell(`__file__ = 'foo'`);
-        this.addCell(`__file__ = 'test.py'`);
+
+        this.addCell(`__file__ = '${Uri.file('foo.py').fsPath}'`);
+        this.addCell(`__file__ = '${Uri.file('bar.py').fsPath}'`);
+        this.addCell(`__file__ = '${Uri.file('foo').fsPath}'`);
+        this.addCell(`__file__ = '${Uri.file('test.py').fsPath}'`);
+
+        // When we have windows file names, we replace `\` with `\\`.
+        // Code is as follows `await this.notebook.execute(`__file__ = '${file.replace(/\\/g, '\\\\')}'`, file, line, uuid(), undefined, true);
+        // Found in src\client\datascience\interactive-common\interactiveBase.ts.
+        this.addCell(`__file__ = '${Uri.file('foo.py').fsPath.replace(/\\/g, '\\\\')}'`);
+        this.addCell(`__file__ = '${Uri.file('bar.py').fsPath.replace(/\\/g, '\\\\')}'`);
+        this.addCell(`__file__ = '${Uri.file('foo').fsPath.replace(/\\/g, '\\\\')}'`);
+        this.addCell(`__file__ = '${Uri.file('test.py').fsPath.replace(/\\/g, '\\\\')}'`);
     }
 
     public getConnInfo(): IConnection {
@@ -171,7 +184,7 @@ export class MockJupyterManager implements IJupyterSessionManager {
     }
 
     public addContinuousOutputCell(code: string, resultGenerator: (cancelToken: CancellationToken) => Promise<{ result: string; haveMore: boolean }>) {
-        const cells = generateCells(undefined, code, 'foo.py', 1, true, uuid());
+        const cells = generateCells(undefined, code, Uri.file('foo.py').fsPath, 1, true, uuid());
         cells.forEach(c => {
             const key = concatMultilineString(c.data.source).replace(LineFeedRegEx, '');
             if (c.data.cell_type === 'code') {
@@ -202,7 +215,7 @@ export class MockJupyterManager implements IJupyterSessionManager {
     }
 
     public addCell(code: string, result?: undefined | string | number | nbformat.IUnrecognizedOutput | nbformat.IExecuteResult | nbformat.IDisplayData | nbformat.IStream | nbformat.IError, mimeType?: string) {
-        const cells = generateCells(undefined, code, 'foo.py', 1, true, uuid());
+        const cells = generateCells(undefined, code, Uri.file('foo.py').fsPath, 1, true, uuid());
         cells.forEach(c => {
             const cellMatcher = new CellMatcher();
             const key = cellMatcher.stripFirstMarker(concatMultilineString(c.data.source)).replace(LineFeedRegEx, '');
diff --git a/src/test/datascience/mockLiveShare.ts b/src/test/datascience/mockLiveShare.ts
index 031826718886..435c6e1a62e1 100644
--- a/src/test/datascience/mockLiveShare.ts
+++ b/src/test/datascience/mockLiveShare.ts
@@ -2,7 +2,6 @@
 // Licensed under the MIT License.
 'use strict';
 import { inject, injectable } from 'inversify';
-import * as path from 'path';
 import * as uuid from 'uuid/v4';
 import { CancellationToken, CancellationTokenSource, Disposable, Event, EventEmitter, TreeDataProvider, Uri } from 'vscode';
 import * as vsls from 'vsls/vscode';
@@ -325,8 +324,7 @@ class MockLiveShare implements vsls.LiveShare, vsls.Session, vsls.Peer, IDisposa
             throw new Error(`Not a workspace file URI: ${localUri}`);
         }
 
-        const file = localUri.fsPath.includes('/') ? path.basename(localUri.fsPath) : localUri.fsPath;
-        return Uri.parse(`vsls:${file}`);
+        return Uri.parse(`vsls:${localUri.fsPath}`);
     }
     public convertSharedUriToLocal(sharedUri: Uri): Uri {
         checkArg(sharedUri, 'sharedUri', 'uri');
diff --git a/src/test/datascience/nativeEditor.functional.test.tsx b/src/test/datascience/nativeEditor.functional.test.tsx
index 590d50040f05..f047d12840fb 100644
--- a/src/test/datascience/nativeEditor.functional.test.tsx
+++ b/src/test/datascience/nativeEditor.functional.test.tsx
@@ -179,7 +179,7 @@ suite('DataScience Native Editor', () => {
             const docManager = TypeMoq.Mock.ofType<IDocumentManager>();
             const visibleEditor = TypeMoq.Mock.ofType<TextEditor>();
             const dummyDocument = TypeMoq.Mock.ofType<TextDocument>();
-            dummyDocument.setup(d => d.fileName).returns(() => 'foo.py');
+            dummyDocument.setup(d => d.fileName).returns(() => Uri.file('foo.py').fsPath);
             visibleEditor.setup(v => v.show()).returns(() => showedEditor.resolve());
             visibleEditor.setup(v => v.revealRange(TypeMoq.It.isAny())).returns(noop);
             visibleEditor.setup(v => v.document).returns(() => dummyDocument.object);
diff --git a/src/test/datascience/notebook.functional.test.ts b/src/test/datascience/notebook.functional.test.ts
index 886909de3351..e0c9c3cd057e 100644
--- a/src/test/datascience/notebook.functional.test.ts
+++ b/src/test/datascience/notebook.functional.test.ts
@@ -635,7 +635,7 @@ suite('DataScience notebook tests', () => {
         let finishedBefore = false;
         const finishedPromise = createDeferred();
         let error;
-        const observable = notebook!.executeObservable(code, 'foo.py', 0, uuid(), false);
+        const observable = notebook!.executeObservable(code, Uri.file('foo.py').fsPath, 0, uuid(), false);
         observable.subscribe(c => {
             if (c.length > 0 && c[0].state === CellState.error) {
                 finishedBefore = !interrupted;
diff --git a/src/test/debugger/extension/configuration/resolvers/attach.unit.test.ts b/src/test/debugger/extension/configuration/resolvers/attach.unit.test.ts
index 2d1d174ccd9a..0127e3fc70f1 100644
--- a/src/test/debugger/extension/configuration/resolvers/attach.unit.test.ts
+++ b/src/test/debugger/extension/configuration/resolvers/attach.unit.test.ts
@@ -16,6 +16,7 @@ import { OSType } from '../../../../../client/common/utils/platform';
 import { AttachConfigurationResolver } from '../../../../../client/debugger/extension/configuration/resolvers/attach';
 import { AttachRequestArguments, DebugOptions } from '../../../../../client/debugger/types';
 import { IServiceContainer } from '../../../../../client/ioc/types';
+import { getOSType } from '../../../../common';
 import { getInfoPerOS, setUpOSMocks } from './common';
 
 getInfoPerOS().forEach(([osName, osType, path]) => {
@@ -174,7 +175,10 @@ getInfoPerOS().forEach(([osName, osType, path]) => {
                 expect(pathMappings![0].localRoot).to.be.equal(workspaceFolder.uri.fsPath);
                 expect(pathMappings![0].remoteRoot).to.be.equal(workspaceFolder.uri.fsPath);
             });
-            test(`Ensure drive letter is lower cased for local path mappings on Windows when host is '${host}'`, async () => {
+            test(`Ensure drive letter is lower cased for local path mappings on Windows when host is '${host}'`, async function () {
+                if (getOSType() !== OSType.Windows || osType !== OSType.Windows){
+                    return this.skip();
+                }
                 const activeFile = 'xyz.py';
                 const workspaceFolder = createMoqWorkspaceFolder(path.join('C:', 'Debug', 'Python_Path'));
                 setupActiveEditor(activeFile, PYTHON_LANGUAGE);
@@ -185,13 +189,32 @@ getInfoPerOS().forEach(([osName, osType, path]) => {
                 const debugConfig = await debugProvider.resolveDebugConfiguration!(workspaceFolder, { localRoot, host, request: 'attach' } as any as DebugConfiguration);
                 const pathMappings = (debugConfig as AttachRequestArguments).pathMappings;
 
-                const expected = osType === OSType.Windows
-                    ? path.join('c:', 'Debug', 'Python_Path')
-                    : path.join('C:', 'Debug', 'Python_Path');
+                const expected = Uri.file(path.join('c:', 'Debug', 'Python_Path')).fsPath;
                 expect(pathMappings![0].localRoot).to.be.equal(expected);
                 expect(pathMappings![0].remoteRoot).to.be.equal(workspaceFolder.uri.fsPath);
             });
-            test(`Ensure drive letter is lower cased for local path mappings on Windows when host is '${host}' and with existing path mappings`, async () => {
+            test(`Ensure drive letter is not lower cased for local path mappings on non-Windows when host is '${host}'`, async function () {
+                if (getOSType() === OSType.Windows || osType === OSType.Windows){
+                    return this.skip();
+                }
+                const activeFile = 'xyz.py';
+                const workspaceFolder = createMoqWorkspaceFolder(path.join('USR', 'Debug', 'Python_Path'));
+                setupActiveEditor(activeFile, PYTHON_LANGUAGE);
+                const defaultWorkspace = path.join('usr', 'desktop');
+                setupWorkspaces([defaultWorkspace]);
+
+                const localRoot = `Debug_PythonPath_${new Date().toString()}`;
+                const debugConfig = await debugProvider.resolveDebugConfiguration!(workspaceFolder, { localRoot, host, request: 'attach' } as any as DebugConfiguration);
+                const pathMappings = (debugConfig as AttachRequestArguments).pathMappings;
+
+                const expected = Uri.file(path.join('USR', 'Debug', 'Python_Path')).fsPath;
+                expect(pathMappings![0].localRoot).to.be.equal(expected);
+                expect(pathMappings![0].remoteRoot).to.be.equal(workspaceFolder.uri.fsPath);
+            });
+            test(`Ensure drive letter is lower cased for local path mappings on Windows when host is '${host}' and with existing path mappings`, async function () {
+                if (getOSType() !== OSType.Windows || osType !== OSType.Windows){
+                    return this.skip();
+                }
                 const activeFile = 'xyz.py';
                 const workspaceFolder = createMoqWorkspaceFolder(path.join('C:', 'Debug', 'Python_Path'));
                 setupActiveEditor(activeFile, PYTHON_LANGUAGE);
@@ -203,9 +226,26 @@ getInfoPerOS().forEach(([osName, osType, path]) => {
                 const debugConfig = await debugProvider.resolveDebugConfiguration!(workspaceFolder, { localRoot, pathMappings: debugPathMappings, host, request: 'attach' } as any as DebugConfiguration);
                 const pathMappings = (debugConfig as AttachRequestArguments).pathMappings;
 
-                const expected = osType === OSType.Windows
-                    ? path.join('c:', 'Debug', 'Python_Path', localRoot)
-                    : path.join('C:', 'Debug', 'Python_Path', localRoot);
+                const expected = Uri.file(path.join('c:', 'Debug', 'Python_Path', localRoot)).fsPath;
+                expect(pathMappings![0].localRoot).to.be.equal(expected);
+                expect(pathMappings![0].remoteRoot).to.be.equal('/app/');
+            });
+            test(`Ensure drive letter is not lower cased for local path mappings on non-Windows when host is '${host}' and with existing path mappings`, async function () {
+                if (getOSType() === OSType.Windows || osType === OSType.Windows){
+                    return this.skip();
+                }
+                const activeFile = 'xyz.py';
+                const workspaceFolder = createMoqWorkspaceFolder(path.join('USR', 'Debug', 'Python_Path'));
+                setupActiveEditor(activeFile, PYTHON_LANGUAGE);
+                const defaultWorkspace = path.join('usr', 'desktop');
+                setupWorkspaces([defaultWorkspace]);
+
+                const localRoot = `Debug_PythonPath_${new Date().toString()}`;
+                const debugPathMappings = [ { localRoot: path.join('${workspaceFolder}', localRoot), remoteRoot: '/app/' }];
+                const debugConfig = await debugProvider.resolveDebugConfiguration!(workspaceFolder, { localRoot, pathMappings: debugPathMappings, host, request: 'attach' } as any as DebugConfiguration);
+                const pathMappings = (debugConfig as AttachRequestArguments).pathMappings;
+
+                const expected = Uri.file(path.join('USR', 'Debug', 'Python_Path', localRoot)).fsPath;
                 expect(pathMappings![0].localRoot).to.be.equal(expected);
                 expect(pathMappings![0].remoteRoot).to.be.equal('/app/');
             });
diff --git a/src/test/debugger/extension/configuration/resolvers/launch.unit.test.ts b/src/test/debugger/extension/configuration/resolvers/launch.unit.test.ts
index 016b53d06447..eb4694642517 100644
--- a/src/test/debugger/extension/configuration/resolvers/launch.unit.test.ts
+++ b/src/test/debugger/extension/configuration/resolvers/launch.unit.test.ts
@@ -20,6 +20,7 @@ import { IDebugEnvironmentVariablesService } from '../../../../../client/debugge
 import { LaunchConfigurationResolver } from '../../../../../client/debugger/extension/configuration/resolvers/launch';
 import { DebugOptions, LaunchRequestArguments } from '../../../../../client/debugger/types';
 import { IInterpreterHelper } from '../../../../../client/interpreter/contracts';
+import { getOSType } from '../../../../common';
 import { getInfoPerOS, setUpOSMocks } from './common';
 
 getInfoPerOS().forEach(([osName, osType, path]) => {
@@ -379,33 +380,63 @@ getInfoPerOS().forEach(([osName, osType, path]) => {
                 remoteRoot: '.'
             }]);
         });
-        test('Ensure drive letter is lower cased for local path mappings on Windows when with existing path mappings', async () => {
+        test('Ensure drive letter is lower cased for local path mappings on Windows when with existing path mappings', async function () {
+            if (getOSType() !== OSType.Windows || osType !== OSType.Windows){
+                // tslint:disable-next-line: no-invalid-this
+                return this.skip();
+            }
             const workspaceFolder = createMoqWorkspaceFolder(path.join('C:', 'Debug', 'Python_Path'));
             setupActiveEditor('spam.py', PYTHON_LANGUAGE);
             const defaultWorkspace = path.join('usr', 'desktop');
             setupWorkspaces([defaultWorkspace]);
-            const localRoot = path.join(workspaceFolder.uri.fsPath, 'app');
+            const localRoot = Uri.file(path.join(workspaceFolder.uri.fsPath, 'app')).fsPath;
 
             const debugConfig = await debugProvider.resolveDebugConfiguration!(
                 workspaceFolder,
                 {
                     request: 'launch',
                     pathMappings: [{
-                        localRoot: localRoot,
+                        localRoot,
                         remoteRoot: '/app/'
                     }]
                 } as any as DebugConfiguration
             );
 
             const pathMappings = (debugConfig as LaunchRequestArguments).pathMappings;
-            const expected = osType === OSType.Windows
-                ? `c${localRoot.substring(1)}`
-                : localRoot;
+            const expected = Uri.file(`c${localRoot.substring(1)}`).fsPath;
             expect(pathMappings).to.deep.equal([{
                 localRoot: expected,
                 remoteRoot: '/app/'
             }]);
         });
+        test('Ensure drive letter is not lower cased for local path mappings on non-Windows when with existing path mappings', async function () {
+            if (getOSType() === OSType.Windows || osType === OSType.Windows){
+                // tslint:disable-next-line: no-invalid-this
+                return this.skip();
+            }
+            const workspaceFolder = createMoqWorkspaceFolder(path.join('USR', 'Debug', 'Python_Path'));
+            setupActiveEditor('spam.py', PYTHON_LANGUAGE);
+            const defaultWorkspace = path.join('usr', 'desktop');
+            setupWorkspaces([defaultWorkspace]);
+            const localRoot = Uri.file(path.join(workspaceFolder.uri.fsPath, 'app')).fsPath;
+
+            const debugConfig = await debugProvider.resolveDebugConfiguration!(
+                workspaceFolder,
+                {
+                    request: 'launch',
+                    pathMappings: [{
+                        localRoot,
+                        remoteRoot: '/app/'
+                    }]
+                } as any as DebugConfiguration
+            );
+
+            const pathMappings = (debugConfig as LaunchRequestArguments).pathMappings;
+            expect(pathMappings).to.deep.equal([{
+                localRoot,
+                remoteRoot: '/app/'
+            }]);
+        });
         test('Ensure local path mappings are not modified when not pointing to a local drive', async () => {
             const workspaceFolder = createMoqWorkspaceFolder(path.join('Server', 'Debug', 'Python_Path'));
             setupActiveEditor('spam.py', PYTHON_LANGUAGE);
diff --git a/src/test/mocks/vsc/charCode.ts b/src/test/mocks/vsc/charCode.ts
new file mode 100644
index 000000000000..98bbd400de7f
--- /dev/null
+++ b/src/test/mocks/vsc/charCode.ts
@@ -0,0 +1,427 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/* tslint:disable */
+
+// Names from https://blog.codinghorror.com/ascii-pronunciation-rules-for-programmers/
+
+/**
+ * An inlined enum containing useful character codes (to be used with String.charCodeAt).
+ * Please leave the const keyword such that it gets inlined when compiled to JavaScript!
+ */
+export const enum CharCode {
+	Null = 0,
+	/**
+	 * The `\b` character.
+	 */
+	Backspace = 8,
+	/**
+	 * The `\t` character.
+	 */
+	Tab = 9,
+	/**
+	 * The `\n` character.
+	 */
+	LineFeed = 10,
+	/**
+	 * The `\r` character.
+	 */
+	CarriageReturn = 13,
+	Space = 32,
+	/**
+	 * The `!` character.
+	 */
+	ExclamationMark = 33,
+	/**
+	 * The `"` character.
+	 */
+	DoubleQuote = 34,
+	/**
+	 * The `#` character.
+	 */
+	Hash = 35,
+	/**
+	 * The `$` character.
+	 */
+	DollarSign = 36,
+	/**
+	 * The `%` character.
+	 */
+	PercentSign = 37,
+	/**
+	 * The `&` character.
+	 */
+	Ampersand = 38,
+	/**
+	 * The `'` character.
+	 */
+	SingleQuote = 39,
+	/**
+	 * The `(` character.
+	 */
+	OpenParen = 40,
+	/**
+	 * The `)` character.
+	 */
+	CloseParen = 41,
+	/**
+	 * The `*` character.
+	 */
+	Asterisk = 42,
+	/**
+	 * The `+` character.
+	 */
+	Plus = 43,
+	/**
+	 * The `,` character.
+	 */
+	Comma = 44,
+	/**
+	 * The `-` character.
+	 */
+	Dash = 45,
+	/**
+	 * The `.` character.
+	 */
+	Period = 46,
+	/**
+	 * The `/` character.
+	 */
+	Slash = 47,
+
+	Digit0 = 48,
+	Digit1 = 49,
+	Digit2 = 50,
+	Digit3 = 51,
+	Digit4 = 52,
+	Digit5 = 53,
+	Digit6 = 54,
+	Digit7 = 55,
+	Digit8 = 56,
+	Digit9 = 57,
+
+	/**
+	 * The `:` character.
+	 */
+	Colon = 58,
+	/**
+	 * The `;` character.
+	 */
+	Semicolon = 59,
+	/**
+	 * The `<` character.
+	 */
+	LessThan = 60,
+	/**
+	 * The `=` character.
+	 */
+	Equals = 61,
+	/**
+	 * The `>` character.
+	 */
+	GreaterThan = 62,
+	/**
+	 * The `?` character.
+	 */
+	QuestionMark = 63,
+	/**
+	 * The `@` character.
+	 */
+	AtSign = 64,
+
+	A = 65,
+	B = 66,
+	C = 67,
+	D = 68,
+	E = 69,
+	F = 70,
+	G = 71,
+	H = 72,
+	I = 73,
+	J = 74,
+	K = 75,
+	L = 76,
+	M = 77,
+	N = 78,
+	O = 79,
+	P = 80,
+	Q = 81,
+	R = 82,
+	S = 83,
+	T = 84,
+	U = 85,
+	V = 86,
+	W = 87,
+	X = 88,
+	Y = 89,
+	Z = 90,
+
+	/**
+	 * The `[` character.
+	 */
+	OpenSquareBracket = 91,
+	/**
+	 * The `\` character.
+	 */
+	Backslash = 92,
+	/**
+	 * The `]` character.
+	 */
+	CloseSquareBracket = 93,
+	/**
+	 * The `^` character.
+	 */
+	Caret = 94,
+	/**
+	 * The `_` character.
+	 */
+	Underline = 95,
+	/**
+	 * The ``(`)`` character.
+	 */
+	BackTick = 96,
+
+	a = 97,
+	b = 98,
+	c = 99,
+	d = 100,
+	e = 101,
+	f = 102,
+	g = 103,
+	h = 104,
+	i = 105,
+	j = 106,
+	k = 107,
+	l = 108,
+	m = 109,
+	n = 110,
+	o = 111,
+	p = 112,
+	q = 113,
+	r = 114,
+	s = 115,
+	t = 116,
+	u = 117,
+	v = 118,
+	w = 119,
+	x = 120,
+	y = 121,
+	z = 122,
+
+	/**
+	 * The `{` character.
+	 */
+	OpenCurlyBrace = 123,
+	/**
+	 * The `|` character.
+	 */
+	Pipe = 124,
+	/**
+	 * The `}` character.
+	 */
+	CloseCurlyBrace = 125,
+	/**
+	 * The `~` character.
+	 */
+	Tilde = 126,
+
+	U_Combining_Grave_Accent = 0x0300,								//	U+0300	Combining Grave Accent
+	U_Combining_Acute_Accent = 0x0301,								//	U+0301	Combining Acute Accent
+	U_Combining_Circumflex_Accent = 0x0302,							//	U+0302	Combining Circumflex Accent
+	U_Combining_Tilde = 0x0303,										//	U+0303	Combining Tilde
+	U_Combining_Macron = 0x0304,									//	U+0304	Combining Macron
+	U_Combining_Overline = 0x0305,									//	U+0305	Combining Overline
+	U_Combining_Breve = 0x0306,										//	U+0306	Combining Breve
+	U_Combining_Dot_Above = 0x0307,									//	U+0307	Combining Dot Above
+	U_Combining_Diaeresis = 0x0308,									//	U+0308	Combining Diaeresis
+	U_Combining_Hook_Above = 0x0309,								//	U+0309	Combining Hook Above
+	U_Combining_Ring_Above = 0x030A,								//	U+030A	Combining Ring Above
+	U_Combining_Double_Acute_Accent = 0x030B,						//	U+030B	Combining Double Acute Accent
+	U_Combining_Caron = 0x030C,										//	U+030C	Combining Caron
+	U_Combining_Vertical_Line_Above = 0x030D,						//	U+030D	Combining Vertical Line Above
+	U_Combining_Double_Vertical_Line_Above = 0x030E,				//	U+030E	Combining Double Vertical Line Above
+	U_Combining_Double_Grave_Accent = 0x030F,						//	U+030F	Combining Double Grave Accent
+	U_Combining_Candrabindu = 0x0310,								//	U+0310	Combining Candrabindu
+	U_Combining_Inverted_Breve = 0x0311,							//	U+0311	Combining Inverted Breve
+	U_Combining_Turned_Comma_Above = 0x0312,						//	U+0312	Combining Turned Comma Above
+	U_Combining_Comma_Above = 0x0313,								//	U+0313	Combining Comma Above
+	U_Combining_Reversed_Comma_Above = 0x0314,						//	U+0314	Combining Reversed Comma Above
+	U_Combining_Comma_Above_Right = 0x0315,							//	U+0315	Combining Comma Above Right
+	U_Combining_Grave_Accent_Below = 0x0316,						//	U+0316	Combining Grave Accent Below
+	U_Combining_Acute_Accent_Below = 0x0317,						//	U+0317	Combining Acute Accent Below
+	U_Combining_Left_Tack_Below = 0x0318,							//	U+0318	Combining Left Tack Below
+	U_Combining_Right_Tack_Below = 0x0319,							//	U+0319	Combining Right Tack Below
+	U_Combining_Left_Angle_Above = 0x031A,							//	U+031A	Combining Left Angle Above
+	U_Combining_Horn = 0x031B,										//	U+031B	Combining Horn
+	U_Combining_Left_Half_Ring_Below = 0x031C,						//	U+031C	Combining Left Half Ring Below
+	U_Combining_Up_Tack_Below = 0x031D,								//	U+031D	Combining Up Tack Below
+	U_Combining_Down_Tack_Below = 0x031E,							//	U+031E	Combining Down Tack Below
+	U_Combining_Plus_Sign_Below = 0x031F,							//	U+031F	Combining Plus Sign Below
+	U_Combining_Minus_Sign_Below = 0x0320,							//	U+0320	Combining Minus Sign Below
+	U_Combining_Palatalized_Hook_Below = 0x0321,					//	U+0321	Combining Palatalized Hook Below
+	U_Combining_Retroflex_Hook_Below = 0x0322,						//	U+0322	Combining Retroflex Hook Below
+	U_Combining_Dot_Below = 0x0323,									//	U+0323	Combining Dot Below
+	U_Combining_Diaeresis_Below = 0x0324,							//	U+0324	Combining Diaeresis Below
+	U_Combining_Ring_Below = 0x0325,								//	U+0325	Combining Ring Below
+	U_Combining_Comma_Below = 0x0326,								//	U+0326	Combining Comma Below
+	U_Combining_Cedilla = 0x0327,									//	U+0327	Combining Cedilla
+	U_Combining_Ogonek = 0x0328,									//	U+0328	Combining Ogonek
+	U_Combining_Vertical_Line_Below = 0x0329,						//	U+0329	Combining Vertical Line Below
+	U_Combining_Bridge_Below = 0x032A,								//	U+032A	Combining Bridge Below
+	U_Combining_Inverted_Double_Arch_Below = 0x032B,				//	U+032B	Combining Inverted Double Arch Below
+	U_Combining_Caron_Below = 0x032C,								//	U+032C	Combining Caron Below
+	U_Combining_Circumflex_Accent_Below = 0x032D,					//	U+032D	Combining Circumflex Accent Below
+	U_Combining_Breve_Below = 0x032E,								//	U+032E	Combining Breve Below
+	U_Combining_Inverted_Breve_Below = 0x032F,						//	U+032F	Combining Inverted Breve Below
+	U_Combining_Tilde_Below = 0x0330,								//	U+0330	Combining Tilde Below
+	U_Combining_Macron_Below = 0x0331,								//	U+0331	Combining Macron Below
+	U_Combining_Low_Line = 0x0332,									//	U+0332	Combining Low Line
+	U_Combining_Double_Low_Line = 0x0333,							//	U+0333	Combining Double Low Line
+	U_Combining_Tilde_Overlay = 0x0334,								//	U+0334	Combining Tilde Overlay
+	U_Combining_Short_Stroke_Overlay = 0x0335,						//	U+0335	Combining Short Stroke Overlay
+	U_Combining_Long_Stroke_Overlay = 0x0336,						//	U+0336	Combining Long Stroke Overlay
+	U_Combining_Short_Solidus_Overlay = 0x0337,						//	U+0337	Combining Short Solidus Overlay
+	U_Combining_Long_Solidus_Overlay = 0x0338,						//	U+0338	Combining Long Solidus Overlay
+	U_Combining_Right_Half_Ring_Below = 0x0339,						//	U+0339	Combining Right Half Ring Below
+	U_Combining_Inverted_Bridge_Below = 0x033A,						//	U+033A	Combining Inverted Bridge Below
+	U_Combining_Square_Below = 0x033B,								//	U+033B	Combining Square Below
+	U_Combining_Seagull_Below = 0x033C,								//	U+033C	Combining Seagull Below
+	U_Combining_X_Above = 0x033D,									//	U+033D	Combining X Above
+	U_Combining_Vertical_Tilde = 0x033E,							//	U+033E	Combining Vertical Tilde
+	U_Combining_Double_Overline = 0x033F,							//	U+033F	Combining Double Overline
+	U_Combining_Grave_Tone_Mark = 0x0340,							//	U+0340	Combining Grave Tone Mark
+	U_Combining_Acute_Tone_Mark = 0x0341,							//	U+0341	Combining Acute Tone Mark
+	U_Combining_Greek_Perispomeni = 0x0342,							//	U+0342	Combining Greek Perispomeni
+	U_Combining_Greek_Koronis = 0x0343,								//	U+0343	Combining Greek Koronis
+	U_Combining_Greek_Dialytika_Tonos = 0x0344,						//	U+0344	Combining Greek Dialytika Tonos
+	U_Combining_Greek_Ypogegrammeni = 0x0345,						//	U+0345	Combining Greek Ypogegrammeni
+	U_Combining_Bridge_Above = 0x0346,								//	U+0346	Combining Bridge Above
+	U_Combining_Equals_Sign_Below = 0x0347,							//	U+0347	Combining Equals Sign Below
+	U_Combining_Double_Vertical_Line_Below = 0x0348,				//	U+0348	Combining Double Vertical Line Below
+	U_Combining_Left_Angle_Below = 0x0349,							//	U+0349	Combining Left Angle Below
+	U_Combining_Not_Tilde_Above = 0x034A,							//	U+034A	Combining Not Tilde Above
+	U_Combining_Homothetic_Above = 0x034B,							//	U+034B	Combining Homothetic Above
+	U_Combining_Almost_Equal_To_Above = 0x034C,						//	U+034C	Combining Almost Equal To Above
+	U_Combining_Left_Right_Arrow_Below = 0x034D,					//	U+034D	Combining Left Right Arrow Below
+	U_Combining_Upwards_Arrow_Below = 0x034E,						//	U+034E	Combining Upwards Arrow Below
+	U_Combining_Grapheme_Joiner = 0x034F,							//	U+034F	Combining Grapheme Joiner
+	U_Combining_Right_Arrowhead_Above = 0x0350,						//	U+0350	Combining Right Arrowhead Above
+	U_Combining_Left_Half_Ring_Above = 0x0351,						//	U+0351	Combining Left Half Ring Above
+	U_Combining_Fermata = 0x0352,									//	U+0352	Combining Fermata
+	U_Combining_X_Below = 0x0353,									//	U+0353	Combining X Below
+	U_Combining_Left_Arrowhead_Below = 0x0354,						//	U+0354	Combining Left Arrowhead Below
+	U_Combining_Right_Arrowhead_Below = 0x0355,						//	U+0355	Combining Right Arrowhead Below
+	U_Combining_Right_Arrowhead_And_Up_Arrowhead_Below = 0x0356,	//	U+0356	Combining Right Arrowhead And Up Arrowhead Below
+	U_Combining_Right_Half_Ring_Above = 0x0357,						//	U+0357	Combining Right Half Ring Above
+	U_Combining_Dot_Above_Right = 0x0358,							//	U+0358	Combining Dot Above Right
+	U_Combining_Asterisk_Below = 0x0359,							//	U+0359	Combining Asterisk Below
+	U_Combining_Double_Ring_Below = 0x035A,							//	U+035A	Combining Double Ring Below
+	U_Combining_Zigzag_Above = 0x035B,								//	U+035B	Combining Zigzag Above
+	U_Combining_Double_Breve_Below = 0x035C,						//	U+035C	Combining Double Breve Below
+	U_Combining_Double_Breve = 0x035D,								//	U+035D	Combining Double Breve
+	U_Combining_Double_Macron = 0x035E,								//	U+035E	Combining Double Macron
+	U_Combining_Double_Macron_Below = 0x035F,						//	U+035F	Combining Double Macron Below
+	U_Combining_Double_Tilde = 0x0360,								//	U+0360	Combining Double Tilde
+	U_Combining_Double_Inverted_Breve = 0x0361,						//	U+0361	Combining Double Inverted Breve
+	U_Combining_Double_Rightwards_Arrow_Below = 0x0362,				//	U+0362	Combining Double Rightwards Arrow Below
+	U_Combining_Latin_Small_Letter_A = 0x0363, 						//	U+0363	Combining Latin Small Letter A
+	U_Combining_Latin_Small_Letter_E = 0x0364, 						//	U+0364	Combining Latin Small Letter E
+	U_Combining_Latin_Small_Letter_I = 0x0365, 						//	U+0365	Combining Latin Small Letter I
+	U_Combining_Latin_Small_Letter_O = 0x0366, 						//	U+0366	Combining Latin Small Letter O
+	U_Combining_Latin_Small_Letter_U = 0x0367, 						//	U+0367	Combining Latin Small Letter U
+	U_Combining_Latin_Small_Letter_C = 0x0368, 						//	U+0368	Combining Latin Small Letter C
+	U_Combining_Latin_Small_Letter_D = 0x0369, 						//	U+0369	Combining Latin Small Letter D
+	U_Combining_Latin_Small_Letter_H = 0x036A, 						//	U+036A	Combining Latin Small Letter H
+	U_Combining_Latin_Small_Letter_M = 0x036B, 						//	U+036B	Combining Latin Small Letter M
+	U_Combining_Latin_Small_Letter_R = 0x036C, 						//	U+036C	Combining Latin Small Letter R
+	U_Combining_Latin_Small_Letter_T = 0x036D, 						//	U+036D	Combining Latin Small Letter T
+	U_Combining_Latin_Small_Letter_V = 0x036E, 						//	U+036E	Combining Latin Small Letter V
+	U_Combining_Latin_Small_Letter_X = 0x036F, 						//	U+036F	Combining Latin Small Letter X
+
+	/**
+	 * Unicode Character 'LINE SEPARATOR' (U+2028)
+	 * http://www.fileformat.info/info/unicode/char/2028/index.htm
+	 */
+	LINE_SEPARATOR_2028 = 8232,
+
+	// http://www.fileformat.info/info/unicode/category/Sk/list.htm
+	U_CIRCUMFLEX = 0x005E,									// U+005E	CIRCUMFLEX
+	U_GRAVE_ACCENT = 0x0060,								// U+0060	GRAVE ACCENT
+	U_DIAERESIS = 0x00A8,									// U+00A8	DIAERESIS
+	U_MACRON = 0x00AF,										// U+00AF	MACRON
+	U_ACUTE_ACCENT = 0x00B4,								// U+00B4	ACUTE ACCENT
+	U_CEDILLA = 0x00B8,										// U+00B8	CEDILLA
+	U_MODIFIER_LETTER_LEFT_ARROWHEAD = 0x02C2,				// U+02C2	MODIFIER LETTER LEFT ARROWHEAD
+	U_MODIFIER_LETTER_RIGHT_ARROWHEAD = 0x02C3,				// U+02C3	MODIFIER LETTER RIGHT ARROWHEAD
+	U_MODIFIER_LETTER_UP_ARROWHEAD = 0x02C4,				// U+02C4	MODIFIER LETTER UP ARROWHEAD
+	U_MODIFIER_LETTER_DOWN_ARROWHEAD = 0x02C5,				// U+02C5	MODIFIER LETTER DOWN ARROWHEAD
+	U_MODIFIER_LETTER_CENTRED_RIGHT_HALF_RING = 0x02D2,		// U+02D2	MODIFIER LETTER CENTRED RIGHT HALF RING
+	U_MODIFIER_LETTER_CENTRED_LEFT_HALF_RING = 0x02D3,		// U+02D3	MODIFIER LETTER CENTRED LEFT HALF RING
+	U_MODIFIER_LETTER_UP_TACK = 0x02D4,						// U+02D4	MODIFIER LETTER UP TACK
+	U_MODIFIER_LETTER_DOWN_TACK = 0x02D5,					// U+02D5	MODIFIER LETTER DOWN TACK
+	U_MODIFIER_LETTER_PLUS_SIGN = 0x02D6,					// U+02D6	MODIFIER LETTER PLUS SIGN
+	U_MODIFIER_LETTER_MINUS_SIGN = 0x02D7,					// U+02D7	MODIFIER LETTER MINUS SIGN
+	U_BREVE = 0x02D8,										// U+02D8	BREVE
+	U_DOT_ABOVE = 0x02D9,									// U+02D9	DOT ABOVE
+	U_RING_ABOVE = 0x02DA,									// U+02DA	RING ABOVE
+	U_OGONEK = 0x02DB,										// U+02DB	OGONEK
+	U_SMALL_TILDE = 0x02DC,									// U+02DC	SMALL TILDE
+	U_DOUBLE_ACUTE_ACCENT = 0x02DD,							// U+02DD	DOUBLE ACUTE ACCENT
+	U_MODIFIER_LETTER_RHOTIC_HOOK = 0x02DE,					// U+02DE	MODIFIER LETTER RHOTIC HOOK
+	U_MODIFIER_LETTER_CROSS_ACCENT = 0x02DF,				// U+02DF	MODIFIER LETTER CROSS ACCENT
+	U_MODIFIER_LETTER_EXTRA_HIGH_TONE_BAR = 0x02E5,			// U+02E5	MODIFIER LETTER EXTRA-HIGH TONE BAR
+	U_MODIFIER_LETTER_HIGH_TONE_BAR = 0x02E6,				// U+02E6	MODIFIER LETTER HIGH TONE BAR
+	U_MODIFIER_LETTER_MID_TONE_BAR = 0x02E7,				// U+02E7	MODIFIER LETTER MID TONE BAR
+	U_MODIFIER_LETTER_LOW_TONE_BAR = 0x02E8,				// U+02E8	MODIFIER LETTER LOW TONE BAR
+	U_MODIFIER_LETTER_EXTRA_LOW_TONE_BAR = 0x02E9,			// U+02E9	MODIFIER LETTER EXTRA-LOW TONE BAR
+	U_MODIFIER_LETTER_YIN_DEPARTING_TONE_MARK = 0x02EA,		// U+02EA	MODIFIER LETTER YIN DEPARTING TONE MARK
+	U_MODIFIER_LETTER_YANG_DEPARTING_TONE_MARK = 0x02EB,	// U+02EB	MODIFIER LETTER YANG DEPARTING TONE MARK
+	U_MODIFIER_LETTER_UNASPIRATED = 0x02ED,					// U+02ED	MODIFIER LETTER UNASPIRATED
+	U_MODIFIER_LETTER_LOW_DOWN_ARROWHEAD = 0x02EF,			// U+02EF	MODIFIER LETTER LOW DOWN ARROWHEAD
+	U_MODIFIER_LETTER_LOW_UP_ARROWHEAD = 0x02F0,			// U+02F0	MODIFIER LETTER LOW UP ARROWHEAD
+	U_MODIFIER_LETTER_LOW_LEFT_ARROWHEAD = 0x02F1,			// U+02F1	MODIFIER LETTER LOW LEFT ARROWHEAD
+	U_MODIFIER_LETTER_LOW_RIGHT_ARROWHEAD = 0x02F2,			// U+02F2	MODIFIER LETTER LOW RIGHT ARROWHEAD
+	U_MODIFIER_LETTER_LOW_RING = 0x02F3,					// U+02F3	MODIFIER LETTER LOW RING
+	U_MODIFIER_LETTER_MIDDLE_GRAVE_ACCENT = 0x02F4,			// U+02F4	MODIFIER LETTER MIDDLE GRAVE ACCENT
+	U_MODIFIER_LETTER_MIDDLE_DOUBLE_GRAVE_ACCENT = 0x02F5,	// U+02F5	MODIFIER LETTER MIDDLE DOUBLE GRAVE ACCENT
+	U_MODIFIER_LETTER_MIDDLE_DOUBLE_ACUTE_ACCENT = 0x02F6,	// U+02F6	MODIFIER LETTER MIDDLE DOUBLE ACUTE ACCENT
+	U_MODIFIER_LETTER_LOW_TILDE = 0x02F7,					// U+02F7	MODIFIER LETTER LOW TILDE
+	U_MODIFIER_LETTER_RAISED_COLON = 0x02F8,				// U+02F8	MODIFIER LETTER RAISED COLON
+	U_MODIFIER_LETTER_BEGIN_HIGH_TONE = 0x02F9,				// U+02F9	MODIFIER LETTER BEGIN HIGH TONE
+	U_MODIFIER_LETTER_END_HIGH_TONE = 0x02FA,				// U+02FA	MODIFIER LETTER END HIGH TONE
+	U_MODIFIER_LETTER_BEGIN_LOW_TONE = 0x02FB,				// U+02FB	MODIFIER LETTER BEGIN LOW TONE
+	U_MODIFIER_LETTER_END_LOW_TONE = 0x02FC,				// U+02FC	MODIFIER LETTER END LOW TONE
+	U_MODIFIER_LETTER_SHELF = 0x02FD,						// U+02FD	MODIFIER LETTER SHELF
+	U_MODIFIER_LETTER_OPEN_SHELF = 0x02FE,					// U+02FE	MODIFIER LETTER OPEN SHELF
+	U_MODIFIER_LETTER_LOW_LEFT_ARROW = 0x02FF,				// U+02FF	MODIFIER LETTER LOW LEFT ARROW
+	U_GREEK_LOWER_NUMERAL_SIGN = 0x0375,					// U+0375	GREEK LOWER NUMERAL SIGN
+	U_GREEK_TONOS = 0x0384,									// U+0384	GREEK TONOS
+	U_GREEK_DIALYTIKA_TONOS = 0x0385,						// U+0385	GREEK DIALYTIKA TONOS
+	U_GREEK_KORONIS = 0x1FBD,								// U+1FBD	GREEK KORONIS
+	U_GREEK_PSILI = 0x1FBF,									// U+1FBF	GREEK PSILI
+	U_GREEK_PERISPOMENI = 0x1FC0,							// U+1FC0	GREEK PERISPOMENI
+	U_GREEK_DIALYTIKA_AND_PERISPOMENI = 0x1FC1,				// U+1FC1	GREEK DIALYTIKA AND PERISPOMENI
+	U_GREEK_PSILI_AND_VARIA = 0x1FCD,						// U+1FCD	GREEK PSILI AND VARIA
+	U_GREEK_PSILI_AND_OXIA = 0x1FCE,						// U+1FCE	GREEK PSILI AND OXIA
+	U_GREEK_PSILI_AND_PERISPOMENI = 0x1FCF,					// U+1FCF	GREEK PSILI AND PERISPOMENI
+	U_GREEK_DASIA_AND_VARIA = 0x1FDD,						// U+1FDD	GREEK DASIA AND VARIA
+	U_GREEK_DASIA_AND_OXIA = 0x1FDE,						// U+1FDE	GREEK DASIA AND OXIA
+	U_GREEK_DASIA_AND_PERISPOMENI = 0x1FDF,					// U+1FDF	GREEK DASIA AND PERISPOMENI
+	U_GREEK_DIALYTIKA_AND_VARIA = 0x1FED,					// U+1FED	GREEK DIALYTIKA AND VARIA
+	U_GREEK_DIALYTIKA_AND_OXIA = 0x1FEE,					// U+1FEE	GREEK DIALYTIKA AND OXIA
+	U_GREEK_VARIA = 0x1FEF,									// U+1FEF	GREEK VARIA
+	U_GREEK_OXIA = 0x1FFD,									// U+1FFD	GREEK OXIA
+	U_GREEK_DASIA = 0x1FFE,									// U+1FFE	GREEK DASIA
+
+
+	U_OVERLINE = 0x203E, // Unicode Character 'OVERLINE'
+
+	/**
+	 * UTF-8 BOM
+	 * Unicode Character 'ZERO WIDTH NO-BREAK SPACE' (U+FEFF)
+	 * http://www.fileformat.info/info/unicode/char/feff/index.htm
+	 */
+	UTF8_BOM = 65279
+}
diff --git a/src/test/mocks/vsc/index.ts b/src/test/mocks/vsc/index.ts
index 117fa5e8b4d6..c7df9e7c2148 100644
--- a/src/test/mocks/vsc/index.ts
+++ b/src/test/mocks/vsc/index.ts
@@ -11,53 +11,11 @@ import * as vscode from 'vscode';
 // export * from './position';
 // export * from './selection';
 export * from './extHostedTypes';
+export * from './uri';
 
 export namespace vscMock {
-    // This is one of the very few classes that we need in our unit tests.
-    // It is constructed in a number of places, and this is required for verification.
-    // Using mocked objects for verfications does not work in typemoq.
-    export class Uri implements vscode.Uri {
-        private static _regexp = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
-        private static _empty = '';
-
-        private constructor(
-            public readonly scheme: string,
-            public readonly authority: string,
-            public readonly path: string,
-            public readonly query: string,
-            public readonly fragment: string,
-            public readonly fsPath: string
-        ) {}
-        public static file(path: string): Uri {
-            return new Uri('file', '', path, '', '', path);
-        }
-        public static parse(value: string): Uri {
-            const match = this._regexp.exec(value);
-            if (!match) {
-                return new Uri('', '', '', '', '', '');
-            }
-            return new Uri(
-                match[2] || this._empty,
-                decodeURIComponent(match[4] || this._empty),
-                decodeURIComponent(match[5] || this._empty),
-                decodeURIComponent(match[7] || this._empty),
-                decodeURIComponent(match[9] || this._empty),
-                decodeURIComponent(match[5] || this._empty)
-            );
-        }
-        public with(_change: { scheme?: string; authority?: string; path?: string; query?: string; fragment?: string }): vscode.Uri {
-            throw new Error('Not implemented');
-        }
-        public toString(_skipEncoding?: boolean): string {
-            return this.fsPath;
-        }
-        public toJSON(): any {
-            return this.fsPath;
-        }
-    }
-
     export class Disposable {
-        constructor(private callOnDispose: Function) {}
+        constructor(private callOnDispose: Function) { }
         public dispose(): any {
             if (this.callOnDispose) {
                 this.callOnDispose();
@@ -195,7 +153,7 @@ export namespace vscMock {
         public static readonly SourceOrganizeImports: CodeActionKind = new CodeActionKind('source.organize.imports');
         public static readonly SourceFixAll: CodeActionKind = new CodeActionKind('source.fix.all');
 
-        private constructor(private _value: string) {}
+        private constructor(private _value: string) { }
 
         public append(parts: string): CodeActionKind {
             return new CodeActionKind(`${this._value}.${parts}`);
@@ -220,9 +178,9 @@ export namespace vscMock {
     }
 
     export class DebugAdapterServer {
-        constructor(public readonly port: number, public readonly host?: string) {}
+        constructor(public readonly port: number, public readonly host?: string) { }
     }
     export class DebugAdapterExecutable {
-        constructor(public readonly command: string, public readonly args: string[] = [], public readonly options?: DebugAdapterExecutableOptions) {}
+        constructor(public readonly command: string, public readonly args: string[] = [], public readonly options?: DebugAdapterExecutableOptions) { }
     }
 }
diff --git a/src/test/mocks/vsc/uri.ts b/src/test/mocks/vsc/uri.ts
index 0e7613d2bae5..9ccadab42f39 100644
--- a/src/test/mocks/vsc/uri.ts
+++ b/src/test/mocks/vsc/uri.ts
@@ -4,32 +4,43 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-export namespace vscUri {
-    const platform = {
-        isWindows: /^win/.test(process.platform)
-    };
+/* tslint:disable */
 
-    // tslint:disable:all
+import { CharCode } from './charCode';
 
-    function _encode(ch: string): string {
-        return '%' + ch.charCodeAt(0).toString(16).toUpperCase();
-    }
+export namespace vscUri {
+    const isWindows = /^win/.test(process.platform);
+    /*---------------------------------------------------------------------------------------------
+    *  Copyright (c) Microsoft Corporation. All rights reserved.
+    *  Licensed under the MIT License. See License.txt in the project root for license information.
+    *--------------------------------------------------------------------------------------------*/
 
-    // see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent
-    function encodeURIComponent2(str: string): string {
-        return encodeURIComponent(str).replace(/[!'()*]/g, _encode);
-    }
+    const _schemePattern = /^\w[\w\d+.-]*$/;
+    const _singleSlashStart = /^\//;
+    const _doubleSlashStart = /^\/\//;
 
-    function encodeNoop(str: string): string {
-        return str.replace(/[#?]/, _encode);
+    let _throwOnMissingSchema: boolean = true;
+
+    /**
+     * @internal
+     */
+    export function setUriThrowOnMissingScheme(value: boolean): boolean {
+        const old = _throwOnMissingSchema;
+        _throwOnMissingSchema = value;
+        return old;
     }
 
+    function _validateUri(ret: URI, _strict?: boolean): void {
 
-    const _schemePattern = /^\w[\w\d+.-]*$/;
-    const _singleSlashStart = /^\//;
-    const _doubleSlashStart = /^\/\//;
+        // scheme, must be set
+        // if (!ret.scheme) {
+        //     // if (_strict || _throwOnMissingSchema) {
+        //     //     throw new Error(`[UriError]: Scheme is missing: {scheme: "", authority: "${ret.authority}", path: "${ret.path}", query: "${ret.query}", fragment: "${ret.fragment}"}`);
+        //     // } else {
+        //     console.warn(`[UriError]: Scheme is missing: {scheme: "", authority: "${ret.authority}", path: "${ret.path}", query: "${ret.query}", fragment: "${ret.fragment}"}`);
+        //     // }
+        // }
 
-    function _validateUri(ret: URI): void {
         // scheme, https://tools.ietf.org/html/rfc3986#section-3.1
         // ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
         if (ret.scheme && !_schemePattern.test(ret.scheme)) {
@@ -54,16 +65,50 @@ export namespace vscUri {
         }
     }
 
+    // for a while we allowed uris *without* schemes and this is the migration
+    // for them, e.g. an uri without scheme and without strict-mode warns and falls
+    // back to the file-scheme. that should cause the least carnage and still be a
+    // clear warning
+    function _schemeFix(scheme: string, _strict: boolean): string {
+        if (_strict || _throwOnMissingSchema) {
+            return scheme || _empty;
+        }
+        if (!scheme) {
+            // tslint:disable-next-line: no-console
+            console.trace('BAD uri lacks scheme, falling back to file-scheme.');
+            scheme = 'file';
+        }
+        return scheme;
+    }
+
+    // implements a bit of https://tools.ietf.org/html/rfc3986#section-5
+    function _referenceResolution(scheme: string, path: string): string {
+
+        // the slash-character is our 'default base' as we don't
+        // support constructing URIs relative to other URIs. This
+        // also means that we alter and potentially break paths.
+        // see https://tools.ietf.org/html/rfc3986#section-5.1.4
+        switch (scheme) {
+            case 'https':
+            case 'http':
+            case 'file':
+                if (!path) {
+                    path = _slash;
+                } else if (path[0] !== _slash) {
+                    path = _slash + path;
+                }
+                break;
+        }
+        return path;
+    }
+
     const _empty = '';
     const _slash = '/';
     const _regexp = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
-    const _driveLetterPath = /^\/[a-zA-Z]:/;
-    const _upperCaseDrive = /^(\/)?([A-Z]:)/;
-    const _driveLetter = /^[a-zA-Z]:/;
 
     /**
      * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.
-     * This class is a simple parser which creates the basic component paths
+     * This class is a simple parser which creates the basic component parts
      * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation
      * and encoding.
      *
@@ -74,9 +119,8 @@ export namespace vscUri {
      *        |   _____________________|__
      *       / \ /                        \
      *       urn:example:animal:ferret:nose
-     *
-     *
      */
+    // tslint:disable-next-line: no-use-before-declare
     export class URI implements UriComponents {
 
         static isUri(thing: any): thing is URI {
@@ -90,7 +134,10 @@ export namespace vscUri {
                 && typeof (<URI>thing).fragment === 'string'
                 && typeof (<URI>thing).path === 'string'
                 && typeof (<URI>thing).query === 'string'
-                && typeof (<URI>thing).scheme === 'string';
+                && typeof (<URI>thing).scheme === 'string'
+                && typeof (<URI>thing).fsPath === 'function'
+                && typeof (<URI>thing).with === 'function'
+                && typeof (<URI>thing).toString === 'function';
         }
 
         /**
@@ -123,7 +170,7 @@ export namespace vscUri {
         /**
          * @internal
          */
-        protected constructor(scheme: string, authority: string, path: string, query: string, fragment: string);
+        protected constructor(scheme: string, authority?: string, path?: string, query?: string, fragment?: string, _strict?: boolean);
 
         /**
          * @internal
@@ -133,7 +180,7 @@ export namespace vscUri {
         /**
          * @internal
          */
-        protected constructor(schemeOrData: string | UriComponents, authority?: string, path?: string, query?: string, fragment?: string) {
+        protected constructor(schemeOrData: string | UriComponents, authority?: string, path?: string, query?: string, fragment?: string, _strict: boolean = false) {
 
             if (typeof schemeOrData === 'object') {
                 this.scheme = schemeOrData.scheme || _empty;
@@ -145,12 +192,13 @@ export namespace vscUri {
                 // that creates uri components.
                 // _validateUri(this);
             } else {
-                this.scheme = schemeOrData || _empty;
+                this.scheme = _schemeFix(schemeOrData, _strict);
                 this.authority = authority || _empty;
-                this.path = path || _empty;
+                this.path = _referenceResolution(this.scheme, path || _empty);
                 this.query = query || _empty;
                 this.fragment = fragment || _empty;
-                _validateUri(this);
+
+                _validateUri(this, _strict);
             }
         }
 
@@ -158,44 +206,65 @@ export namespace vscUri {
 
         /**
          * Returns a string representing the corresponding file system path of this URI.
-         * Will handle UNC paths and normalize windows drive letters to lower-case. Also
-         * uses the platform specific path separator. Will *not* validate the path for
-         * invalid characters and semantics. Will *not* look at the scheme of this URI.
-         */
+         * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the
+         * platform specific path separator.
+         *
+         * * Will *not* validate the path for invalid characters and semantics.
+         * * Will *not* look at the scheme of this URI.
+         * * The result shall *not* be used for display purposes but for accessing a file on disk.
+         *
+         *
+         * The *difference* to `URI#path` is the use of the platform specific separator and the handling
+         * of UNC paths. See the below sample of a file-uri with an authority (UNC path).
+         *
+         * ```ts
+            const u = URI.parse('file://server/c$/folder/file.txt')
+            u.authority === 'server'
+            u.path === '/shares/c$/file.txt'
+            u.fsPath === '\\server\c$\folder\file.txt'
+        ```
+        *
+        * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,
+        * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working
+        * with URIs that represent files on disk (`file` scheme).
+        */
         get fsPath(): string {
+            // if (this.scheme !== 'file') {
+            // 	console.warn(`[UriError] calling fsPath with scheme ${this.scheme}`);
+            // }
             return _makeFsPath(this);
         }
 
         // ---- modify to new -------------------------
 
-        public with(change: { scheme?: string; authority?: string; path?: string; query?: string; fragment?: string }): URI {
+        with(change: { scheme?: string; authority?: string | null; path?: string | null; query?: string | null; fragment?: string | null }): URI {
 
             if (!change) {
                 return this;
             }
 
             let { scheme, authority, path, query, fragment } = change;
-            if (scheme === void 0) {
+            if (scheme === undefined) {
                 scheme = this.scheme;
             } else if (scheme === null) {
                 scheme = _empty;
             }
-            if (authority === void 0) {
+            if (authority === undefined) {
                 authority = this.authority;
             } else if (authority === null) {
                 authority = _empty;
             }
-            if (path === void 0) {
+            if (path === undefined) {
                 path = this.path;
             } else if (path === null) {
                 path = _empty;
             }
-            if (query === void 0) {
+            if (query === undefined) {
                 query = this.query;
             } else if (query === null) {
                 query = _empty;
             }
-            if (fragment === void 0) {
+            if (fragment === undefined) {
                 fragment = this.fragment;
             } else if (fragment === null) {
                 fragment = _empty;
@@ -215,7 +284,13 @@ export namespace vscUri {
 
         // ---- parse & validate ------------------------
 
-        public static parse(value: string): URI {
+        /**
+         * Creates a new URI from a string, e.g. `http://www.msft.com/some/path`,
+         * `file:///usr/home`, or `scheme:with/path`.
+         *
+         * @param value A string which represents an URI (see `URI#toString`).
+         */
+        static parse(value: string, _strict: boolean = false): URI {
             const match = _regexp.exec(value);
             if (!match) {
                 return new _URI(_empty, _empty, _empty, _empty, _empty);
@@ -226,24 +301,46 @@ export namespace vscUri {
                 decodeURIComponent(match[5] || _empty),
                 decodeURIComponent(match[7] || _empty),
                 decodeURIComponent(match[9] || _empty),
+                _strict
             );
         }
 
-        public static file(path: string): URI {
+        /**
+         * Creates a new URI from a file system path, e.g. `c:\my\files`,
+         * `/usr/home`, or `\\server\share\some\path`.
+         *
+         * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument
+         * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**
+         * `URI.parse('file://' + path)` because the path might contain characters that are
+         * interpreted (# and ?). See the following sample:
+         * ```ts
+        const good = URI.file('/coding/c#/project1');
+        good.scheme === 'file';
+        good.path === '/coding/c#/project1';
+        good.fragment === '';
+        const bad = URI.parse('file://' + '/coding/c#/project1');
+        bad.scheme === 'file';
+        bad.path === '/coding/c'; // path is now broken
+        bad.fragment === '/project1';
+        ```
+        *
+        * @param path A file system path (see `URI#fsPath`)
+        */
+        static file(path: string): URI {
 
             let authority = _empty;
 
             // normalize to fwd-slashes on windows,
             // on other systems bwd-slashes are valid
             // filename character, eg /f\oo/ba\r.txt
-            if (platform.isWindows) {
+            if (isWindows) {
                 path = path.replace(/\\/g, _slash);
             }
 
             // check for authority as used in UNC shares
             // or use the path as given
             if (path[0] === _slash && path[1] === _slash) {
-                let idx = path.indexOf(_slash, 2);
+                const idx = path.indexOf(_slash, 2);
                 if (idx === -1) {
                     authority = path.substring(2);
                     path = _slash;
@@ -253,24 +350,11 @@ export namespace vscUri {
                 }
             }
 
-            // Ensure that path starts with a slash
-            // or that it is at least a slash
-            if (_driveLetter.test(path)) {
-                path = _slash + path;
-
-            } else if (path[0] !== _slash) {
-                // tricky -> makes invalid paths
-                // but otherwise we have to stop
-                // allowing relative paths...
-                path = _slash + path;
-            }
-
             return new _URI('file', authority, path, _empty, _empty);
         }
 
-        public static from(components: { scheme?: string; authority?: string; path?: string; query?: string; fragment?: string }): URI {
+        static from(components: { scheme: string; authority?: string; path?: string; query?: string; fragment?: string }): URI {
             return new _URI(
-                // @ts-ignore
                 components.scheme,
                 components.authority,
                 components.path,
@@ -282,52 +366,37 @@ export namespace vscUri {
         // ---- printing/externalize ---------------------------
 
         /**
+         * Creates a string representation for this URI. It's guaranteed that calling
+         * `URI.parse` with the result of this function creates an URI which is equal
+         * to this URI.
+         *
+         * * The result shall *not* be used for display purposes but for externalization or transport.
+         * * The result will be encoded using the percentage encoding and encoding happens mostly
+         * ignore the scheme-specific encoding rules.
          *
          * @param skipEncoding Do not encode the result, default is `false`
          */
-        public toString(skipEncoding: boolean = false): string {
+        toString(skipEncoding: boolean = false): string {
             return _asFormatted(this, skipEncoding);
         }
 
-        public toJSON(): object {
-            const res = <UriState>{
-                $mid: 1,
-                fsPath: this.fsPath,
-                external: this.toString(),
-            };
-
-            if (this.path) {
-                res.path = this.path;
-            }
-
-            if (this.scheme) {
-                res.scheme = this.scheme;
-            }
-
-            if (this.authority) {
-                res.authority = this.authority;
-            }
-
-            if (this.query) {
-                res.query = this.query;
-            }
-
-            if (this.fragment) {
-                res.fragment = this.fragment;
-            }
-
-            return res;
+        toJSON(): UriComponents {
+            return this;
         }
 
-        static revive(data: UriComponents | any): URI {
+        static revive(data: UriComponents | URI): URI;
+        static revive(data: UriComponents | URI | undefined): URI | undefined;
+        static revive(data: UriComponents | URI | null): URI | null;
+        static revive(data: UriComponents | URI | undefined | null): URI | undefined | null;
+        static revive(data: UriComponents | URI | undefined | null): URI | undefined | null {
             if (!data) {
                 return data;
             } else if (data instanceof URI) {
                 return data;
             } else {
-                let result = new _URI(data);
-                result._fsPath = (<UriState>data).fsPath;
+                const result = new _URI(data);
                 result._formatted = (<UriState>data).external;
+                result._fsPath = (<UriState>data)._sep === _pathSepMarker ? (<UriState>data).fsPath : null;
                 return result;
             }
         }
@@ -343,18 +412,22 @@ export namespace vscUri {
 
     interface UriState extends UriComponents {
         $mid: number;
-        fsPath: string;
         external: string;
+        fsPath: string;
+        _sep: 1 | undefined;
     }
 
+    const _pathSepMarker = isWindows ? 1 : undefined;
 
     // tslint:disable-next-line:class-name
     class _URI extends URI {
-        // @ts-ignore
-        _formatted: string = null;
-        // @ts-ignore
-        _fsPath: string = null;
 
+        _formatted: string | null = null;
+        _fsPath: string | null = null;
+        constructor(schemeOrData: string | UriComponents, authority?: string, path?: string, query?: string, fragment?: string, _strict: boolean = false) {
+            super(schemeOrData as any, authority, path, query, fragment, _strict);
+            this._fsPath = this.fsPath;
+        }
         get fsPath(): string {
             if (!this._fsPath) {
                 this._fsPath = _makeFsPath(this);
@@ -362,7 +435,7 @@ export namespace vscUri {
             return this._fsPath;
         }
 
-        public toString(skipEncoding: boolean = false): string {
+        toString(skipEncoding: boolean = false): string {
             if (!skipEncoding) {
                 if (!this._formatted) {
                     this._formatted = _asFormatted(this, false);
@@ -373,27 +446,166 @@ export namespace vscUri {
                 return _asFormatted(this, true);
             }
         }
+
+        toJSON(): UriComponents {
+            const res = <UriState>{
+                $mid: 1
+            };
+            // cached state
+            if (this._fsPath) {
+                res.fsPath = this._fsPath;
+                if (_pathSepMarker){
+                    res._sep = _pathSepMarker;
+                }
+            }
+            if (this._formatted) {
+                res.external = this._formatted;
+            }
+            // uri components
+            if (this.path) {
+                res.path = this.path;
+            }
+            if (this.scheme) {
+                res.scheme = this.scheme;
+            }
+            if (this.authority) {
+                res.authority = this.authority;
+            }
+            if (this.query) {
+                res.query = this.query;
+            }
+            if (this.fragment) {
+                res.fragment = this.fragment;
+            }
+            return res;
+        }
+    }
+
+    // reserved characters: https://tools.ietf.org/html/rfc3986#section-2.2
+    const encodeTable: { [ch: number]: string } = {
+        [CharCode.Colon]: '%3A', // gen-delims
+        [CharCode.Slash]: '%2F',
+        [CharCode.QuestionMark]: '%3F',
+        [CharCode.Hash]: '%23',
+        [CharCode.OpenSquareBracket]: '%5B',
+        [CharCode.CloseSquareBracket]: '%5D',
+        [CharCode.AtSign]: '%40',
+
+        [CharCode.ExclamationMark]: '%21', // sub-delims
+        [CharCode.DollarSign]: '%24',
+        [CharCode.Ampersand]: '%26',
+        [CharCode.SingleQuote]: '%27',
+        [CharCode.OpenParen]: '%28',
+        [CharCode.CloseParen]: '%29',
+        [CharCode.Asterisk]: '%2A',
+        [CharCode.Plus]: '%2B',
+        [CharCode.Comma]: '%2C',
+        [CharCode.Semicolon]: '%3B',
+        [CharCode.Equals]: '%3D',
+
+        [CharCode.Space]: '%20',
+    };
+
+    function encodeURIComponentFast(uriComponent: string, allowSlash: boolean): string {
+        let res: string | undefined = undefined;
+        let nativeEncodePos = -1;
+
+        for (let pos = 0; pos < uriComponent.length; pos++) {
+            const code = uriComponent.charCodeAt(pos);
+
+            // unreserved characters: https://tools.ietf.org/html/rfc3986#section-2.3
+            if (
+                (code >= CharCode.a && code <= CharCode.z)
+                || (code >= CharCode.A && code <= CharCode.Z)
+                || (code >= CharCode.Digit0 && code <= CharCode.Digit9)
+                || code === CharCode.Dash
+                || code === CharCode.Period
+                || code === CharCode.Underline
+                || code === CharCode.Tilde
+                || (allowSlash && code === CharCode.Slash)
+            ) {
+                // check if we are delaying native encode
+                if (nativeEncodePos !== -1) {
+                    res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));
+                    nativeEncodePos = -1;
+                }
+                // check if we write into a new string (by default we try to return the param)
+                if (res !== undefined) {
+                    res += uriComponent.charAt(pos);
+                }
+
+            } else {
+                // encoding needed, we need to allocate a new string
+                if (res === undefined) {
+                    res = uriComponent.substr(0, pos);
+                }
+
+                // check with default table first
+                const escaped = encodeTable[code];
+                if (escaped !== undefined) {
+
+                    // check if we are delaying native encode
+                    if (nativeEncodePos !== -1) {
+                        res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));
+                        nativeEncodePos = -1;
+                    }
+
+                    // append escaped variant to result
+                    res += escaped;
+
+                } else if (nativeEncodePos === -1) {
+                    // use native encode only when needed
+                    nativeEncodePos = pos;
+                }
+            }
+        }
+
+        if (nativeEncodePos !== -1) {
+            res += encodeURIComponent(uriComponent.substring(nativeEncodePos));
+        }
+
+        return res !== undefined ? res : uriComponent;
     }
 
+    function encodeURIComponentMinimal(path: string): string {
+        let res: string | undefined = undefined;
+        for (let pos = 0; pos < path.length; pos++) {
+            const code = path.charCodeAt(pos);
+            if (code === CharCode.Hash || code === CharCode.QuestionMark) {
+                if (res === undefined) {
+                    res = path.substr(0, pos);
+                }
+                res += encodeTable[code];
+            } else {
+                if (res !== undefined) {
+                    res += path[pos];
+                }
+            }
+        }
+        return res !== undefined ? res : path;
+    }
 
     /**
      * Compute `fsPath` for the given uri
-     * @param uri
      */
     function _makeFsPath(uri: URI): string {
 
         let value: string;
-        if (uri.authority && uri.path && uri.scheme === 'file') {
+        if (uri.authority && uri.path.length > 1 && uri.scheme === 'file') {
             // unc path: file://shares/c$/far/boo
             value = `//${uri.authority}${uri.path}`;
-        } else if (_driveLetterPath.test(uri.path)) {
+        } else if (
+            uri.path.charCodeAt(0) === CharCode.Slash
+            && (uri.path.charCodeAt(1) >= CharCode.A && uri.path.charCodeAt(1) <= CharCode.Z || uri.path.charCodeAt(1) >= CharCode.a && uri.path.charCodeAt(1) <= CharCode.z)
+            && uri.path.charCodeAt(2) === CharCode.Colon
+        ) {
             // windows drive letter: file:///c:/far/boo
             value = uri.path[1].toLowerCase() + uri.path.substr(2);
         } else {
             // other path
             value = uri.path;
         }
-        if (platform.isWindows) {
+        if (isWindows) {
             value = value.replace(/\//g, '\\');
         }
         return value;
@@ -405,72 +617,70 @@ export namespace vscUri {
     function _asFormatted(uri: URI, skipEncoding: boolean): string {
 
         const encoder = !skipEncoding
-            ? encodeURIComponent2
-            : encodeNoop;
-
-        const parts: string[] = [];
+            ? encodeURIComponentFast
+            : encodeURIComponentMinimal;
 
+        let res = '';
         let { scheme, authority, path, query, fragment } = uri;
         if (scheme) {
-            parts.push(scheme, ':');
+            res += scheme;
+            res += ':';
         }
         if (authority || scheme === 'file') {
-            parts.push('//');
+            res += _slash;
+            res += _slash;
         }
         if (authority) {
             let idx = authority.indexOf('@');
             if (idx !== -1) {
+                // <user>@<auth>
                 const userinfo = authority.substr(0, idx);
                 authority = authority.substr(idx + 1);
                 idx = userinfo.indexOf(':');
                 if (idx === -1) {
-                    parts.push(encoder(userinfo));
+                    res += encoder(userinfo, false);
                 } else {
-                    parts.push(encoder(userinfo.substr(0, idx)), ':', encoder(userinfo.substr(idx + 1)));
+                    // <user>:<pass>@<auth>
+                    res += encoder(userinfo.substr(0, idx), false);
+                    res += ':';
+                    res += encoder(userinfo.substr(idx + 1), false);
                 }
-                parts.push('@');
+                res += '@';
             }
             authority = authority.toLowerCase();
             idx = authority.indexOf(':');
             if (idx === -1) {
-                parts.push(encoder(authority));
+                res += encoder(authority, false);
             } else {
-                parts.push(encoder(authority.substr(0, idx)), authority.substr(idx));
+                // <auth>:<port>
+                res += encoder(authority.substr(0, idx), false);
+                res += authority.substr(idx);
             }
         }
         if (path) {
             // lower-case windows drive letters in /C:/fff or C:/fff
-            const m = _upperCaseDrive.exec(path);
-            if (m) {
-                if (m[1]) {
-                    path = '/' + m[2].toLowerCase() + path.substr(3); // "/c:".length === 3
-                } else {
-                    path = m[2].toLowerCase() + path.substr(2); // // "c:".length === 2
+            if (path.length >= 3 && path.charCodeAt(0) === CharCode.Slash && path.charCodeAt(2) === CharCode.Colon) {
+                const code = path.charCodeAt(1);
+                if (code >= CharCode.A && code <= CharCode.Z) {
+                    path = `/${String.fromCharCode(code + 32)}:${path.substr(3)}`; // "/c:".length === 3
                 }
-            }
-
-            // encode every segement but not slashes
-            // make sure that # and ? are always encoded
-            // when occurring in paths - otherwise the result
-            // cannot be parsed back again
-            let lastIdx = 0;
-            while (true) {
-                let idx = path.indexOf(_slash, lastIdx);
-                if (idx === -1) {
-                    parts.push(encoder(path.substring(lastIdx)));
-                    break;
+            } else if (path.length >= 2 && path.charCodeAt(1) === CharCode.Colon) {
+                const code = path.charCodeAt(0);
+                if (code >= CharCode.A && code <= CharCode.Z) {
+                    path = `${String.fromCharCode(code + 32)}:${path.substr(2)}`; // "/c:".length === 3
                 }
-                parts.push(encoder(path.substring(lastIdx, idx)), _slash);
-                lastIdx = idx + 1;
             }
+            // encode the rest of the path
+            res += encoder(path, true);
         }
         if (query) {
-            parts.push('?', encoder(query));
+            res += '?';
+            res += encoder(query, false);
         }
         if (fragment) {
-            parts.push('#', encoder(fragment));
+            res += '#';
+            res += !skipEncoding ? encodeURIComponentFast(fragment, false) : fragment;
         }
-
-        return parts.join(_empty);
+        return res;
     }
 }
diff --git a/src/test/testing/codeLenses/testFiles.unit.test.ts b/src/test/testing/codeLenses/testFiles.unit.test.ts
index ce262c9d3d4b..0c7d4c8e1561 100644
--- a/src/test/testing/codeLenses/testFiles.unit.test.ts
+++ b/src/test/testing/codeLenses/testFiles.unit.test.ts
@@ -126,29 +126,29 @@ suite('Code lenses - Test files', () => {
         const workspaceUri = Uri.file('path/to/workspace');
         const workspace = { uri: workspaceUri };
         const testFile2 = {
-            fullPath: 'path/to/document2'
+            fullPath: Uri.file('path/to/document2').fsPath
         };
         const tests = {
             testFiles: [
                 {
-                    fullPath: 'path/to/document1'
+                    fullPath: Uri.file('path/to/document1').fsPath
                 },
                 testFile2
             ]
         };
         workspaceService
-            .setup(w => w.getWorkspaceFolder(document.uri))
+            .setup(w => w.getWorkspaceFolder(typemoq.It.isValue(document.uri)))
             .returns(() => workspace as any)
             .verifiable(typemoq.Times.once());
         testCollectionStorage
-            .setup(w => w.getTests(workspaceUri))
+            .setup(w => w.getTests(typemoq.It.isValue(workspaceUri)))
             .returns(() => tests as any)
             .verifiable(typemoq.Times.once());
         fileSystem
-            .setup(f => f.arePathsSame('path/to/document1', 'path/to/document2'))
+            .setup(f => f.arePathsSame(Uri.file('/path/to/document1').fsPath, Uri.file('/path/to/document2').fsPath))
             .returns(() => false);
         fileSystem
-            .setup(f => f.arePathsSame('path/to/document2', 'path/to/document2'))
+            .setup(f => f.arePathsSame(Uri.file('/path/to/document2').fsPath, Uri.file('/path/to/document2').fsPath))
             .returns(() => true);
         const files = codeLensProvider.getTestFileWhichNeedsCodeLens(document as any);
         assert.deepEqual(files, testFile2 as any);
diff --git a/src/test/testing/pytest/services/discoveryService.unit.test.ts b/src/test/testing/pytest/services/discoveryService.unit.test.ts
index 15365a209a60..8ba0fc3df5a1 100644
--- a/src/test/testing/pytest/services/discoveryService.unit.test.ts
+++ b/src/test/testing/pytest/services/discoveryService.unit.test.ts
@@ -45,7 +45,7 @@ suite('Unit Tests - PyTest - Discovery', () => {
     test('Ensure discovery is invoked when there are no test directories', async () => {
         const options: TestDiscoveryOptions = {
             args: ['some args'],
-            cwd: __dirname,
+            cwd: Uri.file(__dirname).fsPath,
             ignoreCache: true,
             outChannel: new MockOutputChannel('Tests'),
             token: new CancellationTokenSource().token,
@@ -64,7 +64,7 @@ suite('Unit Tests - PyTest - Discovery', () => {
     test('Ensure discovery is invoked when there are multiple test directories', async () => {
         const options: TestDiscoveryOptions = {
             args: ['some args'],
-            cwd: __dirname,
+            cwd: Uri.file(__dirname).fsPath,
             ignoreCache: true,
             outChannel: new MockOutputChannel('Tests'),
             token: new CancellationTokenSource().token,
@@ -94,7 +94,7 @@ suite('Unit Tests - PyTest - Discovery', () => {
     test('Build collection arguments', async () => {
         const options: TestDiscoveryOptions = {
             args: ['some args', 'and some more'],
-            cwd: __dirname,
+            cwd: Uri.file(__dirname).fsPath,
             ignoreCache: false,
             outChannel: new MockOutputChannel('Tests'),
             token: new CancellationTokenSource().token,
@@ -113,7 +113,7 @@ suite('Unit Tests - PyTest - Discovery', () => {
     test('Build collection arguments with ignore in args', async () => {
         const options: TestDiscoveryOptions = {
             args: ['some args', 'and some more', '--cache-clear'],
-            cwd: __dirname,
+            cwd: Uri.file(__dirname).fsPath,
             ignoreCache: true,
             outChannel: new MockOutputChannel('Tests'),
             token: new CancellationTokenSource().token,
@@ -132,7 +132,7 @@ suite('Unit Tests - PyTest - Discovery', () => {
     test('Build collection arguments (& ignore)', async () => {
         const options: TestDiscoveryOptions = {
             args: ['some args', 'and some more'],
-            cwd: __dirname,
+            cwd: Uri.file(__dirname).fsPath,
             ignoreCache: true,
             outChannel: new MockOutputChannel('Tests'),
             token: new CancellationTokenSource().token,
@@ -151,7 +151,7 @@ suite('Unit Tests - PyTest - Discovery', () => {
     test('Discover using common discovery', async () => {
         const options: TestDiscoveryOptions = {
             args: ['some args', 'and some more'],
-            cwd: __dirname,
+            cwd: Uri.file(__dirname).fsPath,
             ignoreCache: true,
             outChannel: new MockOutputChannel('Tests'),
             token: new CancellationTokenSource().token,
diff --git a/src/test/vscode-mock.ts b/src/test/vscode-mock.ts
index 9ce26494d6c0..fb8b870c919f 100644
--- a/src/test/vscode-mock.ts
+++ b/src/test/vscode-mock.ts
@@ -55,7 +55,7 @@ mockedVSCode.CancellationTokenSource = vscodeMocks.vscMock.CancellationTokenSour
 mockedVSCode.CompletionItemKind = vscodeMocks.vscMock.CompletionItemKind;
 mockedVSCode.SymbolKind = vscodeMocks.vscMock.SymbolKind;
 mockedVSCode.IndentAction = vscodeMocks.vscMock.IndentAction;
-mockedVSCode.Uri = vscodeMocks.vscMock.Uri as any;
+mockedVSCode.Uri = vscodeMocks.vscUri.URI as any;
 mockedVSCode.Range = vscodeMocks.vscMockExtHostedTypes.Range;
 mockedVSCode.Position = vscodeMocks.vscMockExtHostedTypes.Position;
 mockedVSCode.Selection = vscodeMocks.vscMockExtHostedTypes.Selection;

From 6b8e26dd22cfbe15796332c3a415b790cebf11bb Mon Sep 17 00:00:00 2001
From: Don Jayamanne <don.jayamanne@yahoo.com>
Date: Mon, 14 Oct 2019 12:43:27 -0700
Subject: [PATCH 25/36] Prevent updates to cell text when stauts of cell has
 changed (#7973)

* Prevent updates to cell text when stauts of cell has changed
* Added comments
---
 news/2 Fixes/7844.md                          |  1 +
 .../interactive-common/mainStateController.ts | 21 ++++++++++++++++---
 2 files changed, 19 insertions(+), 3 deletions(-)
 create mode 100644 news/2 Fixes/7844.md

diff --git a/news/2 Fixes/7844.md b/news/2 Fixes/7844.md
new file mode 100644
index 000000000000..f49616593f8a
--- /dev/null
+++ b/news/2 Fixes/7844.md	
@@ -0,0 +1 @@
+Prevent updates to the cell text when cell execution of the same cell has commenced or completed.
diff --git a/src/datascience-ui/interactive-common/mainStateController.ts b/src/datascience-ui/interactive-common/mainStateController.ts
index 5d5049ec8a9a..8080086ba8af 100644
--- a/src/datascience-ui/interactive-common/mainStateController.ts
+++ b/src/datascience-ui/interactive-common/mainStateController.ts
@@ -1112,10 +1112,25 @@ export class MainStateController implements IMessageHandler {
             // we won't actually update.
             const newVMs = [...this.pendingState.cellVMs];
 
+            // Live share has been disabled for now, see https://github.com/microsoft/vscode-python/issues/7972
             // Check to see if our code still matches for the cell (in liveshare it might be updated from the other side)
-            if (concatMultilineString(this.pendingState.cellVMs[index].cell.data.source) !== concatMultilineString(cell.data.source)) {
-                const newText = extractInputText(cell, getSettings());
-                newVMs[index] = { ...newVMs[index], cell: cell, inputBlockText: newText };
+            // if (concatMultilineString(this.pendingState.cellVMs[index].cell.data.source) !== concatMultilineString(cell.data.source)) {
+
+            // If cell state changes, then update just the state and the cell data (excluding source).
+            // Prevent updates to the source, as its possible we have recieved a response for a cell execution
+            // and the user has updated the cell text since then.
+            if (this.pendingState.cellVMs[index].cell.state !== cell.state) {
+                newVMs[index] = {
+                                    ...newVMs[index],
+                                    cell: {
+                                        ...newVMs[index].cell,
+                                        state: cell.state,
+                                        data: {
+                                            ...cell.data,
+                                            source: newVMs[index].cell.data.source
+                                        }
+                                    }
+                                };
             } else {
                 newVMs[index] = { ...newVMs[index], cell: cell };
             }

From e39d8353f765c64ae965a12344e6d646fa4956a7 Mon Sep 17 00:00:00 2001
From: Don Jayamanne <don.jayamanne@yahoo.com>
Date: Mon, 14 Oct 2019 12:43:38 -0700
Subject: [PATCH 26/36] When automatically opening the `Notebook Editor`, non
 file schemes (#7921)

* Ensure we support live share
---
 news/2 Fixes/7905.md                          |   1 +
 .../interactive-ipynb/nativeEditorProvider.ts |   5 +-
 .../nativeEditorProvider.unit.test.ts         | 118 ++++++++++++++++++
 uitests/wow.ipynb                             |   0
 4 files changed, 123 insertions(+), 1 deletion(-)
 create mode 100644 news/2 Fixes/7905.md
 create mode 100644 src/test/datascience/interactive-ipynb/nativeEditorProvider.unit.test.ts
 create mode 100644 uitests/wow.ipynb

diff --git a/news/2 Fixes/7905.md b/news/2 Fixes/7905.md
new file mode 100644
index 000000000000..096640f862c8
--- /dev/null
+++ b/news/2 Fixes/7905.md	
@@ -0,0 +1 @@
+When automatically opening the `Notebook Editor`, then ignore uris that do not have a `file` scheme
diff --git a/src/client/datascience/interactive-ipynb/nativeEditorProvider.ts b/src/client/datascience/interactive-ipynb/nativeEditorProvider.ts
index f1b46c22a73a..aed3f1efd005 100644
--- a/src/client/datascience/interactive-ipynb/nativeEditorProvider.ts
+++ b/src/client/datascience/interactive-ipynb/nativeEditorProvider.ts
@@ -200,6 +200,9 @@ export class NativeEditorProvider implements INotebookEditorProvider, IAsyncDisp
     }
 
     private isNotebook(document: TextDocument) {
-        return document.languageId === JUPYTER_LANGUAGE || path.extname(document.fileName).toLocaleLowerCase() === '.ipynb';
+        // Only support file uris (we don't want to automatically open any other ipynb file from another resource as a notebook).
+        // E.g. when opening a document for comparison, the scheme is `git`, in live share the scheme is `vsls`.
+        const validUriScheme = document.uri.scheme === 'file' || document.uri.scheme === 'vsls';
+        return validUriScheme && (document.languageId === JUPYTER_LANGUAGE || path.extname(document.fileName).toLocaleLowerCase() === '.ipynb');
     }
 }
diff --git a/src/test/datascience/interactive-ipynb/nativeEditorProvider.unit.test.ts b/src/test/datascience/interactive-ipynb/nativeEditorProvider.unit.test.ts
new file mode 100644
index 000000000000..5b015329e447
--- /dev/null
+++ b/src/test/datascience/interactive-ipynb/nativeEditorProvider.unit.test.ts
@@ -0,0 +1,118 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+// tslint:disable: no-any
+
+import { expect } from 'chai';
+import { instance, mock, when } from 'ts-mockito';
+import * as typemoq from 'typemoq';
+import { EventEmitter, TextDocument, Uri } from 'vscode';
+import { CommandManager } from '../../../client/common/application/commandManager';
+import { DocumentManager } from '../../../client/common/application/documentManager';
+import { ICommandManager, IDocumentManager, IWorkspaceService } from '../../../client/common/application/types';
+import { WorkspaceService } from '../../../client/common/application/workspace';
+import { AsyncDisposableRegistry } from '../../../client/common/asyncDisposableRegistry';
+import { ConfigurationService } from '../../../client/common/configuration/service';
+import { FileSystem } from '../../../client/common/platform/fileSystem';
+import { IFileSystem } from '../../../client/common/platform/types';
+import { IConfigurationService } from '../../../client/common/types';
+import { DataScienceErrorHandler } from '../../../client/datascience/errorHandler/errorHandler';
+import { NativeEditorProvider } from '../../../client/datascience/interactive-ipynb/nativeEditorProvider';
+import { IDataScienceErrorHandler, INotebookEditor } from '../../../client/datascience/types';
+import { ServiceContainer } from '../../../client/ioc/container';
+import { IServiceContainer } from '../../../client/ioc/types';
+import { sleep } from '../../core';
+
+// tslint:disable: max-func-body-length
+suite('Data Science - Native Editor Provider', () => {
+    let workspace: IWorkspaceService;
+    let configService: IConfigurationService;
+    let fileSystem: IFileSystem;
+    let doctManager: IDocumentManager;
+    let dsErrorHandler: IDataScienceErrorHandler;
+    let cmdManager: ICommandManager;
+    let svcContainer: IServiceContainer;
+
+    setup(() => {
+        svcContainer = mock(ServiceContainer);
+        configService = mock(ConfigurationService);
+        fileSystem = mock(FileSystem);
+        doctManager = mock(DocumentManager);
+        dsErrorHandler = mock(DataScienceErrorHandler);
+        cmdManager = mock(CommandManager);
+        workspace = mock(WorkspaceService);
+    });
+
+    function createNotebookProvider() {
+        return new NativeEditorProvider(
+            instance(svcContainer),
+            instance(mock(AsyncDisposableRegistry)),
+            [],
+            instance(workspace),
+            instance(configService),
+            instance(fileSystem),
+            instance(doctManager),
+            instance(cmdManager),
+            instance(dsErrorHandler)
+        );
+    }
+    function createTextDocument(uri: Uri, content: string) {
+        const textDocument = typemoq.Mock.ofType<TextDocument>();
+        textDocument.setup(t => t.uri).returns(() => uri);
+        textDocument.setup(t => t.fileName).returns(() => uri.fsPath);
+        textDocument.setup(t => t.getText()).returns(() => content);
+        return textDocument.object;
+    }
+    async function testAutomaticallyOpeningNotebookEditorWhenOpeningFiles(uri: Uri, shouldOpenNotebookEditor: boolean) {
+        const eventEmitter = new EventEmitter<TextDocument>();
+        const editor = typemoq.Mock.ofType<INotebookEditor>();
+        when(configService.getSettings()).thenReturn({ datascience: { useNotebookEditor: true } } as any);
+        when(doctManager.onDidOpenTextDocument).thenReturn(eventEmitter.event);
+        editor.setup(e => e.closed).returns(() => new EventEmitter<INotebookEditor>().event);
+        editor.setup(e => e.executed).returns(() => new EventEmitter<INotebookEditor>().event);
+        editor.setup(e => (e as any).then).returns(() => undefined);
+        when(svcContainer.get<INotebookEditor>(INotebookEditor)).thenReturn(editor.object);
+
+        // Ensure the editor is created and the load and show methods are invoked.
+        const invocationCount = shouldOpenNotebookEditor ? 1 : 0;
+        editor
+            .setup(e => e.load(typemoq.It.isAny(), typemoq.It.isAny()))
+            .returns(() => Promise.resolve())
+            .verifiable(typemoq.Times.exactly(invocationCount));
+        editor
+            .setup(e => e.show())
+            .returns(() => Promise.resolve())
+            .verifiable(typemoq.Times.exactly(invocationCount));
+
+        const notebookEditor = createNotebookProvider();
+
+        // Open a text document.
+        const textDoc = createTextDocument(uri, 'hello');
+        eventEmitter.fire(textDoc);
+
+        // wait for callbacks to get executed.
+        await sleep(1);
+
+        // If we're to open the notebook, then there must be 1, else 0.
+        expect(notebookEditor.editors).to.be.lengthOf(shouldOpenNotebookEditor ? 1 : 0);
+        editor.verifyAll();
+    }
+
+    test('Open the notebook editor when an ipynb file is opened', async () => {
+        await testAutomaticallyOpeningNotebookEditorWhenOpeningFiles(Uri.file('some file.ipynb'), true);
+    });
+    test('Do not open the notebook editor when a txt file is opened', async () => {
+        await testAutomaticallyOpeningNotebookEditorWhenOpeningFiles(Uri.file('some text file.txt'), false);
+    });
+    test('Open the notebook editor when an ipynb file is opened with a file scheme', async () => {
+        await testAutomaticallyOpeningNotebookEditorWhenOpeningFiles(Uri.parse('file:///some file.ipynb'), true);
+    });
+    test('Open the notebook editor when an ipynb file is opened with a vsls scheme (live share)', async () => {
+        await testAutomaticallyOpeningNotebookEditorWhenOpeningFiles(Uri.parse('vsls:///some file.ipynb'), true);
+    });
+    test('Do not open the notebook editor when an ipynb file is opened with a git scheme (comparing staged/modified files)', async () => {
+        await testAutomaticallyOpeningNotebookEditorWhenOpeningFiles(Uri.parse('git://some//text file.txt'), false);
+    });
+});
diff --git a/uitests/wow.ipynb b/uitests/wow.ipynb
new file mode 100644
index 000000000000..e69de29bb2d1

From e8cecc604c2e5ada772a2c8fb3c8efbb0baacafe Mon Sep 17 00:00:00 2001
From: Don Jayamanne <don.jayamanne@yahoo.com>
Date: Mon, 14 Oct 2019 14:03:22 -0700
Subject: [PATCH 27/36] Copy *.trie files related to fontkit, as part of
 webpacking (#7978)

---
 build/webpack/webpack.extension.config.js | 1 +
 build/webpack/webpack.extension.config.ts | 1 +
 news/2 Fixes/7899.md                      | 1 +
 3 files changed, 3 insertions(+)
 create mode 100644 news/2 Fixes/7899.md

diff --git a/build/webpack/webpack.extension.config.js b/build/webpack/webpack.extension.config.js
index b19caa9f6a7d..4cedc7c07595 100644
--- a/build/webpack/webpack.extension.config.js
+++ b/build/webpack/webpack.extension.config.js
@@ -68,6 +68,7 @@ const config = {
             onEnd: [
                 {
                     copy: [
+                        { source: './node_modules/fontkit/*.trie', destination: './out/client/node_modules' },
                         { source: './node_modules/pdfkit/js/data/*.*', destination: './out/client/node_modules/data' },
                         { source: './node_modules/pdfkit/js/pdfkit.js', destination: './out/client/node_modules/' }
                     ]
diff --git a/build/webpack/webpack.extension.config.ts b/build/webpack/webpack.extension.config.ts
index 9b565d99e369..c7e447a27d5d 100644
--- a/build/webpack/webpack.extension.config.ts
+++ b/build/webpack/webpack.extension.config.ts
@@ -75,6 +75,7 @@ const config: Configuration = {
             onEnd: [
                 {
                     copy: [
+                        { source: './node_modules/fontkit/*.trie', destination: './out/client/node_modules' },
                         { source: './node_modules/pdfkit/js/data/*.*', destination: './out/client/node_modules/data' },
                         { source: './node_modules/pdfkit/js/pdfkit.js', destination: './out/client/node_modules/' }
                     ]
diff --git a/news/2 Fixes/7899.md b/news/2 Fixes/7899.md
new file mode 100644
index 000000000000..7fe6b48d5688
--- /dev/null
+++ b/news/2 Fixes/7899.md	
@@ -0,0 +1 @@
+Ensure the `*.trie` files related to `font kit` npm module are copied into the output directory as part of the `Webpack` bundling operation.

From 557b271b0cdcf11c2108d7b19666eaa61fbef193 Mon Sep 17 00:00:00 2001
From: Rich Chiodo <rchiodo@users.noreply.github.com>
Date: Mon, 14 Oct 2019 16:31:32 -0700
Subject: [PATCH 28/36] Cherry pick saving fix for ipynb files

---
 news/2 Fixes/7960.md                          |   1 +
 package-lock.json                             |   5 +
 package.json                                  |   3 +-
 src/client/datascience/cellFactory.ts         |   4 +-
 src/client/datascience/common.ts              |  34 +++-
 src/client/datascience/gather/gather.ts       |   4 +-
 .../intellisense/baseIntellisenseProvider.ts  |   4 +-
 .../interactive-common/interactiveBase.ts     |   3 +-
 .../interactive-ipynb/nativeEditor.ts         | 113 ++++++++++---
 .../interactive-window/interactiveWindow.ts   |   2 +-
 .../datascience/jupyter/jupyterDebugger.ts    |   4 +-
 .../datascience/jupyter/jupyterExporter.ts    |   9 +-
 .../datascience/jupyter/jupyterNotebook.ts    |  13 +-
 src/client/datascience/types.ts               |   1 -
 .../history-react/interactiveCell.tsx         |   2 +-
 .../interactive-common/cellInput.tsx          |   4 +-
 .../interactive-common/cellOutput.tsx         |   8 +-
 .../informationMessages.tsx                   |   1 -
 .../interactive-common/mainState.ts           |   9 +-
 .../interactive-common/mainStateController.ts |  30 ++--
 .../native-editor/nativeCell.tsx              |   8 +-
 .../nativeEditorStateController.ts            |  10 +-
 .../cellhashprovider.unit.test.ts             |   1 -
 .../datascience/gather/gather.unit.test.ts    |   5 -
 .../interactiveWindow.functional.test.tsx     |   6 +-
 .../datascience/jupyterVariables.unit.test.ts |   3 +-
 src/test/datascience/mockJupyterManager.ts    |   6 +-
 src/test/datascience/mockJupyterRequest.ts    |   4 +-
 src/test/datascience/mockJupyterSession.ts    |   8 +-
 .../nativeEditor.functional.test.tsx          | 160 +++++++++++++++---
 .../datascience/notebook.functional.test.ts   |  10 +-
 31 files changed, 334 insertions(+), 141 deletions(-)
 create mode 100644 news/2 Fixes/7960.md

diff --git a/news/2 Fixes/7960.md b/news/2 Fixes/7960.md
new file mode 100644
index 000000000000..a341718fdcb0
--- /dev/null
+++ b/news/2 Fixes/7960.md	
@@ -0,0 +1 @@
+Minimize the changes to an ipynb file when saving - preserve metadata and spacing.
diff --git a/package-lock.json b/package-lock.json
index 829d0742db09..47ca8b2ec4cf 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -7298,6 +7298,11 @@
             "integrity": "sha1-8NZtA2cqglyxtzvbP+YjEMjlUrc=",
             "dev": true
         },
+        "detect-indent": {
+            "version": "6.0.0",
+            "resolved": "https://registry.npmjs.org/detect-indent/-/detect-indent-6.0.0.tgz",
+            "integrity": "sha512-oSyFlqaTHCItVRGK5RmrmjB+CmaMOW7IaNA/kdxqhoa6d17j/5ce9O9eWXmV/KEdRwqpQA+Vqe8a8Bsybu4YnA=="
+        },
         "detect-libc": {
             "version": "1.0.3",
             "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-1.0.3.tgz",
diff --git a/package.json b/package.json
index 74277dabc922..61eb552802e8 100644
--- a/package.json
+++ b/package.json
@@ -2660,12 +2660,13 @@
         "verifyBundle": "gulp verifyBundle"
     },
     "dependencies": {
+        "@blueprintjs/select": "3.10.0",
         "@jupyterlab/services": "^3.2.1",
         "@msrvida/python-program-analysis": "^0.2.6",
-        "@blueprintjs/select": "3.10.0",
         "ansi-regex": "^4.1.0",
         "arch": "^2.1.0",
         "azure-storage": "^2.10.3",
+        "detect-indent": "^6.0.0",
         "diff-match-patch": "^1.0.0",
         "fast-deep-equal": "^2.0.1",
         "fs-extra": "^4.0.3",
diff --git a/src/client/datascience/cellFactory.ts b/src/client/datascience/cellFactory.ts
index e6e8c1dfd2e2..6fcc20387ffb 100644
--- a/src/client/datascience/cellFactory.ts
+++ b/src/client/datascience/cellFactory.ts
@@ -43,8 +43,7 @@ function generateCodeCell(code: string[], file: string, line: number, id: string
         id: id,
         file: file,
         line: line,
-        state: CellState.init,
-        type: 'execute'
+        state: CellState.init
     };
 
 }
@@ -55,7 +54,6 @@ function generateMarkdownCell(code: string[], file: string, line: number, id: st
         file: file,
         line: line,
         state: CellState.finished,
-        type: 'execute',
         data: {
             cell_type: 'markdown',
             source: generateMarkdownFromCodeLines(code),
diff --git a/src/client/datascience/common.ts b/src/client/datascience/common.ts
index f031f924ce94..fb2b611032a2 100644
--- a/src/client/datascience/common.ts
+++ b/src/client/datascience/common.ts
@@ -7,7 +7,8 @@ import { noop } from '../../test/core';
 
 const SingleQuoteMultiline = '\'\'\'';
 const DoubleQuoteMultiline = '\"\"\"';
-export function concatMultilineString(str: nbformat.MultilineString): string {
+
+function concatMultilineString(str: nbformat.MultilineString, trim: boolean): string {
     const nonLineFeedWhiteSpaceTrim = /(^[\t\f\v\r ]+|[\t\f\v\r ]+$)/g; // Local var so don't have to reset the lastIndex.
     if (Array.isArray(str)) {
         let result = '';
@@ -21,16 +22,35 @@ export function concatMultilineString(str: nbformat.MultilineString): string {
         }
 
         // Just trim whitespace. Leave \n in place
-        return result.replace(nonLineFeedWhiteSpaceTrim, '');
+        return trim ? result.replace(nonLineFeedWhiteSpaceTrim, '') : result;
     }
-    return str.toString().replace(nonLineFeedWhiteSpaceTrim, '');
+    return trim ? str.toString().replace(nonLineFeedWhiteSpaceTrim, '') : str.toString();
 }
 
-export function splitMultilineString(str: nbformat.MultilineString): string[] {
-    if (Array.isArray(str)) {
-        return str as string[];
+export function concatMultilineStringOutput(str: nbformat.MultilineString): string {
+    return concatMultilineString(str, true);
+}
+export function concatMultilineStringInput(str: nbformat.MultilineString): string {
+    return concatMultilineString(str, false);
+}
+
+export function splitMultilineString(source: nbformat.MultilineString): string[] {
+    // Make sure a multiline string is back the way Jupyter expects it
+    if (Array.isArray(source)) {
+        return source as string[];
+    }
+    const str = source.toString();
+    if (str.length > 0) {
+        // Each line should be a separate entry, but end with a \n if not last entry
+        const arr = str.split('\n');
+        return arr.map((s, i) => {
+            if (i < arr.length - 1) {
+                return `${s}\n`;
+            }
+            return s;
+        }).filter(s => s.length > 0); // Skip last one if empty (it's the only one that could be length 0)
     }
-    return str.toString().split('\n');
+    return [];
 }
 
 // Strip out comment lines from code
diff --git a/src/client/datascience/gather/gather.ts b/src/client/datascience/gather/gather.ts
index 049ad27c7c92..8a578989a719 100644
--- a/src/client/datascience/gather/gather.ts
+++ b/src/client/datascience/gather/gather.ts
@@ -14,7 +14,7 @@ import * as localize from '../../common/utils/localize';
 import { Common } from '../../common/utils/localize';
 import { noop } from '../../common/utils/misc';
 import { CellMatcher } from '../cellMatcher';
-import { concatMultilineString } from '../common';
+import { concatMultilineStringInput } from '../common';
 import { Identifiers } from '../constants';
 import { CellState, ICell as IVscCell, IGatherExecution, INotebookExecutionLogger } from '../types';
 
@@ -60,7 +60,7 @@ export class GatherExecution implements IGatherExecution, INotebookExecutionLogg
 
                 // Strip first line marker. We can't do this at JupyterServer.executeCodeObservable because it messes up hashing
                 const cellMatcher = new CellMatcher(this.configService.getSettings().datascience);
-                cloneCell.data.source = cellMatcher.stripFirstMarker(concatMultilineString(vscCell.data.source));
+                cloneCell.data.source = cellMatcher.stripFirstMarker(concatMultilineStringInput(vscCell.data.source));
 
                 // Convert IVscCell to IGatherCell
                 const cell = convertVscToGatherCell(cloneCell) as LogCell;
diff --git a/src/client/datascience/interactive-common/intellisense/baseIntellisenseProvider.ts b/src/client/datascience/interactive-common/intellisense/baseIntellisenseProvider.ts
index eed2dc888ff4..f052762345b6 100644
--- a/src/client/datascience/interactive-common/intellisense/baseIntellisenseProvider.ts
+++ b/src/client/datascience/interactive-common/intellisense/baseIntellisenseProvider.ts
@@ -22,7 +22,7 @@ import { CancellationError } from '../../../common/cancellation';
 import { traceWarning } from '../../../common/logger';
 import { IFileSystem, TemporaryFile } from '../../../common/platform/types';
 import { createDeferred, Deferred, waitForPromise } from '../../../common/utils/async';
-import { concatMultilineString } from '../../common';
+import { concatMultilineStringInput } from '../../common';
 import { Identifiers, Settings } from '../../constants';
 import { IInteractiveWindowListener, IInteractiveWindowProvider, IJupyterExecution, INotebook } from '../../types';
 import {
@@ -387,7 +387,7 @@ export abstract class BaseIntellisenseProvider implements IInteractiveWindowList
         if (document) {
             const changes = document.loadAllCells(payload.cells.filter(c => c.data.cell_type === 'code').map(cell => {
                 return {
-                    code: concatMultilineString(cell.data.source),
+                    code: concatMultilineStringInput(cell.data.source),
                     id: cell.id
                 };
             }));
diff --git a/src/client/datascience/interactive-common/interactiveBase.ts b/src/client/datascience/interactive-common/interactiveBase.ts
index 7ceaa55ba4dc..8440bfc58ac8 100644
--- a/src/client/datascience/interactive-common/interactiveBase.ts
+++ b/src/client/datascience/interactive-common/interactiveBase.ts
@@ -557,13 +557,12 @@ export abstract class InteractiveBase extends WebViewHost<IInteractiveWindowMapp
         return result;
     }
 
-    protected addMessageImpl(message: string, type: 'preview' | 'execute'): void {
+    protected addMessageImpl(message: string): void {
         const cell: ICell = {
             id: uuid(),
             file: Identifiers.EmptyFileName,
             line: 0,
             state: CellState.finished,
-            type,
             data: {
                 cell_type: 'messages',
                 messages: [message],
diff --git a/src/client/datascience/interactive-ipynb/nativeEditor.ts b/src/client/datascience/interactive-ipynb/nativeEditor.ts
index 29b4fd644ea7..a5e94ac1cc36 100644
--- a/src/client/datascience/interactive-ipynb/nativeEditor.ts
+++ b/src/client/datascience/interactive-ipynb/nativeEditor.ts
@@ -3,13 +3,22 @@
 'use strict';
 import '../../common/extensions';
 
+import { nbformat } from '@jupyterlab/coreutils/lib/nbformat';
+import * as detectIndent from 'detect-indent';
 import * as fastDeepEqual from 'fast-deep-equal';
 import { inject, injectable, multiInject, named } from 'inversify';
 import * as path from 'path';
 import * as uuid from 'uuid/v4';
 import { Event, EventEmitter, Memento, Uri, ViewColumn } from 'vscode';
 
-import { IApplicationShell, ICommandManager, IDocumentManager, ILiveShareApi, IWebPanelProvider, IWorkspaceService } from '../../common/application/types';
+import {
+    IApplicationShell,
+    ICommandManager,
+    IDocumentManager,
+    ILiveShareApi,
+    IWebPanelProvider,
+    IWorkspaceService
+} from '../../common/application/types';
 import { ContextKey } from '../../common/contextKey';
 import { traceError } from '../../common/logger';
 import { IFileSystem, TemporaryFile } from '../../common/platform/types';
@@ -20,10 +29,23 @@ import { StopWatch } from '../../common/utils/stopWatch';
 import { EXTENSION_ROOT_DIR } from '../../constants';
 import { IInterpreterService } from '../../interpreter/contracts';
 import { captureTelemetry, sendTelemetryEvent } from '../../telemetry';
-import { concatMultilineString } from '../common';
-import { EditorContexts, Identifiers, NativeKeyboardCommandTelemetryLookup, NativeMouseCommandTelemetryLookup, Telemetry } from '../constants';
+import { concatMultilineStringInput, splitMultilineString } from '../common';
+import {
+    EditorContexts,
+    Identifiers,
+    NativeKeyboardCommandTelemetryLookup,
+    NativeMouseCommandTelemetryLookup,
+    Telemetry
+} from '../constants';
 import { InteractiveBase } from '../interactive-common/interactiveBase';
-import { IEditCell, INativeCommand, InteractiveWindowMessages, ISaveAll, ISubmitNewCell } from '../interactive-common/interactiveWindowTypes';
+import {
+    IEditCell,
+    INativeCommand,
+    InteractiveWindowMessages,
+    ISaveAll,
+    ISubmitNewCell
+} from '../interactive-common/interactiveWindowTypes';
+import { InvalidNotebookFileError } from '../jupyter/invalidNotebookFileError';
 import {
     CellState,
     ICell,
@@ -62,6 +84,8 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
     private visibleCells: ICell[] = [];
     private startupTimer: StopWatch = new StopWatch();
     private loadedAllCells: boolean = false;
+    private indentAmount: string = ' ';
+    private notebookJson: Partial<nbformat.INotebookContent> = {};
 
     constructor(
         @multiInject(IInteractiveWindowListener) listeners: IInteractiveWindowListener[],
@@ -132,7 +156,7 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
         this.close().ignoreErrors();
     }
 
-    public async load(content: string, file: Uri): Promise<void> {
+    public async load(contents: string, file: Uri): Promise<void> {
         // Save our uri
         this._file = file;
 
@@ -149,12 +173,10 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
         const dirtyContents = this.getStoredContents();
         if (dirtyContents) {
             // This means we're dirty. Indicate dirty and load from this content
-            const cells = await this.importer.importCells(dirtyContents);
-            return this.loadCells(cells, true);
+            return this.loadContents(dirtyContents, true);
         } else {
-            // Load the contents of this notebook into our cells.
-            const cells = content ? await this.importer.importCells(content) : [];
-            return this.loadCells(cells, false);
+            // Load without setting dirty
+            return this.loadContents(contents, false);
         }
     }
 
@@ -318,8 +340,7 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
                     id: info.id,
                     file: Identifiers.EmptyFileName,
                     line: 0,
-                    state: CellState.error,
-                    type: 'execute'
+                    state: CellState.error
                 }
             ]);
 
@@ -391,6 +412,41 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
         // Actually don't close, just let the error bubble out
     }
 
+    private async loadContents(contents: string | undefined, forceDirty: boolean): Promise<void> {
+        // tslint:disable-next-line: no-any
+        const json = contents ? JSON.parse(contents) as any : undefined;
+
+        // Double check json (if we have any)
+        if (json && !json.cells) {
+            throw new InvalidNotebookFileError(this.file.fsPath);
+        }
+
+        // Then compute indent. It's computed from the contents
+        if (contents) {
+            this.indentAmount = detectIndent(contents).indent;
+        }
+
+        // Then save the contents. We'll stick our cells back into this format when we save
+        if (json) {
+            this.notebookJson = json;
+        }
+
+        // Extract cells from the json
+        const cells = contents ? json.cells as (nbformat.ICodeCell | nbformat.IRawCell | nbformat.IMarkdownCell)[] : [];
+
+        // Then parse the cells
+        return this.loadCells(cells.map((c, index) => {
+            return {
+                id: `NotebookImport#${index}`,
+                file: Identifiers.EmptyFileName,
+                line: 0,
+                state: CellState.finished,
+                data: c
+            };
+        }), forceDirty);
+
+    }
+
     private async loadCells(cells: ICell[], forceDirty: boolean): Promise<void> {
         // Make sure cells have at least 1
         if (cells.length === 0) {
@@ -399,7 +455,6 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
                 line: 0,
                 file: Identifiers.EmptyFileName,
                 state: CellState.finished,
-                type: 'execute',
                 data: {
                     cell_type: 'code',
                     outputs: [],
@@ -496,7 +551,7 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
             const cell = this.visibleCells.find(c => c.id === request.id);
             if (cell) {
                 // This is an actual edit.
-                const contents = concatMultilineString(cell.data.source);
+                const contents = concatMultilineStringInput(cell.data.source);
                 const before = contents.substr(0, change.rangeOffset);
                 const after = contents.substr(change.rangeOffset + change.rangeLength);
                 const newContents = `${before}${normalized}${after}`;
@@ -532,8 +587,7 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
             this.visibleCells = cells;
 
             // Save our dirty state in the storage for reopen later
-            const notebook = await this.jupyterExporter.translateToNotebook(this.visibleCells, undefined);
-            await this.storeContents(JSON.stringify(notebook));
+            await this.storeContents(this.generateNotebookContent(cells));
 
             // Indicate dirty
             await this.setDirty();
@@ -568,10 +622,7 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
             tempFile = await this.fileSystem.createTemporaryFile('.ipynb');
 
             // Translate the cells into a notebook
-            const notebook = await this.jupyterExporter.translateToNotebook(cells, undefined);
-
-            // Write the cells to this file
-            await this.fileSystem.writeFile(tempFile.filePath, JSON.stringify(notebook), { encoding: 'utf-8' });
+            await this.fileSystem.writeFile(tempFile.filePath, this.generateNotebookContent(cells), { encoding: 'utf-8' });
 
             // Import this file and show it
             const contents = await this.importer.importFromFile(tempFile.filePath);
@@ -593,6 +644,23 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
         await this.documentManager.showTextDocument(doc, ViewColumn.One);
     }
 
+    private fixupCell(cell: nbformat.ICell): nbformat.ICell {
+        // Source is usually a single string on input. Convert back to an array
+        return {
+            ...cell,
+            source: splitMultilineString(cell.source)
+        };
+    }
+
+    private generateNotebookContent(cells: ICell[]): string {
+        // Reuse our original json except for the cells.
+        const json = {
+            ...this.notebookJson,
+            cells: cells.map(c => this.fixupCell(c.data))
+        };
+        return JSON.stringify(json, null, this.indentAmount);
+    }
+
     private async saveToDisk(): Promise<void> {
         try {
             let fileToSaveTo: Uri | undefined = this.file;
@@ -615,9 +683,8 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
             }
 
             if (fileToSaveTo && isDirty) {
-                // Save our visible cells into the file
-                const notebook = await this.jupyterExporter.translateToNotebook(this.visibleCells, undefined);
-                await this.fileSystem.writeFile(fileToSaveTo.fsPath, JSON.stringify(notebook));
+                // Write out our visible cells
+                await this.fileSystem.writeFile(fileToSaveTo.fsPath, this.generateNotebookContent(this.visibleCells));
 
                 // Update our file name and dirty state
                 this._file = fileToSaveTo;
diff --git a/src/client/datascience/interactive-window/interactiveWindow.ts b/src/client/datascience/interactive-window/interactiveWindow.ts
index b76b2a06cbb1..49948b200efe 100644
--- a/src/client/datascience/interactive-window/interactiveWindow.ts
+++ b/src/client/datascience/interactive-window/interactiveWindow.ts
@@ -118,7 +118,7 @@ export class InteractiveWindow extends InteractiveBase implements IInteractiveWi
     }
 
     public addMessage(message: string): Promise<void> {
-        this.addMessageImpl(message, 'execute');
+        this.addMessageImpl(message);
         return Promise.resolve();
     }
 
diff --git a/src/client/datascience/jupyter/jupyterDebugger.ts b/src/client/datascience/jupyter/jupyterDebugger.ts
index 5d1de2542240..56afb727606e 100644
--- a/src/client/datascience/jupyter/jupyterDebugger.ts
+++ b/src/client/datascience/jupyter/jupyterDebugger.ts
@@ -13,7 +13,7 @@ import { IPlatformService } from '../../common/platform/types';
 import { IConfigurationService } from '../../common/types';
 import * as localize from '../../common/utils/localize';
 import { captureTelemetry, sendTelemetryEvent } from '../../telemetry';
-import { concatMultilineString } from '../common';
+import { concatMultilineStringOutput } from '../common';
 import { Identifiers, Telemetry } from '../constants';
 import {
     CellState,
@@ -398,7 +398,7 @@ export class JupyterDebugger implements IJupyterDebugger, ICellHashListener {
                 }
                 if (outputs[0].output_type === 'stream') {
                     const stream = outputs[0] as nbformat.IStream;
-                    return concatMultilineString(stream.text);
+                    return concatMultilineStringOutput(stream.text);
                 }
             }
         }
diff --git a/src/client/datascience/jupyter/jupyterExporter.ts b/src/client/datascience/jupyter/jupyterExporter.ts
index 899c61d82766..89fed8dfbbf5 100644
--- a/src/client/datascience/jupyter/jupyterExporter.ts
+++ b/src/client/datascience/jupyter/jupyterExporter.ts
@@ -13,7 +13,7 @@ import { IConfigurationService } from '../../common/types';
 import * as localize from '../../common/utils/localize';
 import { noop } from '../../common/utils/misc';
 import { CellMatcher } from '../cellMatcher';
-import { concatMultilineString } from '../common';
+import { concatMultilineStringInput } from '../common';
 import { CodeSnippits, Identifiers } from '../constants';
 import { CellState, ICell, IJupyterExecution, INotebookExporter } from '../types';
 
@@ -89,8 +89,7 @@ export class JupyterExporter implements INotebookExporter {
                 id: uuid(),
                 file: Identifiers.EmptyFileName,
                 line: 0,
-                state: CellState.finished,
-                type: 'execute'
+                state: CellState.finished
             };
 
             return [cell, ...cells];
@@ -121,7 +120,7 @@ export class JupyterExporter implements INotebookExporter {
     private calculateDirectoryChange = async (notebookFile: string, cells: ICell[]): Promise<string | undefined> => {
         // Make sure we don't already have a cell with a ChangeDirectory comment in it.
         let directoryChange: string | undefined;
-        const haveChangeAlready = cells.find(c => concatMultilineString(c.data.source).includes(CodeSnippits.ChangeDirectoryCommentIdentifier));
+        const haveChangeAlready = cells.find(c => concatMultilineStringInput(c.data.source).includes(CodeSnippits.ChangeDirectoryCommentIdentifier));
         if (!haveChangeAlready) {
             const notebookFilePath = path.dirname(notebookFile);
             // First see if we have a workspace open, this only works if we have a workspace root to be relative to
@@ -165,7 +164,7 @@ export class JupyterExporter implements INotebookExporter {
     }
 
     private pruneSource = (source: nbformat.MultilineString, cellMatcher: CellMatcher): nbformat.MultilineString => {
-
+        // Remove the comments on the top if there.
         if (Array.isArray(source) && source.length > 0) {
             if (cellMatcher.isCell(source[0])) {
                 return source.slice(1);
diff --git a/src/client/datascience/jupyter/jupyterNotebook.ts b/src/client/datascience/jupyter/jupyterNotebook.ts
index f27fdc4b8031..f67602f25612 100644
--- a/src/client/datascience/jupyter/jupyterNotebook.ts
+++ b/src/client/datascience/jupyter/jupyterNotebook.ts
@@ -23,7 +23,7 @@ import { StopWatch } from '../../common/utils/stopWatch';
 import { captureTelemetry, sendTelemetryEvent } from '../../telemetry';
 import { generateCells } from '../cellFactory';
 import { CellMatcher } from '../cellMatcher';
-import { concatMultilineString, formatStreamText } from '../common';
+import { concatMultilineStringInput, concatMultilineStringOutput, formatStreamText } from '../common';
 import { CodeSnippits, Identifiers, Telemetry } from '../constants';
 import {
     CellState,
@@ -301,8 +301,7 @@ export class JupyterNotebookBase implements INotebook {
             id: uuid(),
             file: '',
             line: 0,
-            state: CellState.finished,
-            type: 'execute'
+            state: CellState.finished
         };
     }
 
@@ -482,7 +481,7 @@ export class JupyterNotebookBase implements INotebook {
                 outputs.forEach(o => {
                     if (o.output_type === 'stream') {
                         const stream = o as nbformat.IStream;
-                        result = result.concat(formatStreamText(concatMultilineString(stream.text)));
+                        result = result.concat(formatStreamText(concatMultilineStringOutput(stream.text)));
                     } else {
                         const data = o.data;
                         if (data && data.hasOwnProperty('text/plain')) {
@@ -622,7 +621,7 @@ export class JupyterNotebookBase implements INotebook {
                 subscriber.error(this.sessionStartTime, new Error(localize.DataScience.jupyterServerCrashed().format(exitCode.toString())));
                 subscriber.complete(this.sessionStartTime);
             } else {
-                const request = this.generateRequest(concatMultilineString(subscriber.cell.data.source), silent);
+                const request = this.generateRequest(concatMultilineStringInput(subscriber.cell.data.source), silent);
 
                 // tslint:disable-next-line:no-require-imports
                 const jupyterLab = require('@jupyterlab/services') as typeof import('@jupyterlab/services');
@@ -807,7 +806,7 @@ export class JupyterNotebookBase implements INotebook {
             } else {
                 // tslint:disable-next-line:restrict-plus-operands
                 existing.text = existing.text + msg.content.text;
-                existing.text = trimFunc(formatStreamText(concatMultilineString(existing.text)));
+                existing.text = trimFunc(formatStreamText(concatMultilineStringOutput(existing.text)));
             }
 
         } else {
@@ -815,7 +814,7 @@ export class JupyterNotebookBase implements INotebook {
             const output: nbformat.IStream = {
                 output_type: 'stream',
                 name: msg.content.name,
-                text: trimFunc(formatStreamText(concatMultilineString(msg.content.text)))
+                text: trimFunc(formatStreamText(concatMultilineStringOutput(msg.content.text)))
             };
             this.addToCellData(cell, output, clearState);
         }
diff --git a/src/client/datascience/types.ts b/src/client/datascience/types.ts
index 9b4266655e8c..3e75c8b57e31 100644
--- a/src/client/datascience/types.ts
+++ b/src/client/datascience/types.ts
@@ -345,7 +345,6 @@ export interface ICell {
     file: string;
     line: number;
     state: CellState;
-    type: 'preview' | 'execute';
     data: nbformat.ICodeCell | nbformat.IRawCell | nbformat.IMarkdownCell | IMessageCell;
     extraLines?: number[];
 }
diff --git a/src/datascience-ui/history-react/interactiveCell.tsx b/src/datascience-ui/history-react/interactiveCell.tsx
index 1e1284a41319..41686aaae886 100644
--- a/src/datascience-ui/history-react/interactiveCell.tsx
+++ b/src/datascience-ui/history-react/interactiveCell.tsx
@@ -62,7 +62,7 @@ export class InteractiveCell extends React.Component<IInteractiveCellProps> {
     public render() {
 
         if (this.props.cellVM.cell.data.cell_type === 'messages') {
-            return <InformationMessages messages={this.props.cellVM.cell.data.messages} type={this.props.cellVM.cell.type}/>;
+            return <InformationMessages messages={this.props.cellVM.cell.data.messages}/>;
         } else {
             return this.renderNormalCell();
         }
diff --git a/src/datascience-ui/interactive-common/cellInput.tsx b/src/datascience-ui/interactive-common/cellInput.tsx
index 17a60132396d..41ec875fcd1e 100644
--- a/src/datascience-ui/interactive-common/cellInput.tsx
+++ b/src/datascience-ui/interactive-common/cellInput.tsx
@@ -7,7 +7,7 @@ import { nbformat } from '@jupyterlab/coreutils';
 import * as monacoEditor from 'monaco-editor/esm/vs/editor/editor.api';
 import * as React from 'react';
 
-import { concatMultilineString } from '../../client/datascience/common';
+import { concatMultilineStringInput } from '../../client/datascience/common';
 import { IKeyboardEvent } from '../react-common/event';
 import { getLocString } from '../react-common/locReactSide';
 import { Code } from './code';
@@ -139,7 +139,7 @@ export class CellInput extends React.Component<ICellInputProps> {
 
     private renderMarkdownInputs = () => {
         if (this.shouldRenderMarkdownEditor()) {
-            const source = concatMultilineString(this.getMarkdownCell().source);
+            const source = concatMultilineStringInput(this.getMarkdownCell().source);
             return (
                 <div className='cell-input'>
                     <Markdown
diff --git a/src/datascience-ui/interactive-common/cellOutput.tsx b/src/datascience-ui/interactive-common/cellOutput.tsx
index 9f201f0e8772..c775d2ad80cb 100644
--- a/src/datascience-ui/interactive-common/cellOutput.tsx
+++ b/src/datascience-ui/interactive-common/cellOutput.tsx
@@ -14,7 +14,7 @@ import cloneDeep = require('lodash/cloneDeep');
 import * as monacoEditor from 'monaco-editor/esm/vs/editor/editor.api';
 import * as React from 'react';
 
-import { concatMultilineString } from '../../client/datascience/common';
+import { concatMultilineStringInput, concatMultilineStringOutput } from '../../client/datascience/common';
 import { Identifiers } from '../../client/datascience/constants';
 import { CellState } from '../../client/datascience/types';
 import { ClassType } from '../../client/ioc/types';
@@ -170,7 +170,7 @@ export class CellOutput extends React.Component<ICellOutputProps> {
     private renderMarkdownOutputs = () => {
         const markdown = this.getMarkdownCell();
         // React-markdown expects that the source is a string
-        const source = concatMultilineString(markdown.source);
+        const source = concatMultilineStringInput(markdown.source);
         const Transform = transforms['text/markdown'];
         const MarkdownClassName = 'markdown-cell-output';
 
@@ -201,7 +201,7 @@ export class CellOutput extends React.Component<ICellOutputProps> {
             isError = false;
             renderWithScrollbars = true;
             const stream = copy as nbformat.IStream;
-            const formatted = concatMultilineString(stream.text);
+            const formatted = concatMultilineStringOutput(stream.text);
             copy.data = {
                 'text/html': formatted.includes('<') ? `<xmp>${formatted}</xmp>` : `<div>${formatted}</div>`
             };
@@ -251,7 +251,7 @@ export class CellOutput extends React.Component<ICellOutputProps> {
                 case 'text/plain':
                     return {
                         mimeType,
-                        data: concatMultilineString(data as nbformat.MultilineString),
+                        data: concatMultilineStringOutput(data as nbformat.MultilineString),
                         isText,
                         isError,
                         renderWithScrollbars,
diff --git a/src/datascience-ui/interactive-common/informationMessages.tsx b/src/datascience-ui/interactive-common/informationMessages.tsx
index 71095624fab2..8ff13e47d225 100644
--- a/src/datascience-ui/interactive-common/informationMessages.tsx
+++ b/src/datascience-ui/interactive-common/informationMessages.tsx
@@ -8,7 +8,6 @@ import * as React from 'react';
 interface IInformationMessagesProps
 {
     messages: string[];
-    type: 'execute' | 'preview';
 }
 
 export class InformationMessages extends React.Component<IInformationMessagesProps> {
diff --git a/src/datascience-ui/interactive-common/mainState.ts b/src/datascience-ui/interactive-common/mainState.ts
index 687cffe8904b..71c237af66c8 100644
--- a/src/datascience-ui/interactive-common/mainState.ts
+++ b/src/datascience-ui/interactive-common/mainState.ts
@@ -9,7 +9,7 @@ import * as path from 'path';
 
 import { IDataScienceSettings } from '../../client/common/types';
 import { CellMatcher } from '../../client/datascience/cellMatcher';
-import { concatMultilineString, splitMultilineString } from '../../client/datascience/common';
+import { concatMultilineStringInput, splitMultilineString } from '../../client/datascience/common';
 import { Identifiers } from '../../client/datascience/constants';
 import { CellState, ICell, IJupyterVariable, IMessageCell } from '../../client/datascience/types';
 import { noop } from '../../test/core';
@@ -134,8 +134,7 @@ export function createEmptyCell(id: string | undefined, executionCount: number |
         id: id ? id : Identifiers.EditCellId,
         file: Identifiers.EmptyFileName,
         line: 0,
-        state: CellState.finished,
-        type: 'execute'
+        state: CellState.finished
     };
 }
 
@@ -173,7 +172,7 @@ export function extractInputText(inputCell: ICell, settings: IDataScienceSetting
         }
     }
 
-    return concatMultilineString(source);
+    return concatMultilineStringInput(source);
 }
 
 export function createCellVM(inputCell: ICell, settings: IDataScienceSettings | undefined, inputBlockToggled: (id: string) => void, editable: boolean): ICellViewModel {
@@ -464,7 +463,7 @@ function generateCellData(): (nbformat.ICodeCell | nbformat.IMarkdownCell | nbfo
                 'Nunc quis orci ante. Vivamus vel blandit velit.\n","Sed mattis dui diam, et blandit augue mattis vestibulum.\n',
                 'Suspendisse ornare interdum velit. Suspendisse potenti.\n',
                 'Morbi molestie lacinia sapien nec porttitor. Nam at vestibulum nisi.\n',
-                '\"\"\" '
+                '\"\"\"'
             ]
         },
         {
diff --git a/src/datascience-ui/interactive-common/mainStateController.ts b/src/datascience-ui/interactive-common/mainStateController.ts
index 8080086ba8af..006a11ac8d67 100644
--- a/src/datascience-ui/interactive-common/mainStateController.ts
+++ b/src/datascience-ui/interactive-common/mainStateController.ts
@@ -11,7 +11,7 @@ import * as uuid from 'uuid/v4';
 
 import { createDeferred, Deferred } from '../../client/common/utils/async';
 import { CellMatcher } from '../../client/datascience/cellMatcher';
-import { concatMultilineString, generateMarkdownFromCodeLines } from '../../client/datascience/common';
+import { concatMultilineStringInput, generateMarkdownFromCodeLines } from '../../client/datascience/common';
 import { Identifiers } from '../../client/datascience/constants';
 import {
     IInteractiveWindowMapping,
@@ -520,7 +520,7 @@ export class MainStateController implements IMessageHandler {
             // Reset the old vms (nothing should be selected/focused)
             // Change state only for cells that were selected/focused
             newVMs.forEach((cellVM, index) => {
-                if (cellVM.selected || cellVM.focused){
+                if (cellVM.selected || cellVM.focused) {
                     newVMs[index] = { ...cellVM, selected: false, focused: false };
                 }
             });
@@ -541,7 +541,7 @@ export class MainStateController implements IMessageHandler {
             // Reset the old vms (nothing should be selected/focused)
             // Change state only for cells that were selected/focused
             newVMs.forEach((cellVM, index) => {
-                if (cellVM.selected || cellVM.focused){
+                if (cellVM.selected || cellVM.focused) {
                     newVMs[index] = { ...cellVM, selected: false, focused: false };
                 }
             });
@@ -562,7 +562,7 @@ export class MainStateController implements IMessageHandler {
             cellVMs[index] = immutable.updateIn(this.pendingState.cellVMs[index], ['cell', 'data', 'cell_type'], () => newType);
             this.setState({ cellVMs });
             if (newType === 'code') {
-                this.sendMessage(InteractiveWindowMessages.InsertCell, { id: cellId, code: concatMultilineString(cellVMs[index].cell.data.source), codeCellAbove: this.firstCodeCellAbove(cellId) });
+                this.sendMessage(InteractiveWindowMessages.InsertCell, { id: cellId, code: concatMultilineStringInput(cellVMs[index].cell.data.source), codeCellAbove: this.firstCodeCellAbove(cellId) });
             } else {
                 this.sendMessage(InteractiveWindowMessages.RemoveCell, { id: cellId });
             }
@@ -1114,23 +1114,23 @@ export class MainStateController implements IMessageHandler {
 
             // Live share has been disabled for now, see https://github.com/microsoft/vscode-python/issues/7972
             // Check to see if our code still matches for the cell (in liveshare it might be updated from the other side)
-            // if (concatMultilineString(this.pendingState.cellVMs[index].cell.data.source) !== concatMultilineString(cell.data.source)) {
+            // if (concatMultilineStringInput(this.pendingState.cellVMs[index].cell.data.source) !== concatMultilineStringInput(cell.data.source)) {
 
             // If cell state changes, then update just the state and the cell data (excluding source).
             // Prevent updates to the source, as its possible we have recieved a response for a cell execution
             // and the user has updated the cell text since then.
             if (this.pendingState.cellVMs[index].cell.state !== cell.state) {
                 newVMs[index] = {
-                                    ...newVMs[index],
-                                    cell: {
-                                        ...newVMs[index].cell,
-                                        state: cell.state,
-                                        data: {
-                                            ...cell.data,
-                                            source: newVMs[index].cell.data.source
-                                        }
-                                    }
-                                };
+                    ...newVMs[index],
+                    cell: {
+                        ...newVMs[index].cell,
+                        state: cell.state,
+                        data: {
+                            ...cell.data,
+                            source: newVMs[index].cell.data.source
+                        }
+                    }
+                };
             } else {
                 newVMs[index] = { ...newVMs[index], cell: cell };
             }
diff --git a/src/datascience-ui/native-editor/nativeCell.tsx b/src/datascience-ui/native-editor/nativeCell.tsx
index 90836d1a9faa..ff1ee03e549a 100644
--- a/src/datascience-ui/native-editor/nativeCell.tsx
+++ b/src/datascience-ui/native-editor/nativeCell.tsx
@@ -7,7 +7,7 @@ import { nbformat } from '@jupyterlab/coreutils';
 import * as fastDeepEqual from 'fast-deep-equal';
 import * as React from 'react';
 
-import { concatMultilineString } from '../../client/datascience/common';
+import { concatMultilineStringInput } from '../../client/datascience/common';
 import { Identifiers } from '../../client/datascience/constants';
 import { NativeCommandType } from '../../client/datascience/interactive-common/interactiveWindowTypes';
 import { CellState, ICell } from '../../client/datascience/types';
@@ -52,7 +52,7 @@ export class NativeCell extends React.Component<INativeCellProps> {
 
     public render() {
         if (this.props.cellVM.cell.data.cell_type === 'messages') {
-            return <InformationMessages messages={this.props.cellVM.cell.data.messages} type={this.props.cellVM.cell.type}/>;
+            return <InformationMessages messages={this.props.cellVM.cell.data.messages}/>;
         } else {
             return this.renderNormalCell();
         }
@@ -481,7 +481,7 @@ export class NativeCell extends React.Component<INativeCellProps> {
             content = possibleContents;
         } else {
             // Outside editor, just use the cell
-            content = concatMultilineString(this.props.cellVM.cell.data.source);
+            content = concatMultilineStringInput(this.props.cellVM.cell.data.source);
         }
 
         // Send to jupyter
@@ -620,7 +620,7 @@ export class NativeCell extends React.Component<INativeCellProps> {
             this.props.cellVM.cell.data.execution_count.toString() : '-';
         const runCell = () => {
             this.props.stateController.updateCellSource(cellId);
-            this.runAndMove(concatMultilineString(this.props.cellVM.cell.data.source));
+            this.runAndMove(concatMultilineStringInput(this.props.cellVM.cell.data.source));
             this.props.stateController.sendCommand(NativeCommandType.Run, 'mouse');
         };
         const canRunBelow = this.props.cellVM.cell.state === CellState.finished || this.props.cellVM.cell.state === CellState.error;
diff --git a/src/datascience-ui/native-editor/nativeEditorStateController.ts b/src/datascience-ui/native-editor/nativeEditorStateController.ts
index 6ceb10dda9a6..2c5cafb4fcb3 100644
--- a/src/datascience-ui/native-editor/nativeEditorStateController.ts
+++ b/src/datascience-ui/native-editor/nativeEditorStateController.ts
@@ -5,7 +5,7 @@ import * as monacoEditor from 'monaco-editor/esm/vs/editor/editor.api';
 import * as uuid from 'uuid/v4';
 
 import { noop } from '../../client/common/utils/misc';
-import { concatMultilineString } from '../../client/datascience/common';
+import { concatMultilineStringInput } from '../../client/datascience/common';
 import { Identifiers } from '../../client/datascience/constants';
 import {
     ILoadAllCells,
@@ -103,7 +103,7 @@ export class NativeEditorStateController extends MainStateController {
             const cells = this.getState().cellVMs;
             const selectedCell = cells.find(cvm => cvm.cell.id === selectedCellId);
             if (selectedCell) {
-                this.submitInput(concatMultilineString(selectedCell.cell.data.source), selectedCell);
+                this.submitInput(concatMultilineStringInput(selectedCell.cell.data.source), selectedCell);
             }
         }
     }
@@ -113,7 +113,7 @@ export class NativeEditorStateController extends MainStateController {
         this.suspendUpdates();
         const cells = this.getState().cellVMs;
         cells.filter(cvm => cvm.cell.data.cell_type === 'code').
-            forEach(cvm => this.submitInput(concatMultilineString(cvm.cell.data.source), cvm));
+            forEach(cvm => this.submitInput(concatMultilineStringInput(cvm.cell.data.source), cvm));
         this.resumeUpdates();
     }
 
@@ -162,7 +162,7 @@ export class NativeEditorStateController extends MainStateController {
         if (index > 0) {
             this.suspendUpdates();
             cells.filter((cvm, i) => i < index && cvm.cell.data.cell_type === 'code').
-                forEach(cvm => this.submitInput(concatMultilineString(cvm.cell.data.source), cvm));
+                forEach(cvm => this.submitInput(concatMultilineStringInput(cvm.cell.data.source), cvm));
             this.resumeUpdates();
         }
     }
@@ -173,7 +173,7 @@ export class NativeEditorStateController extends MainStateController {
         if (index >= 0) {
             this.suspendUpdates();
             cells.filter((cvm, i) => i >= index && cvm.cell.data.cell_type === 'code').
-                forEach(cvm => this.submitInput(concatMultilineString(cvm.cell.data.source), cvm));
+                forEach(cvm => this.submitInput(concatMultilineStringInput(cvm.cell.data.source), cvm));
             this.resumeUpdates();
         }
     }
diff --git a/src/test/datascience/editor-integration/cellhashprovider.unit.test.ts b/src/test/datascience/editor-integration/cellhashprovider.unit.test.ts
index 8fde0bd86f40..d9997449dd4e 100644
--- a/src/test/datascience/editor-integration/cellhashprovider.unit.test.ts
+++ b/src/test/datascience/editor-integration/cellhashprovider.unit.test.ts
@@ -64,7 +64,6 @@ suite('CellHashProvider Unit Tests', () => {
                 execution_count: 1
             },
             id: '1',
-            type: 'execute',
             state: CellState.init
         };
         return hashProvider.preExecute(cell, false);
diff --git a/src/test/datascience/gather/gather.unit.test.ts b/src/test/datascience/gather/gather.unit.test.ts
index d4dc30b9c56f..a2a395a95594 100644
--- a/src/test/datascience/gather/gather.unit.test.ts
+++ b/src/test/datascience/gather/gather.unit.test.ts
@@ -17,7 +17,6 @@ suite('DataScience code gathering unit tests', () => {
             file: '2DB9B899-6519-4E1B-88B0-FA728A274115',
             line: 0,
             state: 2,
-            type: 'execute',
             data: {
                 source: `from bokeh.plotting import show, figure, output_notebook\noutput_notebook()`,
                 cell_type: 'code',
@@ -31,7 +30,6 @@ suite('DataScience code gathering unit tests', () => {
             file: '2DB9B899-6519-4E1B-88B0-FA728A274115',
             line: 0,
             state: 2,
-            type: 'execute',
             data: {
                 source: `x = [1,2,3,4,5]\ny = [21,9,15,17,4]\nprint('This is some irrelevant code')`,
                 cell_type: 'code',
@@ -45,7 +43,6 @@ suite('DataScience code gathering unit tests', () => {
             file: '2DB9B899-6519-4E1B-88B0-FA728A274115',
             line: 0,
             state: 2,
-            type: 'execute',
             data: {
                 source: `p=figure(title='demo',x_axis_label='x',y_axis_label='y')`,
                 cell_type: 'code',
@@ -59,7 +56,6 @@ suite('DataScience code gathering unit tests', () => {
             file: '2DB9B899-6519-4E1B-88B0-FA728A274115',
             line: 0,
             state: 2,
-            type: 'execute',
             data: {
                 source: 'p.line(x,y,line_width=2)',
                 cell_type: 'code',
@@ -73,7 +69,6 @@ suite('DataScience code gathering unit tests', () => {
             file: '2DB9B899-6519-4E1B-88B0-FA728A274115',
             line: 0,
             state: 2,
-            type: 'execute',
             data: {
                 source: 'show(p)',
                 cell_type: 'code',
diff --git a/src/test/datascience/interactiveWindow.functional.test.tsx b/src/test/datascience/interactiveWindow.functional.test.tsx
index 6a71f86444a6..4741f5915aa3 100644
--- a/src/test/datascience/interactiveWindow.functional.test.tsx
+++ b/src/test/datascience/interactiveWindow.functional.test.tsx
@@ -13,7 +13,7 @@ import { IApplicationShell, IDocumentManager } from '../../client/common/applica
 import { createDeferred, waitForPromise } from '../../client/common/utils/async';
 import { noop } from '../../client/common/utils/misc';
 import { generateCellsFromDocument } from '../../client/datascience/cellFactory';
-import { concatMultilineString } from '../../client/datascience/common';
+import { concatMultilineStringInput } from '../../client/datascience/common';
 import { EditorContexts } from '../../client/datascience/constants';
 import { InteractiveWindow } from '../../client/datascience/interactive-window/interactiveWindow';
 import { InteractivePanel } from '../../datascience-ui/history-react/interactivePanel';
@@ -557,10 +557,10 @@ for _ in range(50):
             assert.equal(cells.length, 2, 'Not enough cells generated');
 
             // Run the first cell
-            await addCode(ioc, wrapper, concatMultilineString(cells[0].data.source), 4);
+            await addCode(ioc, wrapper, concatMultilineStringInput(cells[0].data.source), 4);
 
             // Last cell should generate a series of updates. Verify we end up with a single image
-            await addCode(ioc, wrapper, concatMultilineString(cells[1].data.source), 10);
+            await addCode(ioc, wrapper, concatMultilineStringInput(cells[1].data.source), 10);
             const cell = getLastOutputCell(wrapper, 'InteractiveCell');
 
             const output = cell!.find('div.cell-output');
diff --git a/src/test/datascience/jupyterVariables.unit.test.ts b/src/test/datascience/jupyterVariables.unit.test.ts
index c966c17138b3..5efba16b5190 100644
--- a/src/test/datascience/jupyterVariables.unit.test.ts
+++ b/src/test/datascience/jupyterVariables.unit.test.ts
@@ -35,8 +35,7 @@ suite('JupyterVariables', () => {
             id: '0',
             file: '',
             line: 0,
-            state: CellState.finished,
-            type: 'execute'
+            state: CellState.finished
         };
     }
 
diff --git a/src/test/datascience/mockJupyterManager.ts b/src/test/datascience/mockJupyterManager.ts
index e5320ed826c0..b42b97c0bbaf 100644
--- a/src/test/datascience/mockJupyterManager.ts
+++ b/src/test/datascience/mockJupyterManager.ts
@@ -18,7 +18,7 @@ import { IAsyncDisposableRegistry, IConfigurationService } from '../../client/co
 import { EXTENSION_ROOT_DIR } from '../../client/constants';
 import { generateCells } from '../../client/datascience/cellFactory';
 import { CellMatcher } from '../../client/datascience/cellMatcher';
-import { concatMultilineString } from '../../client/datascience/common';
+import { concatMultilineStringInput } from '../../client/datascience/common';
 import { CodeSnippits, Identifiers } from '../../client/datascience/constants';
 import {
     ICell,
@@ -186,7 +186,7 @@ export class MockJupyterManager implements IJupyterSessionManager {
     public addContinuousOutputCell(code: string, resultGenerator: (cancelToken: CancellationToken) => Promise<{ result: string; haveMore: boolean }>) {
         const cells = generateCells(undefined, code, Uri.file('foo.py').fsPath, 1, true, uuid());
         cells.forEach(c => {
-            const key = concatMultilineString(c.data.source).replace(LineFeedRegEx, '');
+            const key = concatMultilineStringInput(c.data.source).replace(LineFeedRegEx, '').toLowerCase();
             if (c.data.cell_type === 'code') {
                 const taggedResult = {
                     output_type: 'generator'
@@ -218,7 +218,7 @@ export class MockJupyterManager implements IJupyterSessionManager {
         const cells = generateCells(undefined, code, Uri.file('foo.py').fsPath, 1, true, uuid());
         cells.forEach(c => {
             const cellMatcher = new CellMatcher();
-            const key = cellMatcher.stripFirstMarker(concatMultilineString(c.data.source)).replace(LineFeedRegEx, '');
+            const key = cellMatcher.stripFirstMarker(concatMultilineStringInput(c.data.source)).replace(LineFeedRegEx, '').toLowerCase();
             if (c.data.cell_type === 'code') {
                 const massagedResult = this.massageCellResult(result, mimeType);
                 const data: nbformat.ICodeCell = c.data as nbformat.ICodeCell;
diff --git a/src/test/datascience/mockJupyterRequest.ts b/src/test/datascience/mockJupyterRequest.ts
index 37b222004d90..1620a069c695 100644
--- a/src/test/datascience/mockJupyterRequest.ts
+++ b/src/test/datascience/mockJupyterRequest.ts
@@ -7,7 +7,7 @@ import { CancellationToken } from 'vscode-jsonrpc';
 
 import { createDeferred, Deferred } from '../../client/common/utils/async';
 import { noop } from '../../client/common/utils/misc';
-import { concatMultilineString } from '../../client/datascience/common';
+import { concatMultilineStringInput } from '../../client/datascience/common';
 import { ICell } from '../../client/datascience/types';
 
 //tslint:disable:no-any
@@ -168,7 +168,7 @@ export class MockJupyterRequest implements Kernel.IFuture {
         // Then combine those into an array of producers for the rest of the messages
         const producers = [
             new SimpleMessageProducer('status', { execution_state: 'busy' }),
-            new SimpleMessageProducer('execute_input', { code: concatMultilineString(this.cell.data.source), execution_count: this.executionCount }),
+            new SimpleMessageProducer('execute_input', { code: concatMultilineStringInput(this.cell.data.source), execution_count: this.executionCount }),
             ...outputProducers,
             new SimpleMessageProducer('status', { execution_state: 'idle' })
         ];
diff --git a/src/test/datascience/mockJupyterSession.ts b/src/test/datascience/mockJupyterSession.ts
index 646242dcee6a..63cfaa1f5340 100644
--- a/src/test/datascience/mockJupyterSession.ts
+++ b/src/test/datascience/mockJupyterSession.ts
@@ -116,13 +116,15 @@ export class MockJupyterSession implements IJupyterSession {
 
     private findCell = (code: string): ICell => {
         // Match skipping line separators
-        const withoutLines = code.replace(LineFeedRegEx, '');
+        const withoutLines = code.replace(LineFeedRegEx, '').toLowerCase();
 
         if (this.dict.hasOwnProperty(withoutLines)) {
             return this.dict[withoutLines] as ICell;
         }
         // tslint:disable-next-line:no-console
-        console.log(`Cell ${code} not found in mock`);
-        throw new Error(`Cell ${code} not found in mock`);
+        console.log(`Cell '${code}' not found in mock`);
+        // tslint:disable-next-line:no-console
+        console.log(`Dict has these keys ${Object.keys(this.dict).join('","')}`);
+        throw new Error(`Cell '${code}' not found in mock`);
     }
 }
diff --git a/src/test/datascience/nativeEditor.functional.test.tsx b/src/test/datascience/nativeEditor.functional.test.tsx
index f047d12840fb..b764ad8ababe 100644
--- a/src/test/datascience/nativeEditor.functional.test.tsx
+++ b/src/test/datascience/nativeEditor.functional.test.tsx
@@ -331,11 +331,113 @@ suite('DataScience Native Editor', () => {
         let wrapper: ReactWrapper<any, Readonly<{}>, React.Component>;
         const disposables: Disposable[] = [];
         let ioc: DataScienceIocContainer;
-        const baseFile = [
-            { id: 'NotebookImport#0', data: { source: 'a=1\na' } },
-            { id: 'NotebookImport#1', data: { source: 'b=2\nb' } },
-            { id: 'NotebookImport#2', data: { source: 'c=3\nc' } }
-        ];
+        const baseFile = `
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a=1\\n",
+    "a"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "b=2\\n",
+    "b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "c=3\\n",
+    "c"
+   ]
+  }
+ ],
+ "metadata": {
+  "file_extension": ".py",
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.4"
+  },
+  "mimetype": "text/x-python",
+  "name": "python",
+  "npconvert_exporter": "python",
+  "pygments_lexer": "ipython3",
+  "version": 3
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}`;
+        const addedJSON = JSON.parse(baseFile);
+        addedJSON.cells.splice(0, 0, {
+            cell_type: 'code',
+            execution_count: null,
+            metadata: {},
+            outputs: [],
+            source: []
+           });
+        const addedJSONFile = JSON.stringify(addedJSON, null, ' ');
+
         let notebookFile: {
             filePath: string;
             cleanupCallback: Function;
@@ -351,15 +453,11 @@ suite('DataScience Native Editor', () => {
 
                 addMockData(ioc, 'b=2\nb', 2);
                 addMockData(ioc, 'c=3\nc', 3);
-
-                const runAllCells = baseFile.map(cell => {
-                    return createFileCell(cell, cell.data);
-                });
                 // Use a real file so we can save notebook to a file.
                 // This is used in some tests (saving).
                 notebookFile = await createTemporaryFile('.ipynb');
-                const notebook = await ioc.get<INotebookExporter>(INotebookExporter).translateToNotebook(runAllCells, undefined);
-                await Promise.all([waitForUpdate(wrapper, NativeEditor, 1), openEditor(ioc, JSON.stringify(notebook), notebookFile.filePath)]);
+                await fs.writeFile(notebookFile.filePath, baseFile);
+                await Promise.all([waitForUpdate(wrapper, NativeEditor, 1), openEditor(ioc, baseFile, notebookFile.filePath)]);
             } else {
                 // tslint:disable-next-line: no-invalid-this
                 this.skip();
@@ -395,11 +493,12 @@ suite('DataScience Native Editor', () => {
 
         function simulateKeyPressOnCell(cellIndex: number, keyboardEvent: Partial<IKeyboardEvent> & { code: string }) {
             const event = { ...createKeyboardEventForCell(keyboardEvent), ...keyboardEvent };
+            const id = `NotebookImport#${cellIndex}`;
             wrapper
                 .find(NativeCell)
                 .at(cellIndex)
                 .find(CellInput)
-                .props().keyDown!(baseFile[cellIndex].id, event);
+                .props().keyDown!(id, event);
             wrapper.update();
         }
 
@@ -718,19 +817,12 @@ suite('DataScience Native Editor', () => {
                     .find('.cell-wrapper')
                     .first();
                 wrapperElement.simulate('keyDown', { key: 'y' });
+                wrapper.update();
 
-                // Confirm output cell is not rendered (remember we don't have any output) and monaco editor is rendered.
-                assert.equal(
-                    wrapper
-                        .find(NativeCell)
-                        .at(1)
-                        .find(CellOutput).length,
-                    0
-                );
+                // Confirm editor is rendered .
+                const nativeCell = wrapper.find(NativeCell).at(1);
                 assert.equal(
-                    wrapper
-                        .find(NativeCell)
-                        .at(1)
+                    nativeCell
                         .find(MonacoEditor).length,
                     1
                 );
@@ -843,7 +935,7 @@ suite('DataScience Native Editor', () => {
                 await waitForMessageReceivedEditorComponent(InteractiveWindowMessages.NotebookDirty, 5_000);
 
                 // Wait for the state to get updated.
-                await waitForCondition(async () => controller.getState().dirty === false, 1_000, `Timeout waiting for dirty state to get updated to false`);
+                await waitForCondition(async () => controller.getState().dirty === false, 2_000, `Timeout waiting for dirty state to get updated to false`);
             }
 
             /**
@@ -891,6 +983,26 @@ suite('DataScience Native Editor', () => {
                 await makeChangesAndConfirmFileIsUpdated();
             });
 
+            test('File saved with same format', async () => {
+                // Configure notebook to save automatically ever 1s.
+                when(ioc.mockedWorkspaceConfig.get('autoSave', 'off')).thenReturn('afterDelay');
+                when(ioc.mockedWorkspaceConfig.get<number>('autoSaveDelay', anything())).thenReturn(1_000);
+                ioc.forceSettingsChanged(ioc.getSettings().pythonPath);
+                const notebookFileContents = await fs.readFile(notebookFile.filePath, 'utf8');
+
+                await modifyNotebook();
+                await waitForNotebookToBeDirty();
+
+                // At this point a message should be sent to extension asking it to save.
+                // After the save, the extension should send a message to react letting it know that it was saved successfully.
+
+                await waitForNotebookToBeClean();
+                // Confirm file is not the same. There should be a single cell that's been added
+                const newFileContents = await fs.readFile(notebookFile.filePath, 'utf8');
+                assert.notEqual(newFileContents, notebookFileContents);
+                assert.equal(newFileContents, addedJSONFile);
+            });
+
             test('Should not auto save notebook, ever', async () => {
                 const notebookFileContents = await fs.readFile(notebookFile.filePath, 'utf8');
 
diff --git a/src/test/datascience/notebook.functional.test.ts b/src/test/datascience/notebook.functional.test.ts
index e0c9c3cd057e..cb7870a1f2c3 100644
--- a/src/test/datascience/notebook.functional.test.ts
+++ b/src/test/datascience/notebook.functional.test.ts
@@ -22,7 +22,7 @@ import { IFileSystem } from '../../client/common/platform/types';
 import { IProcessServiceFactory, IPythonExecutionFactory, Output } from '../../client/common/process/types';
 import { createDeferred, waitForPromise } from '../../client/common/utils/async';
 import { noop } from '../../client/common/utils/misc';
-import { concatMultilineString } from '../../client/datascience/common';
+import { concatMultilineStringInput } from '../../client/datascience/common';
 import { Identifiers } from '../../client/datascience/constants';
 import { JupyterExecutionFactory } from '../../client/datascience/jupyter/jupyterExecutionFactory';
 import { JupyterKernelPromiseFailedError } from '../../client/datascience/jupyter/jupyterKernelPromiseFailedError';
@@ -168,7 +168,7 @@ suite('DataScience notebook tests', () => {
         } else if (cellType === 'markdown') {
             assert.equal(cells[0].data.cell_type, cellType, `${index}: Wrong type of cell returned`);
             const cell = cells[0].data as nbformat.IMarkdownCell;
-            const outputSource = concatMultilineString(cell.source);
+            const outputSource = concatMultilineStringInput(cell.source);
             verifyValue(outputSource);
         } else if (cellType === 'error') {
             const cell = cells[0].data as nbformat.ICodeCell;
@@ -788,7 +788,7 @@ df.head()`,
                 mimeType: 'text/plain',
                 cellType: 'markdown',
                 result: '#HEADER',
-                verifyValue: (d) => assert.equal(d, '#HEADER', 'Markdown incorrect')
+                verifyValue: (d) => assert.equal(d, ' #HEADER', 'Markdown incorrect')
             },
             {
                 markdownRegEx: '\\s*#\\s*<markdowncell>',
@@ -798,7 +798,7 @@ df.head()`,
                 mimeType: 'text/plain',
                 cellType: 'markdown',
                 result: '#HEADER',
-                verifyValue: (d) => assert.equal(d, '#HEADER', 'Markdown incorrect')
+                verifyValue: (d) => assert.equal(d, ' #HEADER', 'Markdown incorrect')
             },
             {
                 // Test relative directories too.
@@ -1038,7 +1038,7 @@ plt.show()`,
         @injectable()
         class Logger implements INotebookExecutionLogger {
             public async preExecute(cell: ICell, _silent: boolean): Promise<void> {
-                cellInputs.push(concatMultilineString(cell.data.source));
+                cellInputs.push(concatMultilineStringInput(cell.data.source));
             }
             public async postExecute(cell: ICell, _silent: boolean): Promise<void> {
                 outputs.push(extractDataOutput(cell));

From 6f4c6487768ad544083cb73035269e0ecb83a690 Mon Sep 17 00:00:00 2001
From: Ian Huff <ianhu@microsoft.com>
Date: Tue, 15 Oct 2019 09:33:19 -0700
Subject: [PATCH 29/36] new notebook command outside of extension (#7981)

---
 news/2 Fixes/7888.md | 1 +
 package.json         | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)
 create mode 100644 news/2 Fixes/7888.md

diff --git a/news/2 Fixes/7888.md b/news/2 Fixes/7888.md
new file mode 100644
index 000000000000..c1714788317c
--- /dev/null
+++ b/news/2 Fixes/7888.md	
@@ -0,0 +1 @@
+Allow the "Create New Blank Jupyter Notebook" command to be run when the python extension is not loaded yet.
\ No newline at end of file
diff --git a/package.json b/package.json
index 61eb552802e8..2903510eb9ca 100644
--- a/package.json
+++ b/package.json
@@ -72,6 +72,7 @@
         "onCommand:python.switchOffInsidersChannel",
         "onCommand:python.switchToDailyChannel",
         "onCommand:python.switchToWeeklyChannel",
+        "onCommand:python.datascience.createnewnotebook",
         "onCommand:python.datascience.showhistorypane",
         "onCommand:python.datascience.importnotebook",
         "onCommand:python.datascience.importnotebookfile",
@@ -957,8 +958,7 @@
                 {
                     "command": "python.datascience.createnewnotebook",
                     "title": "%python.command.python.datascience.createnewnotebook.title%",
-                    "category": "Python",
-                    "when": "python.datascience.featureenabled"
+                    "category": "Python"
                 }
             ],
             "view/title": [

From 42fddf3f76918ecf129c79e8a303a00c889daae8 Mon Sep 17 00:00:00 2001
From: Don Jayamanne <don.jayamanne@yahoo.com>
Date: Tue, 15 Oct 2019 13:23:47 -0700
Subject: [PATCH 30/36] Hide the parameters list when editor doesn't have focus
 (#7987)

* Added comments
---
 news/2 Fixes/7851.md                          |   1 +
 .../react-common/monacoEditor.tsx             | 118 +++++++++++++++++-
 2 files changed, 118 insertions(+), 1 deletion(-)
 create mode 100644 news/2 Fixes/7851.md

diff --git a/news/2 Fixes/7851.md b/news/2 Fixes/7851.md
new file mode 100644
index 000000000000..d45e641a6d22
--- /dev/null
+++ b/news/2 Fixes/7851.md	
@@ -0,0 +1 @@
+Hide the parameters intellisense widget in the `Notebook Editor` when it is not longer required.
diff --git a/src/datascience-ui/react-common/monacoEditor.tsx b/src/datascience-ui/react-common/monacoEditor.tsx
index 35f5c1c778f4..4c2d19915c8f 100644
--- a/src/datascience-ui/react-common/monacoEditor.tsx
+++ b/src/datascience-ui/react-common/monacoEditor.tsx
@@ -60,6 +60,15 @@ export class MonacoEditor extends React.Component<IMonacoEditorProps, IMonacoEdi
     private throttledUpdateWidgetPosition = throttle(this.updateWidgetPosition.bind(this), 100);
     private monacoContainer : HTMLDivElement | undefined;
 
+    /**
+     * Reference to parameter widget (used by monaco to display parameter docs).
+     *
+     * @private
+     * @type {Element}
+     * @memberof MonacoEditor
+     */
+    private parameterWidget?: Element;
+
     constructor(props: IMonacoEditorProps) {
         super(props);
         this.state = { editor: undefined, model: null, visibleLineCount: -1, attached: false, widgetsReparented: false };
@@ -157,6 +166,11 @@ export class MonacoEditor extends React.Component<IMonacoEditorProps, IMonacoEdi
                 }
             }));
 
+            // When editor loses focus, hide parameter widgets (if any currently displayed).
+            this.subscriptions.push(editor.onDidBlurEditorWidget(() => {
+                this.hideParameterWidget();
+            }));
+
             // Track focus changes to make sure we update our widget parent and widget position
             this.subscriptions.push(editor.onDidFocusEditorWidget(() => {
                 this.throttledUpdateWidgetPosition();
@@ -192,7 +206,10 @@ export class MonacoEditor extends React.Component<IMonacoEditorProps, IMonacoEdi
         if (window) {
             window.removeEventListener('resize', this.windowResized);
         }
-
+        if (this.parameterWidget){
+            this.parameterWidget.removeEventListener('mouseleave', this.outermostParentLeave);
+            this.parameterWidget = undefined;
+        }
         if (this.outermostParent) {
             this.outermostParent.removeEventListener('mouseleave', this.outermostParentLeave);
             this.outermostParent = null;
@@ -434,9 +451,108 @@ export class MonacoEditor extends React.Component<IMonacoEditorProps, IMonacoEdi
         if (this.state.editor && !this.enteredHover) {
             // If we haven't already entered hover, then act like it shuts down
             this.onHoverLeave();
+            // Possible user is viewing the parameter hints, wait before user moves the mouse.
+            // Waiting for 1s is too long to move the mouse and hide the hints (100ms seems like a good fit).
+            setTimeout(() => this.hideParameterWidget(), 100);
         }
     }
 
+    /**
+     * This will hide the parameter widget if the user is not hovering over
+     * the parameter widget for this monaco editor.
+     *
+     * Notes: See issue https://github.com/microsoft/vscode-python/issues/7851 for further info.
+     * Hide the parameter widget if all of the following conditions have been met:
+     * - ditor doesn't have focus
+     * - Mouse is not over the editor
+     * - Mouse is not over (hovering) the parameter widget
+     *
+     * @private
+     * @returns
+     * @memberof MonacoEditor
+     */
+    private hideParameterWidget(){
+        if (!this.state.editor || !this.state.editor.getDomNode() || !this.widgetParent){
+            return;
+        }
+        // Find all elements that the user is hovering over.
+        // Its possible the parameter widget is one of them.
+        const hoverElements: Element[] = Array.prototype.slice.call(document.querySelectorAll(':hover'));
+        // Find all parameter widgets related to this monaco editor that are currently displayed.
+        const visibleParameterHintsWidgets: Element[] = Array.prototype.slice.call(this.widgetParent.querySelectorAll('.parameter-hints-widget.visible'));
+        if (hoverElements.length === 0 && visibleParameterHintsWidgets.length === 0){
+            // If user is not hovering over anything and there are no visible parameter widgets,
+            // then, we have nothing to do but get out of here.
+            return;
+        }
+
+        // Find all parameter widgets related to this monaco editor.
+        const knownParameterHintsWidgets: HTMLDivElement[] = Array.prototype.slice.call(this.widgetParent.querySelectorAll('.parameter-hints-widget'));
+
+        // Lets not assume we'll have the exact same DOM for parameter widgets.
+        // So, just remove the event handler, and add it again later.
+        if (this.parameterWidget){
+            this.parameterWidget.removeEventListener('mouseleave', this.outermostParentLeave);
+        }
+        // These are the classes that will appear on a parameter widget when they are visible.
+        const parameterWidgetClasses = ['editor-widget', 'parameter-hints-widget', 'visible'];
+
+        // Find the parameter widget the user is currently hovering over.
+        this.parameterWidget = hoverElements.find(item => {
+            if (!item.className) {
+                return false;
+            }
+            // Check if user is hovering over a parameter widget.
+            const classes = item.className.split(' ');
+            if (!parameterWidgetClasses.every(cls => classes.indexOf(cls) >= 0)){
+                // Not all classes required in a parameter hint widget are in this element.
+                // Hence this is not a parameter widget.
+                return false;
+            }
+
+            // Ok, this element that the user is hovering over is a parameter widget.
+
+            // Next, check whether this parameter widget belongs to this monaco editor.
+            // We have a list of parameter widgets that belong to this editor, hence a simple lookup.
+            return knownParameterHintsWidgets.some(widget => widget === item);
+        });
+
+        if (this.parameterWidget){
+            // We know the user is hovering over the parameter widget for this editor.
+            // Hovering could mean the user is scrolling through a large parameter list.
+            // We need to add a mouse leave event handler, so as to hide this.
+            this.parameterWidget.addEventListener('mouseleave', this.outermostParentLeave);
+
+            // In case the event handler doesn't get fired, have a backup of checking within 1s.
+            setTimeout(() => this.hideParameterWidget(), 1000);
+            return;
+        }
+        if (visibleParameterHintsWidgets.length === 0){
+            // There are no parameter widgets displayed for this editor.
+            // Hence nothing to do.
+            return;
+        }
+        // If the editor has focus, don't hide the parameter widget.
+        // This is the default behavior. Let the user hit `Escape` or click somewhere
+        // to forcefully hide the parameter widget.
+        if (this.state.editor.hasWidgetFocus()) {
+            return;
+        }
+
+        // If we got here, then the user is not hovering over the paramter widgets.
+        // & the editor doesn't have focus.
+        // However some of the parameter widgets associated with this monaco editor are visible.
+        // We need to hide them.
+
+        // Solution: Hide the widgets manually.
+        knownParameterHintsWidgets.forEach(widget => {
+            widget.setAttribute('class', widget.className.split(' ').filter(cls => cls !== 'visible').join(' '));
+            if (widget.style.visibility !== 'hidden') {
+                widget.style.visibility = 'hidden';
+            }
+        });
+    }
+
     private updateMargin(editor: monacoEditor.editor.IStandaloneCodeEditor) {
         const editorNode = editor.getDomNode();
         if (editorNode) {

From 1e7649c06758c1ffc50c6f60343df80ff5719a02 Mon Sep 17 00:00:00 2001
From: Rich Chiodo <rchiodo@users.noreply.github.com>
Date: Wed, 16 Oct 2019 10:28:59 -0700
Subject: [PATCH 31/36] Fix max output size to be passed down to rendering
 (#8017)

---
 news/2 Fixes/8010.md                                 | 1 +
 src/datascience-ui/history-react/interactiveCell.tsx | 1 +
 src/datascience-ui/interactive-common/cellOutput.tsx | 2 +-
 src/datascience-ui/native-editor/nativeCell.tsx      | 1 +
 4 files changed, 4 insertions(+), 1 deletion(-)
 create mode 100644 news/2 Fixes/8010.md

diff --git a/news/2 Fixes/8010.md b/news/2 Fixes/8010.md
new file mode 100644
index 000000000000..a0b0378621d2
--- /dev/null
+++ b/news/2 Fixes/8010.md	
@@ -0,0 +1 @@
+Fix python.dataScience.maxOutputSize to be honored again.
diff --git a/src/datascience-ui/history-react/interactiveCell.tsx b/src/datascience-ui/history-react/interactiveCell.tsx
index 41686aaae886..63cc46ac4cb8 100644
--- a/src/datascience-ui/history-react/interactiveCell.tsx
+++ b/src/datascience-ui/history-react/interactiveCell.tsx
@@ -144,6 +144,7 @@ export class InteractiveCell extends React.Component<IInteractiveCellProps> {
                                     baseTheme={this.props.baseTheme}
                                     expandImage={this.props.expandImage}
                                     openLink={this.props.openLink}
+                                    maxTextSize={this.props.maxTextSize}
                                 />
                             </div>
                         </div>
diff --git a/src/datascience-ui/interactive-common/cellOutput.tsx b/src/datascience-ui/interactive-common/cellOutput.tsx
index c775d2ad80cb..fc2094d49fec 100644
--- a/src/datascience-ui/interactive-common/cellOutput.tsx
+++ b/src/datascience-ui/interactive-common/cellOutput.tsx
@@ -254,7 +254,7 @@ export class CellOutput extends React.Component<ICellOutputProps> {
                         data: concatMultilineStringOutput(data as nbformat.MultilineString),
                         isText,
                         isError,
-                        renderWithScrollbars,
+                        renderWithScrollbars: true,
                         extraButton,
                         doubleClick: noop
                     };
diff --git a/src/datascience-ui/native-editor/nativeCell.tsx b/src/datascience-ui/native-editor/nativeCell.tsx
index ff1ee03e549a..066877ffa7ad 100644
--- a/src/datascience-ui/native-editor/nativeCell.tsx
+++ b/src/datascience-ui/native-editor/nativeCell.tsx
@@ -697,6 +697,7 @@ export class NativeCell extends React.Component<INativeCellProps> {
                     baseTheme={this.props.baseTheme}
                     expandImage={this.props.stateController.showPlot}
                     openLink={this.props.stateController.openLink}
+                    maxTextSize={this.props.maxTextSize}
                  />
             );
         }

From 10f3e0af9e48b9030a1e8aa8dc6729dacc0994ac Mon Sep 17 00:00:00 2001
From: Rich Chiodo <rchiodo@users.noreply.github.com>
Date: Wed, 16 Oct 2019 10:29:07 -0700
Subject: [PATCH 32/36] Fix intellisense popping up in the wrong spot when
 first typing in a cell (#8018)

---
 news/2 Fixes/8009.md                             | 1 +
 src/datascience-ui/react-common/monacoEditor.tsx | 4 ++++
 2 files changed, 5 insertions(+)
 create mode 100644 news/2 Fixes/8009.md

diff --git a/news/2 Fixes/8009.md b/news/2 Fixes/8009.md
new file mode 100644
index 000000000000..045df2aba2ce
--- /dev/null
+++ b/news/2 Fixes/8009.md	
@@ -0,0 +1 @@
+Fix intellisense popping up in the wrong spot when first typing in a cell.
diff --git a/src/datascience-ui/react-common/monacoEditor.tsx b/src/datascience-ui/react-common/monacoEditor.tsx
index 4c2d19915c8f..accad9427343 100644
--- a/src/datascience-ui/react-common/monacoEditor.tsx
+++ b/src/datascience-ui/react-common/monacoEditor.tsx
@@ -370,6 +370,10 @@ export class MonacoEditor extends React.Component<IMonacoEditorProps, IMonacoEdi
                         `position: absolute; left: ${rect.left}px; top: ${rect.top}px; width:${width ? width : rect.width}px`);
                 }
             }
+        } else {
+            // If widget parent isn't set yet, try again later
+            this.updateWidgetParent(this.state.editor);
+            this.throttledUpdateWidgetPosition(width);
         }
     }
 

From b2bbb551eaf1c6f8ac6488695e5219133da950c5 Mon Sep 17 00:00:00 2001
From: Rich Chiodo <rchiodo@users.noreply.github.com>
Date: Thu, 17 Oct 2019 13:10:35 -0700
Subject: [PATCH 33/36] Fix markdown disappearing after editing and hitting the
 escape key. (#8047)

* Fix markdown disappearing after editing and hitting the escape key.

* Put back Don's hack
---
 news/2 Fixes/8045.md                          |  1 +
 .../native-editor/nativeCell.tsx              |  1 +
 .../nativeEditorStateController.ts            | 29 ++++++++++++-------
 3 files changed, 20 insertions(+), 11 deletions(-)
 create mode 100644 news/2 Fixes/8045.md

diff --git a/news/2 Fixes/8045.md b/news/2 Fixes/8045.md
new file mode 100644
index 000000000000..aa1a10ecd523
--- /dev/null
+++ b/news/2 Fixes/8045.md	
@@ -0,0 +1 @@
+Fix markdown disappearing after editing and hitting the escape key.
diff --git a/src/datascience-ui/native-editor/nativeCell.tsx b/src/datascience-ui/native-editor/nativeCell.tsx
index 066877ffa7ad..774615f886bb 100644
--- a/src/datascience-ui/native-editor/nativeCell.tsx
+++ b/src/datascience-ui/native-editor/nativeCell.tsx
@@ -374,6 +374,7 @@ export class NativeCell extends React.Component<INativeCellProps> {
         // Unfocus the current cell by giving focus to the cell itself
         if (this.wrapperRef && this.wrapperRef.current && this.isFocused()) {
             e.stopPropagation();
+            this.isCodeCell() ? this.onCodeUnfocused() : this.onMarkdownUnfocused();
             this.props.focusCell(this.cellId, false);
             this.props.stateController.sendCommand(NativeCommandType.Unfocus, 'keyboard');
         }
diff --git a/src/datascience-ui/native-editor/nativeEditorStateController.ts b/src/datascience-ui/native-editor/nativeEditorStateController.ts
index 2c5cafb4fcb3..8dbe1a0bee26 100644
--- a/src/datascience-ui/native-editor/nativeEditorStateController.ts
+++ b/src/datascience-ui/native-editor/nativeEditorStateController.ts
@@ -53,7 +53,7 @@ export class NativeEditorStateController extends MainStateController {
             case InteractiveWindowMessages.NotebookAddCellBelow:
                 this.addNewCell();
                 break;
-            case  InteractiveWindowMessages.DoSave:
+            case InteractiveWindowMessages.DoSave:
                 this.save();
                 break;
 
@@ -278,24 +278,31 @@ export class NativeEditorStateController extends MainStateController {
 
     protected onCodeLostFocus(cellId: string) {
         // Update the cell's source
-        const cell = this.findCell(cellId);
-        if (cell) {
+        const index = this.findCellIndex(cellId);
+        if (index >= 0) {
             // Get the model for the monaco editor
             const monacoId = this.getMonacoId(cellId);
             if (monacoId) {
                 const model = monacoEditor.editor.getModels().find(m => m.id === monacoId);
                 if (model) {
                     const newValue = model.getValue().replace(/\r/g, '');
-                    cell.cell.data.source = cell.inputBlockText = newValue;
+                    const newVMs = [...this.getState().cellVMs];
+
+                    // Update our state
+                    newVMs[index] = {
+                        ...newVMs[index],
+                        cell: {
+                            ...newVMs[index].cell,
+                            data: {
+                                ...newVMs[index].cell.data,
+                                source: newValue
+                            }
+                        }
+                    };
+
+                    this.setState({ cellVMs: newVMs });
                 }
             }
         }
-
-        // Special case markdown in the edit cell. Submit it.
-        if (cell && cell.cell.id === Identifiers.EditCellId && cell.cell.data.cell_type === 'markdown') {
-            const code = cell.inputBlockText;
-            cell.cell.data.source = cell.inputBlockText = '';
-            this.submitInput(code, cell);
-        }
     }
 }

From 528d664a9932be1d112087fd6688f8f7d2260031 Mon Sep 17 00:00:00 2001
From: Don Jayamanne <don.jayamanne@yahoo.com>
Date: Fri, 18 Oct 2019 09:57:19 -0700
Subject: [PATCH 34/36] Fixes to allowing users to open a diff view for ipynb
 files (#8081)

* Fixes to allowing users to open a diff view
* Updated code review comments
---
 .../interactive-ipynb/nativeEditorProvider.ts | 90 ++++++++++++++++---
 .../nativeEditorProvider.unit.test.ts         | 15 +++-
 2 files changed, 87 insertions(+), 18 deletions(-)

diff --git a/src/client/datascience/interactive-ipynb/nativeEditorProvider.ts b/src/client/datascience/interactive-ipynb/nativeEditorProvider.ts
index aed3f1efd005..df1d675af51b 100644
--- a/src/client/datascience/interactive-ipynb/nativeEditorProvider.ts
+++ b/src/client/datascience/interactive-ipynb/nativeEditorProvider.ts
@@ -3,7 +3,7 @@
 'use strict';
 import { inject, injectable } from 'inversify';
 import * as path from 'path';
-import { TextDocument, Uri } from 'vscode';
+import { TextDocument, TextEditor, Uri } from 'vscode';
 
 import { ICommandManager, IDocumentManager, IWorkspaceService } from '../../common/application/types';
 import { JUPYTER_LANGUAGE } from '../../common/constants';
@@ -21,7 +21,6 @@ export class NativeEditorProvider implements INotebookEditorProvider, IAsyncDisp
     private executedEditors: Set<string> = new Set<string>();
     private notebookCount: number = 0;
     private openedNotebookCount: number = 0;
-
     constructor(
         @inject(IServiceContainer) private serviceContainer: IServiceContainer,
         @inject(IAsyncDisposableRegistry) asyncRegistry: IAsyncDisposableRegistry,
@@ -45,16 +44,14 @@ export class NativeEditorProvider implements INotebookEditorProvider, IAsyncDisp
             findFilesPromise.then(r => this.notebookCount += r.length);
         }
 
-        // Listen to document open commands. We use this to launch an ipynb editor
-        const disposable = this.documentManager.onDidOpenTextDocument(this.onOpenedDocument);
-        this.disposables.push(disposable);
+        this.disposables.push(this.documentManager.onDidChangeActiveTextEditor(this.onDidChangeActiveTextEditorHandler.bind(this)));
 
         // Since we may have activated after a document was opened, also run open document for all documents.
         // This needs to be async though. Iterating over all of these in the .ctor is crashing the extension
         // host, so postpone till after the ctor is finished.
         setTimeout(() => {
             if (this.documentManager.textDocuments && this.documentManager.textDocuments.forEach) {
-                this.documentManager.textDocuments.forEach(this.onOpenedDocument);
+                this.documentManager.textDocuments.forEach(doc => this.openNotebookAndCloseEditor(doc, false));
             }
         }, 0);
 
@@ -132,6 +129,19 @@ export class NativeEditorProvider implements INotebookEditorProvider, IAsyncDisp
             purpose: Identifiers.HistoryPurpose  // Share the same one as the interactive window. Just need a new session
         };
     }
+    /**
+     * Open ipynb files when user opens an ipynb file.
+     *
+     * @private
+     * @memberof NativeEditorProvider
+     */
+    private onDidChangeActiveTextEditorHandler(editor?: TextEditor){
+        // I we're a source control diff view, then ignore this editor.
+        if (!editor || this.isEditorPartOfDiffView(editor)){
+            return;
+        }
+        this.openNotebookAndCloseEditor(editor.document, true).ignoreErrors();
+    }
 
     private async create(file: Uri, contents: string): Promise<INotebookEditor> {
         const editor = this.serviceContainer.get<INotebookEditor>(INotebookEditor);
@@ -178,27 +188,79 @@ export class NativeEditorProvider implements INotebookEditorProvider, IAsyncDisp
         return Uri.file(`${localize.DataScience.untitledNotebookFileName()}-${number}`);
     }
 
-    private onOpenedDocument = async (document: TextDocument) => {
+    private openNotebookAndCloseEditor = async (document: TextDocument, closeDocumentBeforeOpeningNotebook: boolean) => {
         // See if this is an ipynb file
-        if (this.isNotebook(document) && this.configuration.getSettings().datascience.useNotebookEditor) {
+        if (this.isNotebook(document) && this.configuration.getSettings().datascience.useNotebookEditor &&
+            !this.activeEditors.has(document.uri.fsPath)) {
             try {
-                const contents = document.getText();
+                const contents = document.  getText();
                 const uri = document.uri;
+                const closeActiveEditorCommand = 'workbench.action.closeActiveEditor';
+
+                if (closeDocumentBeforeOpeningNotebook) {
+                    if (!this.documentManager.activeTextEditor || this.documentManager.activeTextEditor.document !== document){
+                        await this.documentManager.showTextDocument(document);
+                    }
+                    await this.cmdManager.executeCommand(closeActiveEditorCommand);
+                }
 
                 // Open our own editor.
                 await this.open(uri, contents);
 
-                // Then switch back to the ipynb and close it.
-                // If we don't do it in this order, the close will switch to the wrong item
-                await this.documentManager.showTextDocument(document);
-                const command = 'workbench.action.closeActiveEditor';
-                await this.cmdManager.executeCommand(command);
+                if (!closeDocumentBeforeOpeningNotebook){
+                    // Then switch back to the ipynb and close it.
+                    // If we don't do it in this order, the close will switch to the wrong item
+                    await this.documentManager.showTextDocument(document);
+                    await this.cmdManager.executeCommand(closeActiveEditorCommand);
+                }
             } catch (e) {
                 return this.dataScienceErrorHandler.handleError(e);
             }
         }
     }
+    /**
+     * Check if user is attempting to compare two ipynb files.
+     * If yes, then return `true`, else `false`.
+     *
+     * @private
+     * @param {TextEditor} editor
+     * @memberof NativeEditorProvider
+     */
+    private isEditorPartOfDiffView(editor?: TextEditor){
+        if (!editor){
+            return false;
+        }
+        // There's no easy way to determine if the user is openeing a diff view.
+        // One simple way is to check if there are 2 editor opened, and if both editors point to the same file
+        // One file with the `file` scheme and the other with the `git` scheme.
+        if (this.documentManager.visibleTextEditors.length <= 1){
+            return false;
+        }
+
+        // If we have both `git` & `file` schemes for the same file, then we're most likely looking at a diff view.
+        // Also ensure both editors are in the same view column.
+        // Possible we have a git diff view (with two editors git and file scheme), and we open the file view
+        // on the side (different view column).
+        const gitSchemeEditor = this.documentManager.visibleTextEditors.find(editorUri =>
+                                editorUri.document.uri.scheme === 'git' &&
+                                this.fileSystem.arePathsSame(editorUri.document.uri.fsPath, editor.document.uri.fsPath));
+
+        if (!gitSchemeEditor){
+            return false;
+        }
 
+        const fileSchemeEditor = this.documentManager.visibleTextEditors.find(editorUri =>
+                                    editorUri.document.uri.scheme === 'file' &&
+                                    this.fileSystem.arePathsSame(editorUri.document.uri.fsPath, editor.document.uri.fsPath) &&
+                                    editorUri.viewColumn === gitSchemeEditor.viewColumn);
+        if (!fileSchemeEditor){
+            return false;
+        }
+
+        // Also confirm the document we have passed in, belongs to one of the editors.
+        // If its not, then its another document (that is not in the diff view).
+        return gitSchemeEditor === editor || fileSchemeEditor === editor;
+    }
     private isNotebook(document: TextDocument) {
         // Only support file uris (we don't want to automatically open any other ipynb file from another resource as a notebook).
         // E.g. when opening a document for comparison, the scheme is `git`, in live share the scheme is `vsls`.
diff --git a/src/test/datascience/interactive-ipynb/nativeEditorProvider.unit.test.ts b/src/test/datascience/interactive-ipynb/nativeEditorProvider.unit.test.ts
index 5b015329e447..96ce959e9f2d 100644
--- a/src/test/datascience/interactive-ipynb/nativeEditorProvider.unit.test.ts
+++ b/src/test/datascience/interactive-ipynb/nativeEditorProvider.unit.test.ts
@@ -8,7 +8,7 @@
 import { expect } from 'chai';
 import { instance, mock, when } from 'ts-mockito';
 import * as typemoq from 'typemoq';
-import { EventEmitter, TextDocument, Uri } from 'vscode';
+import { EventEmitter, TextDocument, TextEditor, Uri } from 'vscode';
 import { CommandManager } from '../../../client/common/application/commandManager';
 import { DocumentManager } from '../../../client/common/application/documentManager';
 import { ICommandManager, IDocumentManager, IWorkspaceService } from '../../../client/common/application/types';
@@ -65,11 +65,17 @@ suite('Data Science - Native Editor Provider', () => {
         textDocument.setup(t => t.getText()).returns(() => content);
         return textDocument.object;
     }
+    function createTextEditor(doc: TextDocument) {
+        const textEditor = typemoq.Mock.ofType<TextEditor>();
+        textEditor.setup(e => e.document).returns(() => doc);
+        return textEditor.object;
+    }
     async function testAutomaticallyOpeningNotebookEditorWhenOpeningFiles(uri: Uri, shouldOpenNotebookEditor: boolean) {
-        const eventEmitter = new EventEmitter<TextDocument>();
+        const eventEmitter = new EventEmitter<TextEditor>();
         const editor = typemoq.Mock.ofType<INotebookEditor>();
         when(configService.getSettings()).thenReturn({ datascience: { useNotebookEditor: true } } as any);
-        when(doctManager.onDidOpenTextDocument).thenReturn(eventEmitter.event);
+        when(doctManager.onDidChangeActiveTextEditor).thenReturn(eventEmitter.event);
+        when(doctManager.visibleTextEditors).thenReturn([]);
         editor.setup(e => e.closed).returns(() => new EventEmitter<INotebookEditor>().event);
         editor.setup(e => e.executed).returns(() => new EventEmitter<INotebookEditor>().event);
         editor.setup(e => (e as any).then).returns(() => undefined);
@@ -90,7 +96,8 @@ suite('Data Science - Native Editor Provider', () => {
 
         // Open a text document.
         const textDoc = createTextDocument(uri, 'hello');
-        eventEmitter.fire(textDoc);
+        const textEditor = createTextEditor(textDoc);
+        eventEmitter.fire(textEditor);
 
         // wait for callbacks to get executed.
         await sleep(1);

From 4c783afab7173d9eb6fc36161afd58926efc281b Mon Sep 17 00:00:00 2001
From: Don Jayamanne <don.jayamanne@yahoo.com>
Date: Mon, 21 Oct 2019 11:22:32 -0700
Subject: [PATCH 35/36] Ensure metadata for notebooks are always present
 (#8109)

* Ensure metadata for notebooks are always present
* Let storage run in background
* Refactor
* Address code review
---
 .../interactive-common/interactiveBase.ts     |  2 +-
 .../interactive-ipynb/nativeEditor.ts         | 50 +++++++++++++++++--
 .../nativeEditor.functional.test.tsx          |  4 +-
 3 files changed, 50 insertions(+), 6 deletions(-)

diff --git a/src/client/datascience/interactive-common/interactiveBase.ts b/src/client/datascience/interactive-common/interactiveBase.ts
index 8440bfc58ac8..247f7d1938c8 100644
--- a/src/client/datascience/interactive-common/interactiveBase.ts
+++ b/src/client/datascience/interactive-common/interactiveBase.ts
@@ -102,7 +102,7 @@ export abstract class InteractiveBase extends WebViewHost<IInteractiveWindowMapp
         @unmanaged() cssGenerator: ICodeCssGenerator,
         @unmanaged() themeFinder: IThemeFinder,
         @unmanaged() private statusProvider: IStatusProvider,
-        @unmanaged() private jupyterExecution: IJupyterExecution,
+        @unmanaged() protected jupyterExecution: IJupyterExecution,
         @unmanaged() protected fileSystem: IFileSystem,
         @unmanaged() protected configuration: IConfigurationService,
         @unmanaged() protected jupyterExporter: INotebookExporter,
diff --git a/src/client/datascience/interactive-ipynb/nativeEditor.ts b/src/client/datascience/interactive-ipynb/nativeEditor.ts
index a5e94ac1cc36..d03b6bf95148 100644
--- a/src/client/datascience/interactive-ipynb/nativeEditor.ts
+++ b/src/client/datascience/interactive-ipynb/nativeEditor.ts
@@ -429,6 +429,33 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
         // Then save the contents. We'll stick our cells back into this format when we save
         if (json) {
             this.notebookJson = json;
+        } else {
+            const pythonNumber = await this.extractPythonMainVersion(this.notebookJson);
+            // Use this to build our metadata object
+            // Use these as the defaults unless we have been given some in the options.
+            const metadata: nbformat.INotebookMetadata = {
+                language_info: {
+                    name: 'python',
+                    codemirror_mode: {
+                        name: 'ipython',
+                        version: pythonNumber
+                    }
+                },
+                orig_nbformat: 2,
+                file_extension: '.py',
+                mimetype: 'text/x-python',
+                name: 'python',
+                npconvert_exporter: 'python',
+                pygments_lexer: `ipython${pythonNumber}`,
+                version: pythonNumber
+            };
+
+            // Default notebook data.
+            this.notebookJson = {
+                nbformat: 4,
+                nbformat_minor: 2,
+                metadata: metadata
+            };
         }
 
         // Extract cells from the json
@@ -586,8 +613,10 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
         if (!fastDeepEqual(this.visibleCells, cells)) {
             this.visibleCells = cells;
 
-            // Save our dirty state in the storage for reopen later
-            await this.storeContents(this.generateNotebookContent(cells));
+            // Save our dirty state in the storage for reopen later.
+            // Do not block current code, hence let this run in the background.
+            this.storeContents(this.generateNotebookContent(cells))
+                .catch(ex => traceError('Failed to generate notebook content to store in state', ex));
 
             // Indicate dirty
             await this.setDirty();
@@ -652,10 +681,25 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
         };
     }
 
+    private async extractPythonMainVersion(notebookData: Partial<nbformat.INotebookContent>): Promise<number> {
+        if (notebookData && notebookData.metadata &&
+            notebookData.metadata.language_info &&
+            notebookData.metadata.language_info.codemirror_mode &&
+            // tslint:disable-next-line: no-any
+            typeof (notebookData.metadata.language_info.codemirror_mode as any).version === 'number'){
+
+                // tslint:disable-next-line: no-any
+            return (notebookData.metadata.language_info.codemirror_mode as any).version;
+        }
+        // Use the active interpreter
+        const usableInterpreter = await this.jupyterExecution.getUsableJupyterPython();
+        return usableInterpreter && usableInterpreter.version ? usableInterpreter.version.major : 3;
+    }
+
     private generateNotebookContent(cells: ICell[]): string {
         // Reuse our original json except for the cells.
         const json = {
-            ...this.notebookJson,
+            ...(this.notebookJson as nbformat.INotebookContent),
             cells: cells.map(c => this.fixupCell(c.data))
         };
         return JSON.stringify(json, null, this.indentAmount);
diff --git a/src/test/datascience/nativeEditor.functional.test.tsx b/src/test/datascience/nativeEditor.functional.test.tsx
index b764ad8ababe..4cfffc2d7e8f 100644
--- a/src/test/datascience/nativeEditor.functional.test.tsx
+++ b/src/test/datascience/nativeEditor.functional.test.tsx
@@ -262,7 +262,7 @@ suite('DataScience Native Editor', () => {
             const runAllButton = findButton(wrapper, NativeEditor, 3);
             await waitForMessageResponse(ioc, () => runAllButton!.simulate('click'));
 
-            await waitForUpdate(wrapper, NativeEditor, 16);
+            await waitForUpdate(wrapper, NativeEditor, 15);
 
             verifyHtmlOnCell(wrapper, 'NativeCell', `1`, 0);
             verifyHtmlOnCell(wrapper, 'NativeCell', `2`, 1);
@@ -285,7 +285,7 @@ suite('DataScience Native Editor', () => {
             // Run everything
             let runAllButton = findButton(wrapper, NativeEditor, 3);
             await waitForMessageResponse(ioc, () => runAllButton!.simulate('click'));
-            await waitForUpdate(wrapper, NativeEditor, 16);
+            await waitForUpdate(wrapper, NativeEditor, 15);
 
             // Close editor. Should still have the server up
             await closeNotebook(editor, wrapper);

From 3eeadfbe05ed84a0d0c77469db672f8db0e536e7 Mon Sep 17 00:00:00 2001
From: Don Jayamanne <don.jayamanne@yahoo.com>
Date: Mon, 21 Oct 2019 14:26:20 -0700
Subject: [PATCH 36/36] Do not auto save if notebook is untitled (#8095)

* Do not auto save if notebook is untitled
* Remove redundant code
---
 .../datascience/interactive-ipynb/autoSaveService.ts  |  2 +-
 .../datascience/interactive-ipynb/nativeEditor.ts     | 11 ++++++-----
 src/client/datascience/types.ts                       |  4 ++++
 3 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/src/client/datascience/interactive-ipynb/autoSaveService.ts b/src/client/datascience/interactive-ipynb/autoSaveService.ts
index 61f69e225490..826b2a7c0c1e 100644
--- a/src/client/datascience/interactive-ipynb/autoSaveService.ts
+++ b/src/client/datascience/interactive-ipynb/autoSaveService.ts
@@ -120,7 +120,7 @@ export class AutoSaveService implements IInteractiveWindowListener {
     private save() {
         this.clearTimeout();
         const notebook = this.getNotebook();
-        if (notebook && notebook.isDirty) {
+        if (notebook && notebook.isDirty && !notebook.isUntitled) {
             // Notify webview to perform a save.
             this.postEmitter.fire({ message: InteractiveWindowMessages.DoSave, payload: undefined });
         } else {
diff --git a/src/client/datascience/interactive-ipynb/nativeEditor.ts b/src/client/datascience/interactive-ipynb/nativeEditor.ts
index d03b6bf95148..846e304d9851 100644
--- a/src/client/datascience/interactive-ipynb/nativeEditor.ts
+++ b/src/client/datascience/interactive-ipynb/nativeEditor.ts
@@ -151,6 +151,10 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
         return this._file;
     }
 
+    public get isUntitled(): boolean {
+        const baseName = path.basename(this.file.fsPath);
+        return baseName.includes(localize.DataScience.untitledNotebookFileName());
+    }
     public dispose(): void {
         super.dispose();
         this.close().ignoreErrors();
@@ -711,9 +715,7 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
             let isDirty = this._dirty;
 
             // Ask user for a save as dialog if no title
-            const baseName = path.basename(this.file.fsPath);
-            const isUntitled = baseName.includes(localize.DataScience.untitledNotebookFileName());
-            if (isUntitled) {
+            if (this.isUntitled) {
                 const filtersKey = localize.DataScience.dirtyNotebookDialogFilter();
                 const filtersObject: { [name: string]: string[] } = {};
                 filtersObject[filtersKey] = ['ipynb'];
@@ -721,8 +723,7 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
 
                 fileToSaveTo = await this.applicationShell.showSaveDialog({
                     saveLabel: localize.DataScience.dirtyNotebookDialogTitle(),
-                    filters: filtersObject,
-                    defaultUri: isUntitled ? undefined : this.file
+                    filters: filtersObject
                 });
             }
 
diff --git a/src/client/datascience/types.ts b/src/client/datascience/types.ts
index 3e75c8b57e31..00b478b4f655 100644
--- a/src/client/datascience/types.ts
+++ b/src/client/datascience/types.ts
@@ -251,6 +251,10 @@ export interface INotebookEditor extends IInteractiveBase {
     executed: Event<INotebookEditor>;
     modified: Event<INotebookEditor>;
     saved: Event<INotebookEditor>;
+    /**
+     * Is this notebook representing an untitled file which has never been saved yet.
+     */
+    readonly isUntitled: boolean;
     /**
      * `true` if there are unpersisted changes.
      */