public async startTask(
     executable: string,
     preCommandArgs: string[],
     command: string,
     args: string[],
     cwd: string
 ): Promise<void> {
     args = preCommandArgs.concat(command, ...args);
     const terminal = window.createTerminal('Cargo Task');
     this._runningTerminal = terminal;
     const shell = await this._shellProvider.getValue();
     if (shell === undefined) {
         return;
     }
     const setEnvironmentVariables = () => {
         const cargoEnv = this._configuration.getCargoEnv();
         // Set environment variables
         for (const name in cargoEnv) {
             if (name in cargoEnv) {
                 const value = cargoEnv[name];
                 terminal.sendText(getCommandToSetEnvVar(shell, name, value));
             }
         }
     };
     setEnvironmentVariables();
     // Change the current directory to a specified directory
     this._runningTerminal.sendText(getCommandToChangeWorkingDirectory(shell, cwd));
     // Start a requested command
     this._runningTerminal.sendText(getCommandForArgs(shell, [executable, ...args]));
     this._runningTerminal.show(true);
 }

 const runCommandInIntegratedTerminal = (args: string[], cwd: string) => {
   if (terminal === null) {
     terminal = window.createTerminal('sbt');
     // start sbt
     terminal.sendText('sbt', true);
   }
   terminal.show();
   terminal.sendText(args.join(' '));
 };

function runCommandInIntegratedTerminal(args: string[], cwd: string): void {
	const cmd_args = Array.from(args);
	if (!terminal) {
		terminal = window.createTerminal('npm');
	}
	terminal.show();
	if (cwd) {
		terminal.sendText(['cd', cwd].join(' '));
	}
	cmd_args.splice(0, 0, getNpmBin());
	terminal.sendText(cmd_args.join(' '));
}

			const reg1 = window.onDidChangeTerminalDimensions(async (event: TerminalDimensionsChangeEvent) => {
				assert.equal(event.terminal, terminal1);
				assert.equal(typeof event.dimensions.columns, 'number');
				assert.equal(typeof event.dimensions.rows, 'number');
				assert.ok(event.dimensions.columns > 0);
				assert.ok(event.dimensions.rows > 0);
				reg1.dispose();
				let terminal2: Terminal;
				const reg2 = window.onDidOpenTerminal((newTerminal) => {
					// This is guarantees to fire before dimensions change event
					if (newTerminal !== terminal1) {
						terminal2 = newTerminal;
						reg2.dispose();
					}
				});
				let firstCalled = false;
				let secondCalled = false;
				const reg3 = window.onDidChangeTerminalDimensions((event: TerminalDimensionsChangeEvent) => {
					if (event.terminal === terminal1) {
						// The original terminal should fire dimension change after a split
						firstCalled = true;
					} else if (event.terminal !== terminal1) {
						// The new split terminal should fire dimension change
						secondCalled = true;
					}
					if (firstCalled && secondCalled) {
						terminal1.dispose();
						terminal2.dispose();
						reg3.dispose();
						done();
					}
				});
				await timeout(500);
				commands.executeCommand('workbench.action.terminal.split');
			});

			const reg2 = renderer.onDidChangeMaximumDimensions(dimensions => {
				assert.ok(dimensions.columns > 0);
				assert.ok(dimensions.rows > 0);
				reg2.dispose();
				const reg3 = window.onDidCloseTerminal(() => {
					reg3.dispose();
					done();
				});
				terminal.dispose();
			});

				const reg3 = window.onDidChangeTerminalDimensions((event: TerminalDimensionsChangeEvent) => {
					if (event.terminal === terminal1) {
						// The original terminal should fire dimension change after a split
						firstCalled = true;
					} else if (event.terminal !== terminal1) {
						// The new split terminal should fire dimension change
						secondCalled = true;
					}
					if (firstCalled && secondCalled) {
						terminal1.dispose();
						terminal2.dispose();
						reg3.dispose();
						done();
					}
				});

		test('terminal renderers should get maximum dimensions set when shown', (done) => {
			let terminal: Terminal;
			const reg1 = window.onDidOpenTerminal(term => {
				reg1.dispose();
				term.show();
				terminal = term;
			});
			const renderer = window.createTerminalRenderer('foo');
			const reg2 = renderer.onDidChangeMaximumDimensions(dimensions => {
				assert.ok(dimensions.columns > 0);
				assert.ok(dimensions.rows > 0);
				reg2.dispose();
				const reg3 = window.onDidCloseTerminal(() => {
					reg3.dispose();
					done();
				});
				terminal.dispose();
			});
		});

    private ensureTerminal(cwd: string): Terminal {
        if (this._terminal === undefined) {
            this._terminal = window.createTerminal(extensionTerminalName);
            this._disposable = window.onDidCloseTerminal((e: Terminal) => {
                if (e.name === extensionTerminalName) {
                    this._terminal = undefined;
                    this._disposable!.dispose();
                    this._disposable = undefined;
                }
            }, this);

            Container.context.subscriptions.push(this._disposable);
            this._terminalCwd = undefined;
        }

        if (this._terminalCwd !== cwd) {
            this._terminal.sendText(`cd "${cwd}"`, true);
            this._terminalCwd = cwd;
        }

        return this._terminal;
    }

 public stopRunningTask(): void {
     if (this._runningTerminal) {
         this._runningTerminal.dispose();
         this._runningTerminal = undefined;
     }
 }

export function deactivate() {
	if (terminal) {
		terminal.dispose();
	}
}