libv8 7.8.279.23.0beta1 → 8.4.255.0

data/vendor/depot_tools/split_cl.py

@@ -5,6 +5,8 @@
 
 """Splits a branch into smaller branches and uploads CLs."""
 
+from __future__ import print_function
+
 import collections
 import os
 import re
@@ -12,9 +14,11 @@ import subprocess2
 import sys
 import tempfile
 
+import gclient_utils
 import git_footers
 import owners
 import owners_finder
+import scm
 
 import git_common as git
 
@@ -75,7 +79,7 @@ def AddUploadedByGitClSplitToDescription(description):
 
 def UploadCl(refactor_branch, refactor_branch_upstream, directory, files,
              description, comment, reviewers, changelist, cmd_upload,
-             cq_dry_run, enable_auto_submit):
+             cq_dry_run, enable_auto_submit, repository_root):
   """Uploads a CL with all changes to |files| in |refactor_branch|.
 
   Args:
@@ -95,26 +99,31 @@ def UploadCl(refactor_branch, refactor_branch_upstream, directory, files,
   # Create a branch.
   if not CreateBranchForDirectory(
       refactor_branch, directory, refactor_branch_upstream):
-    print 'Skipping ' + directory + ' for which a branch already exists.'
+    print('Skipping ' + directory + ' for which a branch already exists.')
     return
 
   # Checkout all changes to files in |files|.
-  deleted_files = [f.AbsoluteLocalPath() for f in files if f.Action() == 'D']
+  deleted_files = []
+  modified_files = []
+  for action, f in files:
+    abspath = os.path.abspath(os.path.join(repository_root, f))
+    if action == 'D':
+      deleted_files.append(abspath)
+    else:
+      modified_files.append(abspath)
+
   if deleted_files:
     git.run(*['rm'] + deleted_files)
-  modified_files = [f.AbsoluteLocalPath() for f in files if f.Action() != 'D']
   if modified_files:
     git.run(*['checkout', refactor_branch, '--'] + modified_files)
 
   # Commit changes. The temporary file is created with delete=False so that it
   # can be deleted manually after git has read it rather than automatically
   # when it is closed.
-  with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
-    tmp_file.write(FormatDescriptionOrComment(description, directory))
-    # Close the file to let git open it at the next line.
-    tmp_file.close()
-    git.run('commit', '-F', tmp_file.name)
-    os.remove(tmp_file.name)
+  with gclient_utils.temporary_file() as tmp_file:
+    gclient_utils.FileWrite(
+        tmp_file, FormatDescriptionOrComment(description, directory))
+    git.run('commit', '-F', tmp_file)
 
   # Upload a CL.
   upload_args = ['-f', '-r', ','.join(reviewers)]
@@ -124,7 +133,7 @@ def UploadCl(refactor_branch, refactor_branch_upstream, directory, files,
     upload_args.append('--send-mail')
   if enable_auto_submit:
     upload_args.append('--enable-auto-submit')
-  print 'Uploading CL for ' + directory + '.'
+  print('Uploading CL for ' + directory + '.')
   cmd_upload(upload_args)
   if comment:
     changelist().AddComment(FormatDescriptionOrComment(comment, directory),
@@ -139,9 +148,9 @@ def GetFilesSplitByOwners(owners_database, files):
     values are lists of files sharing an OWNERS file.
   """
   files_split_by_owners = collections.defaultdict(list)
-  for f in files:
-    files_split_by_owners[owners_database.enclosing_dir_with_owners(
-        f.LocalPath())].append(f)
+  for action, path in files:
+    enclosing_dir = owners_database.enclosing_dir_with_owners(path)
+    files_split_by_owners[enclosing_dir].append((action, path))
   return files_split_by_owners
 
 
@@ -162,16 +171,16 @@ def PrintClInfo(cl_index, num_cls, directory, file_paths, description,
                                                  directory).splitlines()
   indented_description = '\n'.join(['    ' + l for l in description_lines])
 
