node-pty 0.11.0-beta9 → 1.1.0-beta1

package/src/win/winpty.cc

@@ -9,6 +9,7 @@
  */
 
 #include <iostream>
+#include <map>
 #include <nan.h>
 #include <Shlwapi.h> // PathCombine, PathIsRelative
 #include <sstream>
@@ -37,21 +38,25 @@ static volatile LONG ptyCounter;
 * Helpers
 */
 
-static winpty_t *get_pipe_handle(int handle) {
+/** Keeps track of the handles created by PtyStartProcess */
+static std::map<DWORD, HANDLE> createdHandles;
+
+static winpty_t *get_pipe_handle(DWORD pid) {
   for (size_t i = 0; i < ptyHandles.size(); ++i) {
     winpty_t *ptyHandle = ptyHandles[i];
-    int current = (int)winpty_agent_process(ptyHandle);
-    if (current == handle) {
+    HANDLE current = winpty_agent_process(ptyHandle);
+    if (GetProcessId(current) == pid) {
       return ptyHandle;
     }
   }
   return nullptr;
 }
 
-static bool remove_pipe_handle(int handle) {
+static bool remove_pipe_handle(DWORD pid) {
   for (size_t i = 0; i < ptyHandles.size(); ++i) {
     winpty_t *ptyHandle = ptyHandles[i];
-    if ((int)winpty_agent_process(ptyHandle) == handle) {
+    HANDLE current = winpty_agent_process(ptyHandle);
+    if (GetProcessId(current) == pid) {
       winpty_free(ptyHandle);
       ptyHandles.erase(ptyHandles.begin() + i);
       ptyHandle = nullptr;
@@ -62,11 +67,10 @@ static bool remove_pipe_handle(int handle) {
 }
 
 void throw_winpty_error(const char *generalMsg, winpty_error_ptr_t error_ptr) {
-  std::stringstream why;
+  std::wstringstream why;
   std::wstring msg(winpty_error_msg(error_ptr));
-  std::string msg_(msg.begin(), msg.end());
-  why << generalMsg << ": " << msg_;
-  Nan::ThrowError(why.str().c_str());
+  why << generalMsg << ": " << msg;
+  Nan::ThrowError(path_util::from_wstring(why.str().c_str()));
   winpty_error_free(error_ptr);
 }
 
@@ -75,13 +79,24 @@ static NAN_METHOD(PtyGetExitCode) {
 
   if (info.Length() != 1 ||
       !info[0]->IsNumber()) {
-    Nan::ThrowError("Usage: pty.getExitCode(pidHandle)");
+    Nan::ThrowError("Usage: pty.getExitCode(pid)");
+    return;
+  }
+
+  DWORD pid = info[0]->Uint32Value(Nan::GetCurrentContext()).FromJust();
+  HANDLE handle = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
+  if (handle == NULL) {
+    info.GetReturnValue().Set(Nan::New<v8::Number>(-1));
     return;
   }
 
   DWORD exitCode = 0;
-  GetExitCodeProcess((HANDLE)info[0]->IntegerValue(Nan::GetCurrentContext()).FromJust(), &exitCode);
+  BOOL success = GetExitCodeProcess(handle, &exitCode);
+  if (success == FALSE) {
+    exitCode = -1;
+  }
 
+  CloseHandle(handle);
   info.GetReturnValue().Set(Nan::New<v8::Number>(exitCode));
 }
 
@@ -94,8 +109,7 @@ static NAN_METHOD(PtyGetProcessList) {
     return;
   }
 
-  int pid = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
-
+  DWORD pid = info[0]->Uint32Value(Nan::GetCurrentContext()).FromJust();
   winpty_t *pc = get_pipe_handle(pid);
   if (pc == nullptr) {
     info.GetReturnValue().Set(Nan::New<v8::Array>(0));
@@ -104,9 +118,13 @@ static NAN_METHOD(PtyGetProcessList) {
   int processList[64];
   const int processCount = 64;
   int actualCount = winpty_get_console_process_list(pc, processList, processCount, nullptr);
-
-  v8::Local<v8::Array> result = Nan::New<v8::Array>(actualCount);
-  for (uint32_t i = 0; i < actualCount; i++) {
+  if (actualCount <= 0) {
+    info.GetReturnValue().Set(Nan::New<v8::Array>(0));
+    return;
+  }
+  uint32_t actualCountSize = static_cast<uint32_t>(actualCount);
+  v8::Local<v8::Array> result = Nan::New<v8::Array>(actualCountSize);
+  for (uint32_t i = 0; i < actualCountSize; i++) {
     Nan::Set(result, i, Nan::New<v8::Number>(processList[i]));
   }
   info.GetReturnValue().Set(result);
@@ -127,8 +145,6 @@ static NAN_METHOD(PtyStartProcess) {
     return;
   }
 
-  std::stringstream why;
-
   const wchar_t *filename = path_util::to_wstring(Nan::Utf8String(info[0]));
   const wchar_t *cmdline = path_util::to_wstring(Nan::Utf8String(info[1]));
   const wchar_t *cwd = path_util::to_wstring(Nan::Utf8String(info[3]));
@@ -157,12 +173,14 @@ static NAN_METHOD(PtyStartProcess) {
     shellpath = filename;
   }
 
-  std::string shellpath_(shellpath.begin(), shellpath.end());
-
   if (shellpath.empty() || !path_util::file_exists(shellpath)) {
-    why << "File not found: " << shellpath_;
-    Nan::ThrowError(why.str().c_str());
-    goto cleanup;
+    std::wstringstream why;
+    why << "File not found: " << shellpath;
+    Nan::ThrowError(path_util::from_wstring(why.str().c_str()));
+    delete filename;
+    delete cmdline;
+    delete cwd;
+    return;
   }
 
   int cols = info[4]->Int32Value(Nan::GetCurrentContext()).FromJust();
@@ -177,7 +195,10 @@ static NAN_METHOD(PtyStartProcess) {
   winpty_config_t* winpty_config = winpty_config_new(0, &error_ptr);
   if (winpty_config == nullptr) {
     throw_winpty_error("Error creating WinPTY config", error_ptr);
-    goto cleanup;
+    delete filename;
+    delete cmdline;
+    delete cwd;
+    return;
   }
   winpty_error_free(error_ptr);
 
@@ -189,18 +210,22 @@ static NAN_METHOD(PtyStartProcess) {
   winpty_config_free(winpty_config);
   if (pc == nullptr) {
     throw_winpty_error("Error launching WinPTY agent", error_ptr);
-    goto cleanup;
+    delete filename;
+    delete cmdline;
+    delete cwd;
+    return;
   }
   winpty_error_free(error_ptr);
 
-  // Save pty struct for later use
-  ptyHandles.insert(ptyHandles.end(), pc);
-
   // Create winpty spawn config
   winpty_spawn_config_t* config = winpty_spawn_config_new(WINPTY_SPAWN_FLAG_AUTO_SHUTDOWN, shellpath.c_str(), cmdline, cwd, env.c_str(), &error_ptr);
   if (config == nullptr) {
     throw_winpty_error("Error creating WinPTY spawn config", error_ptr);
-    goto cleanup;
+    winpty_free(pc);
+    delete filename;
+    delete cmdline;
+    delete cwd;
+    return;
   }
   winpty_error_free(error_ptr);
 
@@ -210,32 +235,68 @@ static NAN_METHOD(PtyStartProcess) {
   winpty_spawn_config_free(config);
   if (!spawnSuccess) {
     throw_winpty_error("Unable to start terminal process", error_ptr);
-    goto cleanup;
+    if (handle) {
+      CloseHandle(handle);
+    }
+    winpty_free(pc);
+    delete filename;
+    delete cmdline;
+    delete cwd;
+    return;
   }
   winpty_error_free(error_ptr);
 
-  // Set return values
+  LPCWSTR coninPipeName = winpty_conin_name(pc);
+  std::string coninPipeNameStr(path_util::from_wstring(coninPipeName));
+  if (coninPipeNameStr.empty()) {
+    Nan::ThrowError("Failed to initialize winpty conin");
+    CloseHandle(handle);
+    winpty_free(pc);
+    delete filename;
+    delete cmdline;
+    delete cwd;
+    return;
+  }
+
+  LPCWSTR conoutPipeName = winpty_conout_name(pc);
+  std::string conoutPipeNameStr(path_util::from_wstring(conoutPipeName));
+  if (conoutPipeNameStr.empty()) {
+    Nan::ThrowError("Failed to initialize winpty conout");
+    CloseHandle(handle);
+    winpty_free(pc);
+    delete filename;
+    delete cmdline;
+    delete cwd;
+    return;
+  }
+
+  DWORD innerPid = GetProcessId(handle);
+  if (createdHandles[innerPid]) {
+    std::stringstream why;
+    why << "There is already a process with innerPid " << innerPid;
+    Nan::ThrowError(why.str().c_str());
+    CloseHandle(handle);
+    winpty_free(pc);
+    delete filename;
+    delete cmdline;
+    delete cwd;
+    return;
+  }
+  createdHandles[innerPid] = handle;
+
+  // Save pty struct for later use
+  ptyHandles.push_back(pc);
+
   v8::Local<v8::Object> marshal = Nan::New<v8::Object>();
-  Nan::Set(marshal, Nan::New<v8::String>("innerPid").ToLocalChecked(), Nan::New<v8::Number>((int)GetProcessId(handle)));
-  Nan::Set(marshal, Nan::New<v8::String>("innerPidHandle").ToLocalChecked(), Nan::New<v8::Number>((int)handle));
-  Nan::Set(marshal, Nan::New<v8::String>("pid").ToLocalChecked(), Nan::New<v8::Number>((int)winpty_agent_process(pc)));
+  DWORD pid = GetProcessId(winpty_agent_process(pc));
+  Nan::Set(marshal, Nan::New<v8::String>("innerPid").ToLocalChecked(), Nan::New<v8::Number>(static_cast<double>(innerPid)));
+  Nan::Set(marshal, Nan::New<v8::String>("pid").ToLocalChecked(), Nan::New<v8::Number>(static_cast<double>(pid)));
   Nan::Set(marshal, Nan::New<v8::String>("pty").ToLocalChecked(), Nan::New<v8::Number>(InterlockedIncrement(&ptyCounter)));
   Nan::Set(marshal, Nan::New<v8::String>("fd").ToLocalChecked(), Nan::New<v8::Number>(-1));
-  {
-    LPCWSTR coninPipeName = winpty_conin_name(pc);
-    std::wstring coninPipeNameWStr(coninPipeName);
-    std::string coninPipeNameStr(coninPipeNameWStr.begin(), coninPipeNameWStr.end());
-    Nan::Set(marshal, Nan::New<v8::String>("conin").ToLocalChecked(), Nan::New<v8::String>(coninPipeNameStr).ToLocalChecked());
-    LPCWSTR conoutPipeName = winpty_conout_name(pc);
-    std::wstring conoutPipeNameWStr(conoutPipeName);
-    std::string conoutPipeNameStr(conoutPipeNameWStr.begin(), conoutPipeNameWStr.end());
-    Nan::Set(marshal, Nan::New<v8::String>("conout").ToLocalChecked(), Nan::New<v8::String>(conoutPipeNameStr).ToLocalChecked());
-  }
+  Nan::Set(marshal, Nan::New<v8::String>("conin").ToLocalChecked(), Nan::New<v8::String>(coninPipeNameStr).ToLocalChecked());
+  Nan::Set(marshal, Nan::New<v8::String>("conout").ToLocalChecked(), Nan::New<v8::String>(conoutPipeNameStr).ToLocalChecked());
   info.GetReturnValue().Set(marshal);
 
-  goto cleanup;
-
-cleanup:
   delete filename;
   delete cmdline;
   delete cwd;
@@ -252,11 +313,11 @@ static NAN_METHOD(PtyResize) {
     return;
   }
 
-  int handle = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  DWORD pid = info[0]->Uint32Value(Nan::GetCurrentContext()).FromJust();
   int cols = info[1]->Int32Value(Nan::GetCurrentContext()).FromJust();
   int rows = info[2]->Int32Value(Nan::GetCurrentContext()).FromJust();
 
-  winpty_t *pc = get_pipe_handle(handle);
+  winpty_t *pc = get_pipe_handle(pid);
 
   if (pc == nullptr) {
     Nan::ThrowError("The pty doesn't appear to exist");
@@ -277,20 +338,23 @@ static NAN_METHOD(PtyKill) {
   if (info.Length() != 2 ||
       !info[0]->IsNumber() ||
       !info[1]->IsNumber()) {
-    Nan::ThrowError("Usage: pty.kill(pid, innerPidHandle)");
+    Nan::ThrowError("Usage: pty.kill(pid, innerPid)");
     return;
   }
 
-  int handle = info[0]->Int32Value(Nan::GetCurrentContext()).FromJust();
-  HANDLE innerPidHandle = (HANDLE)info[1]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  DWORD pid = info[0]->Uint32Value(Nan::GetCurrentContext()).FromJust();
+  DWORD innerPid = info[1]->Uint32Value(Nan::GetCurrentContext()).FromJust();
 
-  winpty_t *pc = get_pipe_handle(handle);
+  winpty_t *pc = get_pipe_handle(pid);
   if (pc == nullptr) {
     Nan::ThrowError("Pty seems to have been killed already");
     return;
   }
 
-  assert(remove_pipe_handle(handle));
+  assert(remove_pipe_handle(pid));
+
+  HANDLE innerPidHandle = createdHandles[innerPid];
+  createdHandles.erase(innerPid);
   CloseHandle(innerPidHandle);
 
   return info.GetReturnValue().SetUndefined();

package/src/windowsConoutConnection.ts

@@ -30,7 +30,7 @@ const FLUSH_DATA_INTERVAL = 1000;
  */
 export class ConoutConnection implements IDisposable {
   private _worker: Worker;
-  private _drainTimeout: NodeJS.Timeout;
+  private _drainTimeout: NodeJS.Timeout | undefined;
   private _isDisposed: boolean = false;
 
   private _onReady = new EventEmitter2<void>();

package/src/windowsPtyAgent.ts

@@ -29,10 +29,9 @@ const FLUSH_DATA_INTERVAL = 1000;
 export class WindowsPtyAgent {
   private _inSocket: Socket;
   private _outSocket: Socket;
-  private _pid: number;
-  private _innerPid: number;
-  private _innerPidHandle: number;
-  private _closeTimeout: NodeJS.Timer;
+  private _pid: number = 0;
+  private _innerPid: number = 0;
+  private _closeTimeout: NodeJS.Timer | undefined;
   private _exitCode: number | undefined;
   private _conoutSocketWorker: ConoutConnection;
 
@@ -105,7 +104,6 @@ export class WindowsPtyAgent {
       term = (this._ptyNative as IWinptyNative).startProcess(file, commandLine, env, cwd, cols, rows, debug);
       this._pid = (term as IWinptyProcess).pid;
       this._innerPid = (term as IWinptyProcess).innerPid;
-      this._innerPidHandle = (term as IWinptyProcess).innerPidHandle;
     }
 
     // Not available on windows.
@@ -152,6 +150,12 @@ export class WindowsPtyAgent {
     this._ptyNative.resize(this._pid, cols, rows);
   }
 
+  public clear(): void {
+    if (this._useConpty) {
+      (this._ptyNative as IConptyNative).clear(this._pty);
+    }
+  }
+
   public kill(): void {
     this._inSocket.readable = false;
     this._outSocket.readable = false;
@@ -168,14 +172,14 @@ export class WindowsPtyAgent {
         (this._ptyNative as IConptyNative).kill(this._pty);
       });
     } else {
-      (this._ptyNative as IWinptyNative).kill(this._pid, this._innerPidHandle);
-      // Since pty.kill closes the handle it will kill most processes by itself
-      // and process IDs can be reused as soon as all handles to them are
-      // dropped, we want to immediately kill the entire console process list.
+      // Because pty.kill closes the handle, it will kill most processes by itself.
+      // Process IDs can be reused as soon as all handles to them are
+      // dropped, so we want to immediately kill the entire console process list.
       // If we do not force kill all processes here, node servers in particular
       // seem to become detached and remain running (see
       // Microsoft/vscode#26807).
       const processList: number[] = (this._ptyNative as IWinptyNative).getProcessList(this._pid);
+      (this._ptyNative as IWinptyNative).kill(this._pid, this._innerPid);
       processList.forEach(pid => {
         try {
           process.kill(pid);
@@ -202,11 +206,12 @@ export class WindowsPtyAgent {
     });
   }
 
-  public get exitCode(): number {
+  public get exitCode(): number | undefined {
     if (this._useConpty) {
       return this._exitCode;
     }
-    return (this._ptyNative as IWinptyNative).getExitCode(this._innerPidHandle);
+    const winptyExitCode = (this._ptyNative as IWinptyNative).getExitCode(this._innerPid);
+    return winptyExitCode === -1 ? undefined : winptyExitCode;
   }
 
   private _getWindowsBuildNumber(): number {

package/src/windowsTerminal.test.ts

@@ -65,7 +65,7 @@ function pollForProcessTreeSize(pid: number, size: number, intervalMs: number =
         })[0]);
         const list: IWindowsProcessTreeResult[] = [];
         while (openList.length) {
-          const current = openList.shift();
+          const current = openList.shift()!;
           ps.filter(p => p.ppid === current.pid).map(p => {
             return { name: p.name, pid: p.pid };
           }).forEach(p => openList.push(p));
@@ -81,7 +81,6 @@ function pollForProcessTreeSize(pid: number, size: number, intervalMs: number =
         if (tries * intervalMs >= timeoutMs) {
           clearInterval(interval);
           assert.fail(`Bad process state, expected: ${size}, actual: ${list.length}`);
-          resolve();
         }
       });
     }, intervalMs);
@@ -89,125 +88,127 @@ function pollForProcessTreeSize(pid: number, size: number, intervalMs: number =
 }
 
 if (process.platform === 'win32') {
-  describe('WindowsTerminal', () => {
-    describe('kill', () => {
-      it('should not crash parent process', (done) => {
-        const term = new WindowsTerminal('cmd.exe', [], {});
-        term.kill();
-        // Add done call to deferred function queue to ensure the kill call has completed
-        (<any>term)._defer(done);
-      });
-      it('should kill the process tree', function (done: Mocha.Done): void {
-        this.timeout(5000);
-        const term = new WindowsTerminal('cmd.exe', [], {});
-        // Start sub-processes
-        term.write('powershell.exe\r');
-        term.write('notepad.exe\r');
-        term.write('node.exe\r');
-        pollForProcessTreeSize(term.pid, 4, 500, 5000).then(list => {
-          assert.equal(list[0].name, 'cmd.exe');
-          assert.equal(list[1].name, 'powershell.exe');
-          assert.equal(list[2].name, 'notepad.exe');
-          assert.equal(list[3].name, 'node.exe');
+  [true, false].forEach((useConpty) => {
+    describe(`WindowsTerminal (useConpty = ${useConpty})`, () => {
+      describe('kill', () => {
+        it('should not crash parent process', (done) => {
+          const term = new WindowsTerminal('cmd.exe', [], { useConpty });
           term.kill();
-          const desiredState: IProcessState = {};
-          desiredState[list[0].pid] = false;
-          desiredState[list[1].pid] = false;
-          desiredState[list[2].pid] = true;
-          desiredState[list[3].pid] = false;
-          pollForProcessState(desiredState).then(() => {
-            // Kill notepad before done
-            process.kill(list[2].pid);
-            done();
+          // Add done call to deferred function queue to ensure the kill call has completed
+          (<any>term)._defer(done);
+        });
+        it('should kill the process tree', function (done: Mocha.Done): void {
+          this.timeout(5000);
+          const term = new WindowsTerminal('cmd.exe', [], { useConpty });
+          // Start sub-processes
+          term.write('powershell.exe\r');
+          term.write('notepad.exe\r');
+          term.write('node.exe\r');
+          pollForProcessTreeSize(term.pid, 4, 500, 5000).then(list => {
+            assert.strictEqual(list[0].name.toLowerCase(), 'cmd.exe');
+            assert.strictEqual(list[1].name.toLowerCase(), 'powershell.exe');
+            assert.strictEqual(list[2].name.toLowerCase(), 'notepad.exe');
+            assert.strictEqual(list[3].name.toLowerCase(), 'node.exe');
+            term.kill();
+            const desiredState: IProcessState = {};
+            desiredState[list[0].pid] = false;
+            desiredState[list[1].pid] = false;
+            desiredState[list[2].pid] = true;
+            desiredState[list[3].pid] = false;
+            pollForProcessState(desiredState).then(() => {
+              // Kill notepad before done
+              process.kill(list[2].pid);
+              done();
+            });
           });
         });
       });
-    });
 
-    describe('resize', () => {
-      it('should throw a non-native exception when resizing an invalid value', () => {
-        const term = new WindowsTerminal('cmd.exe', [], {});
-        assert.throws(() => term.resize(-1, -1));
-        assert.throws(() => term.resize(0, 0));
-        assert.doesNotThrow(() => term.resize(1, 1));
-      });
-      it('should throw an non-native exception when resizing a killed terminal', (done) => {
-        const term = new WindowsTerminal('cmd.exe', [], {});
-        (<any>term)._defer(() => {
-          term.on('exit', () => {
-            assert.throws(() => term.resize(1, 1));
-            done();
+      describe('resize', () => {
+        it('should throw a non-native exception when resizing an invalid value', () => {
+          const term = new WindowsTerminal('cmd.exe', [], { useConpty });
+          assert.throws(() => term.resize(-1, -1));
+          assert.throws(() => term.resize(0, 0));
+          assert.doesNotThrow(() => term.resize(1, 1));
+        });
+        it('should throw a non-native exception when resizing a killed terminal', (done) => {
+          const term = new WindowsTerminal('cmd.exe', [], { useConpty });
+          (<any>term)._defer(() => {
+            term.on('exit', () => {
+              assert.throws(() => term.resize(1, 1));
+              done();
+            });
+            term.destroy();
           });
-          term.destroy();
         });
       });
-    });
 
-    describe('Args as CommandLine', () => {
-      it('should not fail running a file containing a space in the path', (done) => {
-        const spaceFolder = path.resolve(__dirname, '..', 'fixtures', 'space folder');
-        if (!fs.existsSync(spaceFolder)) {
-          fs.mkdirSync(spaceFolder);
-        }
+      describe('Args as CommandLine', () => {
+        it('should not fail running a file containing a space in the path', (done) => {
+          const spaceFolder = path.resolve(__dirname, '..', 'fixtures', 'space folder');
+          if (!fs.existsSync(spaceFolder)) {
+            fs.mkdirSync(spaceFolder);
+          }
 
-        const cmdCopiedPath = path.resolve(spaceFolder, 'cmd.exe');
-        const data = fs.readFileSync(`${process.env.windir}\\System32\\cmd.exe`);
-        fs.writeFileSync(cmdCopiedPath, data);
+          const cmdCopiedPath = path.resolve(spaceFolder, 'cmd.exe');
+          const data = fs.readFileSync(`${process.env.windir}\\System32\\cmd.exe`);
+          fs.writeFileSync(cmdCopiedPath, data);
 
-        if (!fs.existsSync(cmdCopiedPath)) {
-          // Skip test if git bash isn't installed
-          return;
-        }
-        const term = new WindowsTerminal(cmdCopiedPath, '/c echo "hello world"', {});
-        let result = '';
-        term.on('data', (data) => {
-          result += data;
-        });
-        term.on('exit', () => {
-          assert.ok(result.indexOf('hello world') >= 1);
-          done();
+          if (!fs.existsSync(cmdCopiedPath)) {
+            // Skip test if git bash isn't installed
+            return;
+          }
+          const term = new WindowsTerminal(cmdCopiedPath, '/c echo "hello world"', { useConpty });
+          let result = '';
+          term.on('data', (data) => {
+            result += data;
+          });
+          term.on('exit', () => {
+            assert.ok(result.indexOf('hello world') >= 1);
+            done();
+          });
         });
       });
-    });
 
-    describe('env', () => {
-      it('should set environment variables of the shell', (done) => {
-        const term = new WindowsTerminal('cmd.exe', '/C echo %FOO%', { env: { FOO: 'BAR' }});
-        let result = '';
-        term.on('data', (data) => {
-          result += data;
-        });
-        term.on('exit', () => {
-          assert.ok(result.indexOf('BAR') >= 0);
-          done();
+      describe('env', () => {
+        it('should set environment variables of the shell', (done) => {
+          const term = new WindowsTerminal('cmd.exe', '/C echo %FOO%', { env: { FOO: 'BAR' }});
+          let result = '';
+          term.on('data', (data) => {
+            result += data;
+          });
+          term.on('exit', () => {
+            assert.ok(result.indexOf('BAR') >= 0);
+            done();
+          });
         });
       });
-    });
 
-    describe('On close', () => {
-      it('should return process zero exit codes', (done) => {
-        const term = new WindowsTerminal('cmd.exe', '/C exit');
-        term.on('exit', (code) => {
-          assert.equal(code, 0);
-          done();
+      describe('On close', () => {
+        it('should return process zero exit codes', (done) => {
+          const term = new WindowsTerminal('cmd.exe', '/C exit', { useConpty });
+          term.on('exit', (code) => {
+            assert.strictEqual(code, 0);
+            done();
+          });
         });
-      });
 
-      it('should return process non-zero exit codes', (done) => {
-        const term = new WindowsTerminal('cmd.exe', '/C exit 2');
-        term.on('exit', (code) => {
-          assert.equal(code, 2);
-          done();
+        it('should return process non-zero exit codes', (done) => {
+          const term = new WindowsTerminal('cmd.exe', '/C exit 2', { useConpty });
+          term.on('exit', (code) => {
+            assert.strictEqual(code, 2);
+            done();
+          });
         });
       });
-    });
 
-    describe('winpty', () => {
-      it('should accept input', (done) => {
-        const term = new WindowsTerminal('cmd.exe', '', { useConpty: false });
-        term.write('exit\r');
-        term.on('exit', () => {
-          done();
+      describe('Write', () => {
+        it('should accept input', (done) => {
+          const term = new WindowsTerminal('cmd.exe', '', { useConpty });
+          term.write('exit\r');
+          term.on('exit', () => {
+            done();
+          });
         });
       });
     });