docs: def _taskkill(self, force: bool = False) -> int:
          """
          Executes a Windows ``TASKKILL /pid PROCESS_ID /t`` command
          (``/t`` for "tree kill" = "kill all children").
  
          Args:
              force: also add ``/f`` (forcefully)
  
          Returns:
              return code from ``TASKKILL``
  
          **Test code:**
  
          Firstly we need a program that won't let itself be killed. Save this as
          ``nokill.py``:
  
          .. code-block:: python
  
              #!/usr/bin/env python
  
              import logging
              import time
              import os
              from cardinal_pythonlib.logs import main_only_quicksetup_rootlogger
              from cardinal_pythonlib.signalfunc import trap_ctrl_c_ctrl_break
  
              main_only_quicksetup_rootlogger(level=logging.DEBUG)
              trap_ctrl_c_ctrl_break()
  
              while True:
                  print("Process ID is {}; time is {} s".format(os.getpid(), time.clock()))
                  time.sleep(1)
  
          Now run that with ``python nokill.py``. It should resist CTRL-C and
          CTRL-BREAK. Start another command prompt in which to play with
          ``TASKKILL``.
  
          .. code-block:: bat
  
              REM Firstly, avoid this single-ampersand syntax:
              REM     taskkill /im notepad.exe & echo %errorlevel%
              REM ... as it prints the WRONG (previous?) errorlevel.
  
              notepad.exe
              taskkill /im notepad.exe
              echo %errorlevel%
              REM ... 0 for success (Windows 10), e.g.
              REM 'SUCCESS: Sent termination signal to the process "notepad.exe" with PID 6988.'
  
              taskkill /im notepad.exe
              echo %errorlevel%
              REM ... 128 for "not found" (Windows 10), e.g.
              REM 'ERROR: The process "notepad.exe" not found.'
  
              REM Now run notepad.exe as Administrator
              taskkill /im notepad.exe & echo %errorlevel%
              REM ... 1 for "access denied" (Windows 10)
  
              REM Now kill the nokill.py process by its PID (e.g. 11892 here):
              taskkill /pid 11892
              echo %errorlevel%
              REM ... 1 for "not allowed" (Windows 10), e.g.
              REM 'ERROR: The process with PID 11892 could not be terminated.'
              REM 'Reason: This process can only be terminated forcefully (with /F option).'
  
              REM Now forcefully:
              taskkill /pid 11892 /f
              echo %errorlevel%
              REM ... 0 for success (Windows 10), e.g.
              REM 'SUCCESS: The process with PID 11892 has been terminated.'
              
          """  # noqa
          args = [
              "taskkill",  # built in to Windows XP and higher
              "/pid", str(self.process.pid),
              "/t",  # tree kill: kill all children
          ]
          if force:
              args.append("/f")  # forcefully
          callname = " ".join(args)
          retcode = subprocess.call(args)
          # http://stackoverflow.com/questions/18682681/what-are-exit-codes-from-the-taskkill-utility  # noqa
          if retcode == winerror.ERROR_SUCCESS:  # 0
              self.info("Killed with " + repr(callname))
          elif retcode == winerror.ERROR_INVALID_FUNCTION:  # 1
              self.warning(
                  repr(callname) +
                  " failed (error code 1 = ERROR_INVALID_FUNCTION; "
                  "can mean 'Access denied', or 'This process can only be "
                  "terminated forcefully (with /F option)').")
          elif retcode == winerror.ERROR_WAIT_NO_CHILDREN:  # 128
              self.warning(
                  repr(callname) +
                  " failed (error code 128 = ERROR_WAIT_NO_CHILDREN "
                  "= 'There are no child processes to wait for', but also "
                  "occurs when the process doesn't exist, and when processes "
                  "require a forceful [/F] termination)")
          elif retcode == winerror.ERROR_EA_LIST_INCONSISTENT:  # 255
              self.warning(
                  repr(callname) +
                  " failed (error code 255 = ERROR_EA_LIST_INCONSISTENT "
                  "= 'The extended attributes are inconsistent.')")
          else:
              self.warning(callname + " failed: error code {}".format(retcode))
          return retcode