-  print 'CL {}/{}'.format(cl_index, num_cls)
-  print 'Path: {}'.format(directory)
-  print 'Reviewers: {}'.format(', '.join(reviewers))
-  print '\n' + indented_description + '\n'
-  print '\n'.join(file_paths)
-  print
+  print('CL {}/{}'.format(cl_index, num_cls))
+  print('Path: {}'.format(directory))
+  print('Reviewers: {}'.format(', '.join(reviewers)))
+  print('\n' + indented_description + '\n')
+  print('\n'.join(file_paths))
+  print()
 
 
 def SplitCl(description_file, comment_file, changelist, cmd_upload, dry_run,
-            cq_dry_run, enable_auto_submit):
+            cq_dry_run, enable_auto_submit, repository_root):
   """"Splits a branch into smaller branches and uploads CLs.
 
   Args:
@@ -193,11 +202,14 @@ def SplitCl(description_file, comment_file, changelist, cmd_upload, dry_run,
     EnsureInGitRepository()
 
     cl = changelist()
-    change = cl.GetChange(cl.GetCommonAncestorWithUpstream(), None)
-    files = change.AffectedFiles()
+    upstream = cl.GetCommonAncestorWithUpstream()
+    files = [
+        (action.strip(), f)
+        for action, f in scm.GIT.CaptureStatus(repository_root, upstream)
+    ]
 
     if not files:
-      print 'Cannot split an empty CL.'
+      print('Cannot split an empty CL.')
       return 1
 
     author = git.run('config', 'user.email').strip() or None
@@ -207,8 +219,8 @@ def SplitCl(description_file, comment_file, changelist, cmd_upload, dry_run,
     assert refactor_branch_upstream, \
         "Branch %s must have an upstream." % refactor_branch
 
-    owners_database = owners.Database(change.RepositoryRoot(), file, os.path)
-    owners_database.load_data_needed_for([f.LocalPath() for f in files])
+    owners_database = owners.Database(repository_root, open, os.path)
+    owners_database.load_data_needed_for([f for _, f in files])
 
     files_split_by_owners = GetFilesSplitByOwners(owners_database, files)
 
@@ -216,22 +228,22 @@ def SplitCl(description_file, comment_file, changelist, cmd_upload, dry_run,
     print('Will split current branch (' + refactor_branch + ') into ' +
           str(num_cls) + ' CLs.\n')
     if cq_dry_run and num_cls > CL_SPLIT_FORCE_LIMIT:
-      print (
+      print(
         'This will generate "%r" CLs. This many CLs can potentially generate'
         ' too much load on the build infrastructure. Please email'
         ' infra-dev@chromium.org to ensure that this won\'t  break anything.'
         ' The infra team reserves the right to cancel your jobs if they are'
-        ' overloading the CQ.') % num_cls
-      answer = raw_input('Proceed? (y/n):')
+        ' overloading the CQ.' % num_cls)
+      answer = gclient_utils.AskForData('Proceed? (y/n):')
       if answer.lower() != 'y':
         return 0
 
     for cl_index, (directory, files) in \
-        enumerate(files_split_by_owners.iteritems(), 1):
+        enumerate(files_split_by_owners.items(), 1):
       # Use '/' as a path separator in the branch name and the CL description
       # and comment.
       directory = directory.replace(os.path.sep, '/')
-      file_paths = [f.LocalPath() for f in files]
+      file_paths = [f for _, f in files]
       reviewers = owners_database.reviewers_for(file_paths, author)
 
       if dry_run:
@@ -240,7 +252,7 @@ def SplitCl(description_file, comment_file, changelist, cmd_upload, dry_run,
       else:
         UploadCl(refactor_branch, refactor_branch_upstream, directory, files,
                  description, comment, reviewers, changelist, cmd_upload,
-                 cq_dry_run, enable_auto_submit)
+                 cq_dry_run, enable_auto_submit, repository_root)
 
     # Go back to the original branch.
     git.run('checkout', refactor_branch)

data/vendor/depot_tools/subcommand.py

@@ -66,11 +66,11 @@ def epilog(text):
 
 def CMDhelp(parser, args):
   """Prints list of commands or help for a specific command."""
-  # This is the default help implementation. It can be disabled or overriden if
+  # This is the default help implementation. It can be disabled or overridden if
   # wanted.
   if not any(i in ('-h', '--help') for i in args):
     args = args + ['--help']
-  _, args = parser.parse_args(args)
+  parser.parse_args(args)
   # Never gets there.
   assert False
 
@@ -160,7 +160,7 @@ class CommandDispatcher(object):
     commands = self.enumerate_commands()
     docs = sorted(
         (cmd_name, self._create_command_summary(cmd_name, handler))
-        for cmd_name, handler in commands.iteritems())
+        for cmd_name, handler in commands.items())
     # Skip commands without a docstring.
     docs = [i for i in docs if i[1]]
     # Then calculate maximum length for alignment:
@@ -235,14 +235,14 @@ class CommandDispatcher(object):
 
     if args:
       if args[0] in ('-h', '--help') and len(args) > 1:
-        # Inverse the argument order so 'tool --help cmd' is rewritten to
+        # Reverse the argument order so 'tool --help cmd' is rewritten to
         # 'tool cmd --help'.
         args = [args[1], args[0]] + args[2:]
       command = self.find_nearest_command(args[0])
       if command:
         if command.__name__ == 'CMDhelp' and len(args) > 1:
-          # Inverse the arguments order so 'tool help cmd' is rewritten to
-          # 'tool cmd --help'. Do it here since we want 'tool hel cmd' to work
+          # Reverse the argument order so 'tool help cmd' is rewritten to
+          # 'tool cmd --help'. Do it here since we want 'tool help cmd' to work
           # too.
           args = [args[1], '--help'] + args[2:]
           command = self.find_nearest_command(args[0]) or command

data/vendor/depot_tools/subprocess2.py

@@ -1,4 +1,4 @@
-# coding=utf8
+# coding=utf-8
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
@@ -12,41 +12,27 @@ import errno
 import io
 import logging
 import os
-
-try:
-  import Queue
-except ImportError:  # For Py3 compatibility
-  import queue as Queue
-
 import subprocess
 import sys
-import time
 import threading
 
 # Cache the string-escape codec to ensure subprocess can find it later.
 # See crbug.com/912292#c2 for context.
 if sys.version_info.major == 2:
+  import Queue
   codecs.lookup('string-escape')
-
-# TODO(crbug.com/953884): Remove this when python3 migration is done.
-try:
-  basestring
-except NameError:
+else:
+  import queue as Queue
   # pylint: disable=redefined-builtin
-  basestring = str
+  basestring = (str, bytes)
 
 
 # Constants forwarded from subprocess.
 PIPE = subprocess.PIPE
 STDOUT = subprocess.STDOUT
 # Sends stdout or stderr to os.devnull.
-VOID = object()
-# Error code when a process was killed because it timed out.
-TIMED_OUT = -2001
-
-# Globals.
-# Set to True if you somehow need to disable this hack.
-SUBPROCESS_CLEANUP_HACKED = False
+VOID = open(os.devnull, 'w')
+VOID_INPUT = open(os.devnull, 'r')
 
 
 class CalledProcessError(subprocess.CalledProcessError):
@@ -62,7 +48,11 @@ class CalledProcessError(subprocess.CalledProcessError):
         ' '.join(self.cmd), self.returncode)
     if self.cwd:
       out += ' in ' + self.cwd
-    return '\n'.join(filter(None, (out, self.stdout, self.stderr)))
+    if self.stdout:
+      out += '\n' + self.stdout.decode('utf-8', 'ignore')
+    if self.stderr:
+      out += '\n' + self.stderr.decode('utf-8', 'ignore')
+    return out
 
 
 class CygwinRebaseError(CalledProcessError):
@@ -78,51 +68,11 @@ def kill_pid(pid):
     # Unable to import 'module'
     # pylint: disable=no-member,F0401
     import signal
-    return os.kill(pid, signal.SIGKILL)
-  except ImportError:
-    pass
-
-
-def kill_win(process):
-  """Kills a process with its windows handle.
-
-  Has no effect on other platforms.
-  """
-  try:
-    # Unable to import 'module'
-    # pylint: disable=import-error
-    import win32process
-    # Access to a protected member _handle of a client class
-    # pylint: disable=protected-access
-    return win32process.TerminateProcess(process._handle, -1)
+    return os.kill(pid, signal.SIGTERM)
   except ImportError:
     pass
 
 
-def add_kill():
-  """Adds kill() method to subprocess.Popen for python <2.6"""
-  if hasattr(subprocess.Popen, 'kill'):
-    return
-
-  if sys.platform == 'win32':
-    subprocess.Popen.kill = kill_win
-  else:
-    subprocess.Popen.kill = lambda process: kill_pid(process.pid)
-
-
-def hack_subprocess():
-  """subprocess functions may throw exceptions when used in multiple threads.
-
-  See http://bugs.python.org/issue1731717 for more information.
-  """
-  global SUBPROCESS_CLEANUP_HACKED
-  if not SUBPROCESS_CLEANUP_HACKED and threading.activeCount() != 1:
-    # Only hack if there is ever multiple threads.
-    # There is no point to leak with only one thread.
-    subprocess._cleanup = lambda: None
-    SUBPROCESS_CLEANUP_HACKED = True
-
-
 def get_english_env(env):
   """Forces LANG and/or LANGUAGE to be English.
 
