Simplify some functions by removing the options.stdout mock. Fix the unit tes...

gclient.py

 #!/usr/bin/python
 #
 # Copyright 2008 Google Inc.  All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
@@ skipping 46 matching lines @@
                to run the command.
 
   Example:
     hooks = [
       { "pattern": "\\.(gif|jpe?g|pr0n|png)$",
         "action":  ["python", "image_indexer.py", "--all"]},
     ]
 """
 
 __author__ = "darinf@gmail.com (Darin Fisher)"
-__version__ = "0.3.1"
+__version__ = "0.3.2"
 
 import errno
 import optparse
 import os
 import re
 import stat
 import subprocess
 import sys
 import time
 import urlparse
@@ skipping 312 matching lines @@
   try:
     os.rmdir(file_path)
   except OSError, e:
     if e.errno != errno.EACCES or sys.platform != 'win32':
       raise
     print 'Failed to remove %s: trying again' % file_path
     time.sleep(0.1)
     os.rmdir(file_path)
 
 
-def SubprocessCall(command, in_directory, out, fail_status=None):
+def SubprocessCall(command, in_directory, fail_status=None):
   """Runs command, a list, in directory in_directory.
 
   This function wraps SubprocessCallAndCapture, but does not perform the
   capturing functions.  See that function for a more complete usage
   description.
   """
   # Call subprocess and capture nothing:
-  SubprocessCallAndCapture(command, in_directory, out, fail_status)
+  SubprocessCallAndCapture(command, in_directory, fail_status)
 
 
-def SubprocessCallAndCapture(command, in_directory, out, fail_status=None,
+def SubprocessCallAndCapture(command, in_directory, fail_status=None,
                              pattern=None, capture_list=None):
   """Runs command, a list, in directory in_directory.
 
   A message indicating what is being done, as well as the command's stdout,
   is printed to out.
 
   If a pattern is specified, any line in the output matching pattern will have
   its first match group appended to capture_list.
 
   If the command fails, as indicated by a nonzero exit status, gclient will
   exit with an exit status of fail_status.  If fail_status is None (the
   default), gclient will raise an Error exception.
   """
 
-  print >> out, ("\n________ running \'%s\' in \'%s\'"
-      % (' '.join(command), in_directory))
+  print("\n________ running \'%s\' in \'%s\'"
+        % (' '.join(command), in_directory))
 
   # *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 called
   # with a list because it only tries to execute the first item in the list.
   kid = subprocess.Popen(command, bufsize=0, cwd=in_directory,
       shell=(sys.platform == 'win32'), stdout=subprocess.PIPE)
 
   if pattern:
     compiled_pattern = re.compile(pattern)
 
@@ skipping 30 matching lines @@
   |entries| is a list of paths to check."""
   for path in paths:
     if os.path.exists(os.path.join(root, path, '.git')):
       return True
   return False
 
 # -----------------------------------------------------------------------------
 # SVN utils:
 
 
-def RunSVN(options, args, in_directory):
+def RunSVN(args, in_directory):
   """Runs svn, sending output to stdout.
 
   Args:
     args: A sequence of command line parameters to be passed to svn.
     in_directory: The directory where svn is to be run.
 
   Raises:
     Error: An error occurred while running the svn command.
   """
   c = [SVN_COMMAND]
   c.extend(args)
 
-  SubprocessCall(c, in_directory, options.stdout)
+  SubprocessCall(c, in_directory)
 
 
-def CaptureSVN(options, args, in_directory):
+def CaptureSVN(args, in_directory):
   """Runs svn, capturing output sent to stdout as a string.
 
   Args:
     args: A sequence of command line parameters to be passed to svn.
     in_directory: The directory where svn is to be run.
 
   Returns:
     The output sent to stdout as a string.
   """
   c = [SVN_COMMAND]
   c.extend(args)
 
   # *Sigh*:  Windows needs shell=True, or else it won't search %PATH% for
   # the svn.exe executable, but shell=True makes subprocess on Linux fail
   # when it's called with a list because it only tries to execute the
   # first string ("svn").