@@ -150,42 +100,6 @@ def get_english_env(env):
   return env
 
 
-class NagTimer(object):
-  """
-  Triggers a callback when a time interval passes without an event being fired.
-
-  For example, the event could be receiving terminal output from a subprocess;
-  and the callback could print a warning to stderr that the subprocess appeared
-  to be hung.
-  """
-  def __init__(self, interval, cb):
-    self.interval = interval
-    self.cb = cb
-    self.timer = threading.Timer(self.interval, self.fn)
-    self.last_output = self.previous_last_output = 0
-
-  def start(self):
-    self.last_output = self.previous_last_output = time.time()
-    self.timer.start()
-
-  def event(self):
-    self.last_output = time.time()
-
-  def fn(self):
-    now = time.time()
-    if self.last_output == self.previous_last_output:
-      self.cb(now - self.previous_last_output)
-    # Use 0.1 fudge factor, just in case
-    #   (self.last_output - now) is very close to zero.
-    sleep_time = (self.last_output - now - 0.1) % self.interval
-    self.previous_last_output = self.last_output
-    self.timer = threading.Timer(sleep_time + 0.1, self.fn)
-    self.timer.start()
-
-  def cancel(self):
-    self.timer.cancel()
-
-
 class Popen(subprocess.Popen):
   """Wraps subprocess.Popen() with various workarounds.
 
@@ -208,13 +122,20 @@ class Popen(subprocess.Popen):
   popen_lock = threading.Lock()
 
   def __init__(self, args, **kwargs):
-    # Make sure we hack subprocess if necessary.
-    hack_subprocess()
-    add_kill()
-
     env = get_english_env(kwargs.get('env'))
     if env:
       kwargs['env'] = env
+    if kwargs.get('env') is not None and sys.version_info.major != 2:
+      # Subprocess expects environment variables to be strings in Python 3.
+      def ensure_str(value):
+        if isinstance(value, bytes):
+          return value.decode()
+        return value
+
+      kwargs['env'] = {
+          ensure_str(k): ensure_str(v)
+          for k, v in kwargs['env'].items()
+      }
     if kwargs.get('shell') is None:
       # *Sigh*:  Windows needs shell=True, or else it won't search %PATH% for
       # the executable, but shell=True makes subprocess on Linux fail when it's
@@ -232,33 +153,6 @@ class Popen(subprocess.Popen):
       tmp_str += ';  cwd=%s' % kwargs['cwd']
     logging.debug(tmp_str)
 
-    self.stdout_cb = None
-    self.stderr_cb = None
-    self.stdin_is_void = False
-    self.stdout_is_void = False
-    self.stderr_is_void = False
-    self.cmd_str = tmp_str
-
-    if kwargs.get('stdin') is VOID:
-      kwargs['stdin'] = open(os.devnull, 'r')
-      self.stdin_is_void = True
-
-    for stream in ('stdout', 'stderr'):
-      if kwargs.get(stream) in (VOID, os.devnull):
-        kwargs[stream] = open(os.devnull, 'w')
-        setattr(self, stream + '_is_void', True)
-      if callable(kwargs.get(stream)):
-        setattr(self, stream + '_cb', kwargs[stream])
-        kwargs[stream] = PIPE
-
-    self.start = time.time()
-    self.timeout = None
-    self.nag_timer = None
-    self.nag_max = None
-    self.shell = kwargs.get('shell', None)
-    # Silence pylint on MacOSX
-    self.returncode = None
-
     try:
       with self.popen_lock:
         super(Popen, self).__init__(args, **kwargs)
@@ -279,205 +173,25 @@ class Popen(subprocess.Popen):
                     'Check that %s or %s exist and have execution permission.'
                     % (str(e), kwargs.get('cwd'), args[0]))
 
-  def _tee_threads(self, input):  # pylint: disable=redefined-builtin
-    """Does I/O for a process's pipes using threads.
-
-    It's the simplest and slowest implementation. Expect very slow behavior.
-
-    If there is a callback and it doesn't keep up with the calls, the timeout
-    effectiveness will be delayed accordingly.
-    """
-    # Queue of either of <threadname> when done or (<threadname>, data).  In
-    # theory we would like to limit to ~64kb items to not cause large memory
-    # usage when the callback blocks. It is not done because it slows down
-    # processing on OSX10.6 by a factor of 2x, making it even slower than
-    # Windows!  Revisit this decision if it becomes a problem, e.g. crash
-    # because of memory exhaustion.
-    queue = Queue.Queue()
-    done = threading.Event()
-    nag = None
-
-    def write_stdin():
-      try:
-        stdin_io = io.BytesIO(input)
-        while True:
-          data = stdin_io.read(1024)
-          if data:
-            self.stdin.write(data)
-          else:
-            self.stdin.close()
-            break
-      finally:
-        queue.put('stdin')
-
-    def _queue_pipe_read(pipe, name):
-      """Queues characters read from a pipe into a queue."""
-      try:
-        while True:
-          data = pipe.read(1)
-          if not data:
-            break
-          if nag:
-            nag.event()
-          queue.put((name, data))
-      finally:
-        queue.put(name)
-
-    def timeout_fn():
-      try:
-        done.wait(self.timeout)
-      finally:
-        queue.put('timeout')
-
-    def wait_fn():
-      try:
-        self.wait()
-      finally:
-        queue.put('wait')
-
-    # Starts up to 5 threads:
-    # Wait for the process to quit
-    # Read stdout
-    # Read stderr
-    # Write stdin
-    # Timeout
-    threads = {
-        'wait': threading.Thread(target=wait_fn),
-    }
-    if self.timeout is not None:
-      threads['timeout'] = threading.Thread(target=timeout_fn)
-    if self.stdout_cb:
-      threads['stdout'] = threading.Thread(
-          target=_queue_pipe_read, args=(self.stdout, 'stdout'))
-    if self.stderr_cb:
-      threads['stderr'] = threading.Thread(
-        target=_queue_pipe_read, args=(self.stderr, 'stderr'))
-    if input:
-      threads['stdin'] = threading.Thread(target=write_stdin)
-    elif self.stdin:
-      # Pipe but no input, make sure it's closed.
-      self.stdin.close()
-    for t in threads.itervalues():
-      t.start()
-
-    if self.nag_timer:
-      def _nag_cb(elapsed):
-        logging.warn('  No output for %.0f seconds from command:' % elapsed)
-        logging.warn('    %s' % self.cmd_str)
-        if (self.nag_max and
-            int('%.0f' % (elapsed / self.nag_timer)) >= self.nag_max):
-          queue.put('timeout')
-          done.set()  # Must do this so that timeout thread stops waiting.
-      nag = NagTimer(self.nag_timer, _nag_cb)
-      nag.start()
-
-    timed_out = False
-    try:
-      # This thread needs to be optimized for speed.
-      while threads:
-        item = queue.get()
-        if item[0] == 'stdout':
-          self.stdout_cb(item[1])
-        elif item[0] == 'stderr':
-          self.stderr_cb(item[1])
-        else:
-          # A thread terminated.
-          if item in threads:
-            threads[item].join()
-            del threads[item]
-          if item == 'wait':
-            # Terminate the timeout thread if necessary.
-            done.set()
-          elif item == 'timeout' and not timed_out and self.poll() is None:
-            logging.debug('Timed out after %.0fs: killing' % (
-                time.time() - self.start))
-            self.kill()
-            timed_out = True
-    finally:
-      # Stop the threads.
-      done.set()
-      if nag:
-        nag.cancel()
-      if 'wait' in threads:
-        # Accelerate things, otherwise it would hang until the child process is
-        # done.
-        logging.debug('Killing child because of an exception')
-        self.kill()
-      # Join threads.
-      for thread in threads.itervalues():
-        thread.join()
-      if timed_out:
-        self.returncode = TIMED_OUT
-
-  # pylint: disable=arguments-differ,W0622
-  def communicate(self, input=None, timeout=None, nag_timer=None,
-                  nag_max=None):
-    """Adds timeout and callbacks support.
-
-    Returns (stdout, stderr) like subprocess.Popen().communicate().
-
-    - The process will be killed after |timeout| seconds and returncode set to
-      TIMED_OUT.
-    - If the subprocess runs for |nag_timer| seconds without producing terminal
-      output, print a warning to stderr.
-    """
-    self.timeout = timeout
-    self.nag_timer = nag_timer
-    self.nag_max = nag_max
-    if (not self.timeout and not self.nag_timer and
-        not self.stdout_cb and not self.stderr_cb):
-      return super(Popen, self).communicate(input)
-
-    if self.timeout and self.shell:
-      raise TypeError(
-          'Using timeout and shell simultaneously will cause a process leak '
-          'since the shell will be killed instead of the child process.')
-
-    stdout = None
-    stderr = None
-    # Convert to a lambda to workaround python's deadlock.
-    # http://docs.python.org/library/subprocess.html#subprocess.Popen.wait
-    # When the pipe fills up, it would deadlock this process.
-    if self.stdout and not self.stdout_cb and not self.stdout_is_void:
-      stdout = []
-      self.stdout_cb = stdout.append
-    if self.stderr and not self.stderr_cb and not self.stderr_is_void:
-      stderr = []
-      self.stderr_cb = stderr.append
-    self._tee_threads(input)
-    if stdout is not None:
-      stdout = ''.join(stdout)
-    if stderr is not None:
-      stderr = ''.join(stderr)
-    return (stdout, stderr)
-
-
-def communicate(args, timeout=None, nag_timer=None, nag_max=None, **kwargs):
-  """Wraps subprocess.Popen().communicate() and add timeout support.
+
+def communicate(args, **kwargs):
+  """Wraps subprocess.Popen().communicate().
 
   Returns ((stdout, stderr), returncode).
 
-  - The process will be killed after |timeout| seconds and returncode set to
-    TIMED_OUT.
   - If the subprocess runs for |nag_timer| seconds without producing terminal
     output, print a warning to stderr.
   - Automatically passes stdin content as input so do not specify stdin=PIPE.
   """
-  stdin = kwargs.pop('stdin', None)
-  if stdin is not None:
-    if isinstance(stdin, basestring):
-      # When stdin is passed as an argument, use it as the actual input data and
-      # set the Popen() parameter accordingly.
-      kwargs['stdin'] = PIPE
-    else:
-      kwargs['stdin'] = stdin
-      stdin = None
+  stdin = None
+  # When stdin is passed as an argument, use it as the actual input data and
+  # set the Popen() parameter accordingly.
+  if 'stdin' in kwargs and isinstance(kwargs['stdin'], basestring):
+    stdin = kwargs['stdin']
+    kwargs['stdin'] = PIPE
 
   proc = Popen(args, **kwargs)
-  if stdin:
-    return proc.communicate(stdin, timeout, nag_timer), proc.returncode
-  else:
-    return proc.communicate(None, timeout, nag_timer), proc.returncode
+  return proc.communicate(stdin), proc.returncode
 
 
 def call(args, **kwargs):
@@ -486,6 +200,8 @@ def call(args, **kwargs):
   Automatically convert stdout=PIPE or stderr=PIPE to VOID.
   In no case they can be returned since no code path raises
   subprocess2.CalledProcessError.
+
+  Returns exit code.
   """
   if kwargs.get('stdout') == PIPE:
     kwargs['stdout'] = VOID
@@ -520,7 +236,7 @@ def capture(args, **kwargs):
   - Discards returncode.
   - Blocks stdin by default if not specified since no output will be visible.
   """
-  kwargs.setdefault('stdin', VOID)
+  kwargs.setdefault('stdin', VOID_INPUT)
 
   # Like check_output, deny the caller from using stdout arg.
   return communicate(args, stdout=PIPE, **kwargs)[0][0]
@@ -536,7 +252,7 @@ def check_output(args, **kwargs):
   - Blocks stdin by default if not specified since no output will be visible.
   - As per doc, "The stdout argument is not allowed as it is used internally."
   """
-  kwargs.setdefault('stdin', VOID)
+  kwargs.setdefault('stdin', VOID_INPUT)
   if 'stdout' in kwargs:
     raise ValueError('stdout argument not allowed, it would be overridden.')
   return check_call_out(args, stdout=PIPE, **kwargs)[0]