-  return subprocess.Popen(c, cwd=in_directory, shell=(sys.platform == 'win32'),
+  return subprocess.Popen(c,
+                          cwd=in_directory,
+                          shell=(sys.platform == 'win32'),
                           stdout=subprocess.PIPE).communicate()[0]
 
 
-def RunSVNAndGetFileList(options, args, in_directory, file_list):
+def RunSVNAndGetFileList(args, in_directory, file_list):
   """Runs svn checkout, update, or status, output to stdout.
 
   The first item in args must be either "checkout", "update", or "status".
 
   svn's stdout is parsed to collect a list of files checked out or updated.
   These files are appended to file_list.  svn's stdout is also printed to
   sys.stdout as in RunSVN.
 
   Args:
     args: A sequence of command line parameters to be passed to svn.
@@ skipping 19 matching lines @@
   # args[0] must be a supported command.  This will blow up if it's something
   # else, which is good.  Note that the patterns are only effective when
   # these commands are used in their ordinary forms, the patterns are invalid
   # for "svn status --show-updates", for example.
   pattern = {
         'checkout': update_pattern,
         'status':   status_pattern,
         'update':   update_pattern,
       }[args[0]]
 
-  SubprocessCallAndCapture(command, in_directory, options.stdout,
-                           pattern=pattern, capture_list=file_list)
+  SubprocessCallAndCapture(command,
+                           in_directory,
+                           pattern=pattern,
+                           capture_list=file_list)
 
 
-def CaptureSVNInfo(options, relpath, in_directory):
+def CaptureSVNInfo(relpath, in_directory=None):
   """Returns a dictionary from the svn info output for the given file.
 
   Args:
     relpath: The directory where the working copy resides relative to
       the directory given by in_directory.
     in_directory: The directory where svn is to be run.
   """
-  dom = ParseXML(CaptureSVN(options, ["info", "--xml", relpath], in_directory))
+  output = CaptureSVN(["info", "--xml", relpath], in_directory)
+  dom = ParseXML(output)
   result = {}
   if dom:
     def C(item, f):
       if item is not None: return f(item)
     # /info/entry/
     #   url
     #   reposityory/(root|uuid)
     #   wc-info/(schedule|depth)
     #   commit/(author|date)
     # str() the results because they may be returned as Unicode, which
     # interferes with the higher layers matching up things in the deps
     # dictionary.
     # TODO(maruel): Fix at higher level instead (!)
     result['Repository Root'] = C(GetNamedNodeText(dom, 'root'), str)
     result['URL'] = C(GetNamedNodeText(dom, 'url'), str)
     result['UUID'] = C(GetNamedNodeText(dom, 'uuid'), str)
     result['Revision'] = C(GetNodeNamedAttributeText(dom, 'entry', 'revision'),
                            int)
     result['Node Kind'] = C(GetNodeNamedAttributeText(dom, 'entry', 'kind'),
                             str)
     result['Schedule'] = C(GetNamedNodeText(dom, 'schedule'), str)
     result['Path'] = C(GetNodeNamedAttributeText(dom, 'entry', 'path'), str)
     result['Copied From URL'] = C(GetNamedNodeText(dom, 'copy-from-url'), str)
     result['Copied From Rev'] = C(GetNamedNodeText(dom, 'copy-from-rev'), str)
   return result
 
 
-def CaptureSVNHeadRevision(options, url):
+def CaptureSVNHeadRevision(url):
   """Get the head revision of a SVN repository.
 
   Returns:
     Int head revision
   """
-  info = CaptureSVN(options, ["info", "--xml", url], os.getcwd())
+  info = CaptureSVN(["info", "--xml", url], os.getcwd())
   dom = xml.dom.minidom.parseString(info)
   return int(dom.getElementsByTagName('entry')[0].getAttribute('revision'))
 
 
 class FileStatus:
   def __init__(self, path, text_status, props, lock, history):
     self.path = path
     self.text_status = text_status
     self.props = props
     self.lock = lock
     self.history = history
 
   def __str__(self):
     # Emulate svn status 1.5 output.
     return (self.text_status + self.props + self.lock + self.history + ' ' +
             self.path)
 
 
-def CaptureSVNStatus(options, path):
+def CaptureSVNStatus(path):
   """Runs 'svn status' on an existing path.
 
   Args:
     path: The directory to run svn status.
 
   Returns:
     An array of FileStatus corresponding to the emulated output of 'svn status'
     version 1.5."""
-  dom = ParseXML(CaptureSVN(options, ["status", "--xml"], path))
+  dom = ParseXML(CaptureSVN(["status", "--xml"], path))
   results = []
   if dom:
     # /status/target/entry/(wc-status|commit|author|date)
     for target in dom.getElementsByTagName('target'):
       base_path = target.getAttribute('path')
       for entry in target.getElementsByTagName('entry'):
         file = entry.getAttribute('path')
         wc_status = entry.getElementsByTagName('wc-status')
         assert len(wc_status) == 1
         # Emulate svn 1.5 status ouput...
@@ skipping 81 matching lines @@
 
     if not command in commands:
       raise Error('Unknown command %s' % command)
 
     return commands[command](options, args, file_list)
 
   def cleanup(self, options, args, file_list):
     """Cleanup working copy."""
     command = ['cleanup']
     command.extend(args)
-    RunSVN(options, command, os.path.join(self._root_dir, self.relpath))
+    RunSVN(command, os.path.join(self._root_dir, self.relpath))
 
   def diff(self, options, args, file_list):
     # NOTE: This function does not currently modify file_list.
     command = ['diff']
     command.extend(args)
-    RunSVN(options, command, os.path.join(self._root_dir, self.relpath))
+    RunSVN(command, os.path.join(self._root_dir, self.relpath))
 
   def update(self, options, args, file_list):
     """Runs SCM to update or transparently checkout the working copy.
 
     All updated files will be appended to file_list.
 
     Raises:
       Error: if can't get URL for relative path.
     """
     # Only update if git is not controlling the directory.
     git_path = os.path.join(self._root_dir, self.relpath, '.git')
     if options.path_exists(git_path):
-      print >> options.stdout, (
-          "________ found .git directory; skipping %s" % self.relpath)
+      print("________ found .git directory; skipping %s" % self.relpath)
       return
 
     if args:
       raise Error("Unsupported argument(s): %s" % ",".join(args))
 
     url = self.url
     components = url.split("@")
     revision = None
     forced_revision = False
     if options.revision:
       # Override the revision number.
       url = '%s@%s' % (components[0], str(options.revision))
       revision = int(options.revision)
       forced_revision = True
     elif len(components) == 2:
       revision = int(components[1])
       forced_revision = True
 
     rev_str = ""
     if revision:
       rev_str = ' at %d' % revision
 
     if not options.path_exists(os.path.join(self._root_dir, self.relpath)):
       # We need to checkout.
       command = ['checkout', url, os.path.join(self._root_dir, self.relpath)]
       if revision:
         command.extend(['--revision', str(revision)])
-      RunSVNAndGetFileList(options, command, self._root_dir, file_list)
+      RunSVNAndGetFileList(command, self._root_dir, file_list)
       return
 
     # Get the existing scm url and the revision number of the current checkout.
-    from_info = CaptureSVNInfo(options,
-                               os.path.join(self._root_dir, self.relpath, '.'),
+    from_info = CaptureSVNInfo(os.path.join(self._root_dir, self.relpath, '.'),
                                '.')
 
     if options.manually_grab_svn_rev:
       # Retrieve the current HEAD version because svn is slow at null updates.
       if not revision:
-        from_info_live = CaptureSVNInfo(options, from_info['URL'], '.')
+        from_info_live = CaptureSVNInfo(from_info['URL'], '.')
         revision = int(from_info_live['Revision'])
         rev_str = ' at %d' % revision
 
     if from_info['URL'] != components[0]:
-      to_info = CaptureSVNInfo(options, url, '.')
+      to_info = CaptureSVNInfo(url, '.')
       if from_info['Repository Root'] != to_info['Repository Root']:
         # We have different roots, so check if we can switch --relocate.
         # Subversion only permits this if the repository UUIDs match.
         if from_info['UUID'] != to_info['UUID']:
           raise Error("Can't switch the checkout to %s; UUID don't match. That "
                       "simply means in theory, gclient should verify you don't "
                       "have a local change, remove the old checkout and do a "
                       "fresh new checkout of the new repo. Contributions are "
                       "welcome." % url)
 
         # Perform the switch --relocate, then rewrite the from_url
         # to reflect where we "are now."  (This is the same way that
         # Subversion itself handles the metadata when switch --relocate
         # is used.)  This makes the checks below for whether we
         # can update to a revision or have to switch to a different
         # branch work as expected.
         # TODO(maruel):  TEST ME !
         command = ["switch", "--relocate",
                    from_info['Repository Root'],
                    to_info['Repository Root'],
                    self.relpath]
-        RunSVN(options, command, self._root_dir)
+        RunSVN(command, self._root_dir)
         from_info['URL'] = from_info['URL'].replace(
             from_info['Repository Root'],
             to_info['Repository Root'])
 
     # If the provided url has a revision number that matches the revision
     # number of the existing directory, then we don't need to bother updating.
     if not options.force and from_info['Revision'] == revision:
       if options.verbose or not forced_revision:
-        print >>options.stdout, ("\n_____ %s%s" % (
-            self.relpath, rev_str))
+        print("\n_____ %s%s" % (self.relpath, rev_str))
       return
 
     command = ["update", os.path.join(self._root_dir, self.relpath)]
     if revision:
       command.extend(['--revision', str(revision)])
-    RunSVNAndGetFileList(options, command, self._root_dir, file_list)
+    RunSVNAndGetFileList(command, self._root_dir, file_list)
 
   def revert(self, options, args, file_list):
     """Reverts local modifications. Subversion specific.
 
     All reverted files will be appended to file_list, even if Subversion
     doesn't know about them.
     """
     path = os.path.join(self._root_dir, self.relpath)
     if not os.path.isdir(path):
       # svn revert won't work if the directory doesn't exist. It needs to
       # checkout instead.
-      print >>options.stdout, ("\n_____ %s is missing, synching instead" %
-                               self.relpath)
+      print("\n_____ %s is missing, synching instead" % self.relpath)
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
-    files = CaptureSVNStatus(options, path)
+    files = CaptureSVNStatus(path)
     # Batch the command.
     files_to_revert = []
     for file in files:
       file_path = os.path.join(path, file.path)
-      print >>options.stdout, file_path
+      print(file_path)
       # Unversioned file or unexpected unversioned file.
       if file.text_status in ('?', '~'):
         # Remove extraneous file. Also remove unexpected unversioned
         # directories. svn won't touch them but we want to delete these.
         file_list.append(file_path)
         try:
           os.remove(file_path)
         except EnvironmentError:
           RemoveDirectory(file_path)
 
       if file.text_status != '?':
         # For any other status, svn revert will work.
         file_list.append(file_path)
         files_to_revert.append(file.path)
 
     # Revert them all at once.
     if files_to_revert:
       accumulated_paths = []
       accumulated_length = 0
       command = ['revert']
       for p in files_to_revert:
         # Some shell have issues with command lines too long.
         if accumulated_length and accumulated_length + len(p) > 3072:
-          RunSVN(options, command + accumulated_paths,
+          RunSVN(command + accumulated_paths,
                  os.path.join(self._root_dir, self.relpath))
           accumulated_paths = []
           accumulated_length = 0
         else:
           accumulated_paths.append(p)
           accumulated_length += len(p)
       if accumulated_paths:
-        RunSVN(options, command + accumulated_paths,
+        RunSVN(command + accumulated_paths,
                os.path.join(self._root_dir, self.relpath))
 
   def status(self, options, args, file_list):
     """Display status information."""
     path = os.path.join(self._root_dir, self.relpath)
     command = ['status']
     command.extend(args)
     if not os.path.isdir(path):
       # svn status won't work if the directory doesn't exist.
-      print >> options.stdout, (
-          "\n________ couldn't run \'%s\' in \'%s\':\nThe directory "
-          "does not exist."
-          % (' '.join(command), path))
+      print("\n________ couldn't run \'%s\' in \'%s\':\nThe directory "
+            "does not exist."
+            % (' '.join(command), path))
       # There's no file list to retrieve.
     else:
-      RunSVNAndGetFileList(options, command, path, file_list)
+      RunSVNAndGetFileList(command, path, file_list)
 
 
 ## GClient implementation.
 
 
 class GClient(object):
   """Object that represent a gclient checkout."""
 
   supported_commands = [
     'cleanup', 'diff', 'revert', 'status', 'update', 'runhooks'
@@ skipping 260 matching lines @@
     command = hook_dict['action'][:]
     if command[0] == 'python':
       # If the hook specified "python" as the first item, the action is a
       # Python script.  Run it by starting a new copy of the same
       # interpreter.
       command[0] = sys.executable
 
     # Use a discrete exit status code of 2 to indicate that a hook action
     # failed.  Users of this script may wish to treat hook action failures
     # differently from VC failures.
-    SubprocessCall(command, self._root_dir, self._options.stdout,
-                   fail_status=2)
+    SubprocessCall(command, self._root_dir, fail_status=2)
 
   def _RunHooks(self, command, file_list, is_using_git):
     """Evaluates all hooks, running actions as needed.
     """
     # Hooks only run for these command types.
     if not command in ('update', 'revert', 'runhooks'):
       return
 
     # Get any hooks from the .gclient file.
     hooks = self.GetVar("hooks", [])
@@ skipping 122 matching lines @@
     self._RunHooks(command, file_list, is_using_git)
 
     if command == 'update':
       # notify the user if there is an orphaned entry in their working copy.
       # TODO(darin): we should delete this directory manually if it doesn't
       # have any changes in it.
       prev_entries = self._ReadEntries()
       for entry in prev_entries:
         e_dir = os.path.join(self._root_dir, entry)
         if entry not in entries and self._options.path_exists(e_dir):
-          if CaptureSVNStatus(self._options, e_dir):
+          if CaptureSVNStatus(e_dir):
             # There are modified files in this entry
             entries[entry] = None  # Keep warning until removed.
-            print >> self._options.stdout, (
-                "\nWARNING: \"%s\" is no longer part of this client.  "
-                "It is recommended that you manually remove it.\n") % entry
+            print("\nWARNING: \"%s\" is no longer part of this client.  "
+                  "It is recommended that you manually remove it.\n") % entry
           else:
             # Delete the entry
-            print >> self._options.stdout, ("\n________ deleting \'%s\' " +
-                "in \'%s\'") % (entry, self._root_dir)
+            print("\n________ deleting \'%s\' " +
+                  "in \'%s\'") % (entry, self._root_dir)
             RemoveDirectory(e_dir)
       # record the current list of entries for next time
       self._SaveEntries(entries)
 
   def PrintRevInfo(self):
     """Output revision info mapping for the client and its dependencies. This
     allows the capture of a overall "revision" for the source tree that can
     be used to reproduce the same tree in the future. The actual output
     contains enough information (source paths, svn server urls and revisions)
     that it can be used either to generate external svn commands (without
@@ skipping 28 matching lines @@
     entries_deps_content = {}
 
     # Inner helper to generate base url and rev tuple (including honoring
     # |revision_overrides|)
     def GetURLAndRev(name, original_url):
       if original_url.find("@") < 0:
         if revision_overrides.has_key(name):
           return (original_url, int(revision_overrides[name]))
         else:
           # TODO(aharper): SVN/SCMWrapper cleanup (non-local commandset)
-          return (original_url, CaptureSVNHeadRevision(self._options,
-                                                       original_url))
+          return (original_url, CaptureSVNHeadRevision(original_url))
       else:
         url_components = original_url.split("@")
         if revision_overrides.has_key(name):
           return (url_components[0], int(revision_overrides[name]))
         else:
           return (url_components[0], int(url_components[1]))
 
     # Run on the base solutions first.
     for solution in solutions:
       name = solution["name"]
       if name in entries:
         raise Error("solution %s specified more than once" % name)
       (url, rev) = GetURLAndRev(name, solution["url"])
       entries[name] = "%s@%d" % (url, rev)
       # TODO(aharper): SVN/SCMWrapper cleanup (non-local commandset)
       entries_deps_content[name] = CaptureSVN(
-                                     self._options,
                                      ["cat",
                                       "%s/%s@%d" % (url,
                                                     self._options.deps_file,
                                                     rev)],
                                      os.getcwd())
 
     # Process the dependencies next (sort alphanumerically to ensure that
     # containing directories get populated first and for readability)
     deps = self._ParseAllDeps(entries, entries_deps_content)
     deps_to_process = deps.keys()
     deps_to_process.sort()
 
     # First pass for direct dependencies.
     for d in deps_to_process:
       if type(deps[d]) == str:
         (url, rev) = GetURLAndRev(d, deps[d])
         entries[d] = "%s@%d" % (url, rev)
 
     # Second pass for inherited deps (via the From keyword)
     for d in deps_to_process:
       if type(deps[d]) != str:
         deps_parent_url = entries[deps[d].module_name]
         if deps_parent_url.find("@") < 0:
           raise Error("From %s missing revisioned url" % deps[d].module_name)
         deps_parent_url_components = deps_parent_url.split("@")
         # TODO(aharper): SVN/SCMWrapper cleanup (non-local commandset)
         deps_parent_content = CaptureSVN(
-                                self._options,
                                 ["cat",
                                  "%s/%s@%s" % (deps_parent_url_components[0],
                                                self._options.deps_file,
                                                deps_parent_url_components[1])],
                                 os.getcwd())
         sub_deps = self._ParseSolutionDeps(
                            deps[d].module_name,
                            FileRead(os.path.join(self._root_dir,
                                                  deps[d].module_name,
                                                  self._options.deps_file)),
                            {})
         (url, rev) = GetURLAndRev(d, sub_deps[d])
         entries[d] = "%s@%d" % (url, rev)
 
-    print ";".join(["%s,%s" % (x, entries[x]) for x in sorted(entries.keys())])
+    print(";".join(["%s,%s" % (x, entries[x]) for x in sorted(entries.keys())]))
 
 
 ## gclient commands.
 
 
 def DoCleanup(options, args):
   """Handle the cleanup subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
   client = options.gclient.LoadCurrentConfig(options)
   if not client:
     raise Error("client not configured; see 'gclient config'")
   if options.verbose:
     # Print out the .gclient file.  This is longer than if we just printed the
     # client dict, but more legible, and it might contain helpful comments.
-    print >>options.stdout, client.ConfigContent()
+    print(client.ConfigContent())
   options.verbose = True
   return client.RunOnDeps('cleanup', args)
 
 
 def DoConfig(options, args):
   """Handle the config subcommand.
 
   Args:
     options: If options.spec set, a string providing contents of config file.
     args: The command line args.  If spec is not set,
@@ skipping 22 matching lines @@
   client.SaveConfig()
 
 
 def DoHelp(options, args):
   """Handle the help subcommand giving help for another subcommand.
 
   Raises:
     Error: if the command is unknown.
   """
   if len(args) == 1 and args[0] in COMMAND_USAGE_TEXT:
-    print >>options.stdout, COMMAND_USAGE_TEXT[args[0]]
+    print(COMMAND_USAGE_TEXT[args[0]])
   else:
     raise Error("unknown subcommand '%s'; see 'gclient help'" % args[0])
 
 
 def DoStatus(options, args):
   """Handle the status subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
   client = options.gclient.LoadCurrentConfig(options)
   if not client:
     raise Error("client not configured; see 'gclient config'")
   if options.verbose:
     # Print out the .gclient file.  This is longer than if we just printed the
     # client dict, but more legible, and it might contain helpful comments.
-    print >>options.stdout, client.ConfigContent()
+    print(client.ConfigContent())
   options.verbose = True
   return client.RunOnDeps('status', args)
 
 
 def DoUpdate(options, args):
   """Handle the update and sync subcommands.
 
   Raises:
     Error: if client isn't configured properly.
   """
@@ skipping 18 matching lines @@
           if not has_key:
             handle = urllib.urlopen(s['safesync_url'])
             rev = handle.read().strip()
             handle.close()
             if len(rev):
               options.revisions.append(s['name']+'@'+rev)
 
   if options.verbose:
     # Print out the .gclient file.  This is longer than if we just printed the
     # client dict, but more legible, and it might contain helpful comments.
-    print >>options.stdout, client.ConfigContent()
+    print(client.ConfigContent())
   return client.RunOnDeps('update', args)
 
 
 def DoDiff(options, args):
   """Handle the diff subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
   client = options.gclient.LoadCurrentConfig(options)
   if not client:
     raise Error("client not configured; see 'gclient config'")
   if options.verbose:
     # Print out the .gclient file.  This is longer than if we just printed the
     # client dict, but more legible, and it might contain helpful comments.
-    print >>options.stdout, client.ConfigContent()
+    print(client.ConfigContent())
   options.verbose = True
   return client.RunOnDeps('diff', args)
 
 
 def DoRevert(options, args):
   """Handle the revert subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
   client = options.gclient.LoadCurrentConfig(options)
   if not client:
     raise Error("client not configured; see 'gclient config'")
   return client.RunOnDeps('revert', args)
 
 
 def DoRunHooks(options, args):
   """Handle the runhooks subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
   client = options.gclient.LoadCurrentConfig(options)
   if not client:
     raise Error("client not configured; see 'gclient config'")
   if options.verbose:
     # Print out the .gclient file.  This is longer than if we just printed the
     # client dict, but more legible, and it might contain helpful comments.
-    print >>options.stdout, client.ConfigContent()
+    print(client.ConfigContent())
   return client.RunOnDeps('runhooks', args)
 
 
 def DoRevInfo(options, args):
   """Handle the revinfo subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
   client = options.gclient.LoadCurrentConfig(options)
@@ skipping 78 matching lines @@
 
   if len(argv) < 3 and command == "help":
     option_parser.print_help()
     return 0
 
   # Files used for configuration and state saving.
   options.config_filename = os.environ.get("GCLIENT_FILE", ".gclient")
   options.entries_filename = ".gclient_entries"
   options.deps_file = "DEPS"
 
-  # These are overridded when testing. They are not externally visible.
-  options.stdout = sys.stdout
   options.path_exists = os.path.exists
   options.gclient = GClient
   options.scm_wrapper = SCMWrapper
   options.platform = sys.platform
   return DispatchCommand(command, options, args)
 
 
 if "__main__" == __name__:
   try:
     result = Main(sys.argv)
   except Error, e:
-    print "Error: %s" % str(e)
+    print >> sys.stderr, "Error: %s" % str(e)
     result = 1
   sys.exit(result)
 
 # vim: ts=2:sw=2:tw=80:et: