Enable parallel checkout by default to --jobs=8 and smoke tests.

tests/gclient_smoketest.py

 #!/usr/bin/python
 # Copyright (c) 2010 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.
 
 """Smoke tests for gclient.py.
 
 Shell out 'gclient' and run basic conformance tests.
 
 This test assumes GClientSmokeBase.URL_BASE is valid.
@@ skipping 31 matching lines @@
     cmd = cmd_base + cmd
     process = subprocess.Popen(cmd, cwd=cwd, env=self.env,
                                stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                                shell=sys.platform.startswith('win'))
     (stdout, stderr) = process.communicate()
     logging.debug("XXX: %s\n%s\nXXX" % (' '.join(cmd), stdout))
     logging.debug("YYY: %s\n%s\nYYY" % (' '.join(cmd), stderr))
     return (stdout.replace('\r\n', '\n'), stderr.replace('\r\n', '\n'),
             process.returncode)
 
-  def parseGclient(self, cmd, items, expected_stderr=''):
-    """Parse gclient's output to make it easier to test."""
+  def parseGclient(self, cmd, items, expected_stderr='', untangle=False):
+    """Parse gclient's output to make it easier to test.
+    If untangle is True, tries to sort out the output from parallel checkout."""
     (stdout, stderr, returncode) = self.gclient(cmd)
+    if untangle:
+      tasks = {}
+      remaining = []
+      for line in stdout.splitlines(False):
+        m = re.match(r'^(\d)+>(.*)$', line)
+        if not m:
+          remaining.append(line)
+        else:
+          self.assertEquals([], remaining)
+          tasks.setdefault(int(m.group(1)), []).append(m.group(2))
+      out = []
+      for key in sorted(tasks.iterkeys()):
+        out.extend(tasks[key])
+      out.extend(remaining)
+      stdout = '\n'.join(out)
     self.checkString(expected_stderr, stderr)
     self.assertEquals(0, returncode)
     return self.checkBlock(stdout, items)
 
   def splitBlock(self, stdout):
     """Split gclient's output into logical execution blocks.
     ___ running 'foo' at '/bar'
     (...)
     ___ running 'baz' at '/bar'
     (...)
 
     will result in 2 items of len((...).splitlines()) each.
     """
     results = []
     for line in stdout.splitlines(False):
       # Intentionally skips empty lines.
       if not line:
         continue
       if line.startswith('__'):
         match = re.match(r'^________ ([a-z]+) \'(.*)\' in \'(.*)\'$', line)
         if not match:
           match = re.match(r'^_____ (.*) is missing, synching instead$', line)
           if match:
             # Blah, it's when a dependency is deleted, we should probably not
             # output this message.
             results.append([line])
-          else:
-            print line
-            raise Exception('fail', line)
+          elif (
+              not re.match(
+                  r'_____ [^ ]+ : Attempting rebase onto [0-9a-f]+...',
+                  line) and
+              not re.match(r'_____ [^ ]+ at [^ ]+', line)):
+            # The two regexp above are a bit too broad, they are necessary only
+            # for git checkouts.
+            self.fail(line)
         else:
           results.append([[match.group(1), match.group(2), match.group(3)]])
       else:
         if not results:
           # TODO(maruel): gclient's git stdout is inconsistent.
           # This should fail the test instead!!
           pass
         else:
           results[-1].append(line)
     return results
@@ skipping 123 matching lines @@
   def testDifferentTopLevelDirectory(self):
     # Check that even if the .gclient file does not mention the directory src
     # itself, but it is included via dependencies, the .gclient file is used.
     self.gclient(['config', self.svn_base + 'trunk/src.DEPS'])
     deps = join(self.root_dir, 'src.DEPS')
     os.mkdir(deps)
     write(join(deps, 'DEPS'),
         'deps = { "src": "%strunk/src" }' % (self.svn_base))
     src = join(self.root_dir, 'src')
     os.mkdir(src)
-    res = self.gclient(['status'], src)
+    res = self.gclient(['status', '--jobs', '1'], src)
     self.checkBlock(res[0], [('running', deps), ('running', src)])
 
 
 class GClientSmokeSVN(GClientSmokeBase):
   def setUp(self):
     GClientSmokeBase.setUp(self)
     self.FAKE_REPOS.setUpSVN()
 
   def testSync(self):
     # TODO(maruel): safesync.
     self.gclient(['config', self.svn_base + 'trunk/src/'])
     # Test unversioned checkout.
-    self.parseGclient(['sync', '--deps', 'mac'],
+    self.parseGclient(['sync', '--deps', 'mac', '--jobs', '1'],
                       ['running', 'running',
                        # This is due to the way svn update is called for a
                        # single file when File() is used in a DEPS file.
                        ('running', self.root_dir + '/src/file/other'),
                        'running', 'running', 'running', 'running'])
     tree = self.mangle_svn_tree(
         ('trunk/src@2', 'src'),
         ('trunk/third_party/foo@1', 'src/third_party/foo'),
         ('trunk/other@2', 'src/other'))
     tree['src/file/other/DEPS'] = (
         self.FAKE_REPOS.svn_revs[2]['trunk/other/DEPS'])
     tree['src/svn_hooked1'] = 'svn_hooked1'
     self.assertTree(tree)
 
     # Manually remove svn_hooked1 before synching to make sure it's not
     # recreated.
     os.remove(join(self.root_dir, 'src', 'svn_hooked1'))
 
     # Test incremental versioned sync: sync backward.
-    self.parseGclient(['sync', '--revision', 'src@1', '--deps', 'mac',
-                       '--delete_unversioned_trees'],
-                      ['running', 'running', 'running', 'running', 'deleting'])
+    self.parseGclient(
+        ['sync', '--revision', 'src@1', '--deps', 'mac',
+          '--delete_unversioned_trees', '--jobs', '1'],
+        ['running', 'running', 'running', 'running', 'deleting'])
     tree = self.mangle_svn_tree(
         ('trunk/src@1', 'src'),
         ('trunk/third_party/foo@2', 'src/third_party/fpp'),
         ('trunk/other@1', 'src/other'),
         ('trunk/third_party/foo@2', 'src/third_party/prout'))
     tree['src/file/other/DEPS'] = (
         self.FAKE_REPOS.svn_revs[2]['trunk/other/DEPS'])
     self.assertTree(tree)
     # Test incremental sync: delete-unversioned_trees isn't there.
-    self.parseGclient(['sync', '--deps', 'mac'],
+    self.parseGclient(['sync', '--deps', 'mac', '--jobs', '1'],
                       ['running', 'running', 'running', 'running', 'running'])
     tree = self.mangle_svn_tree(
         ('trunk/src@2', 'src'),
         ('trunk/third_party/foo@2', 'src/third_party/fpp'),
         ('trunk/third_party/foo@1', 'src/third_party/foo'),
         ('trunk/other@2', 'src/other'),
         ('trunk/third_party/foo@2', 'src/third_party/prout'))
     tree['src/file/other/DEPS'] = (
         self.FAKE_REPOS.svn_revs[2]['trunk/other/DEPS'])
     tree['src/svn_hooked1'] = 'svn_hooked1'
     self.assertTree(tree)
 
   def testSyncIgnoredSolutionName(self):
     """TODO(maruel): This will become an error soon."""
     self.gclient(['config', self.svn_base + 'trunk/src/'])
-    results = self.gclient(['sync', '--deps', 'mac', '-r', 'invalid@1'])
+    results = self.gclient(
+        ['sync', '--deps', 'mac', '-r', 'invalid@1', '--jobs', '1'])
     self.checkBlock(results[0], [
         'running', 'running',
         # This is due to the way svn update is called for a single file when
         # File() is used in a DEPS file.
         ('running', self.root_dir + '/src/file/other'),
         'running', 'running', 'running', 'running'])
     self.checkString('Please fix your script, having invalid --revision flags '
         'will soon considered an error.\n', results[1])
     self.assertEquals(0, results[2])
     tree = self.mangle_svn_tree(
         ('trunk/src@2', 'src'),
         ('trunk/third_party/foo@1', 'src/third_party/foo'),
         ('trunk/other@2', 'src/other'))
     tree['src/file/other/DEPS'] = (
         self.FAKE_REPOS.svn_revs[2]['trunk/other/DEPS'])
     tree['src/svn_hooked1'] = 'svn_hooked1'
     self.assertTree(tree)
 
   def testSyncNoSolutionName(self):
     # When no solution name is provided, gclient uses the first solution listed.
     self.gclient(['config', self.svn_base + 'trunk/src/'])
-    self.parseGclient(['sync', '--deps', 'mac', '-r', '1'],
+    self.parseGclient(['sync', '--deps', 'mac', '-r', '1', '--jobs', '1'],
                       ['running', 'running', 'running', 'running'])
     tree = self.mangle_svn_tree(
         ('trunk/src@1', 'src'),
         ('trunk/third_party/foo@2', 'src/third_party/fpp'),
         ('trunk/other@1', 'src/other'),
         ('trunk/third_party/foo@2', 'src/third_party/prout'))
     self.assertTree(tree)
 
+  def testSyncJobs(self):
+    # TODO(maruel): safesync.
+    self.gclient(['config', self.svn_base + 'trunk/src/'])
+    # Test unversioned checkout.
+    self.parseGclient(
+        ['sync', '--deps', 'mac', '--jobs', '8'],
+        ['running', 'running',
+        # This is due to the way svn update is called for a
+        # single file when File() is used in a DEPS file.
+        ('running', self.root_dir + '/src/file/other'),
+        'running', 'running', 'running', 'running'],
+        untangle=True)
+    tree = self.mangle_svn_tree(
+        ('trunk/src@2', 'src'),
+        ('trunk/third_party/foo@1', 'src/third_party/foo'),
+        ('trunk/other@2', 'src/other'))
+    tree['src/file/other/DEPS'] = (
+        self.FAKE_REPOS.svn_revs[2]['trunk/other/DEPS'])
+    tree['src/svn_hooked1'] = 'svn_hooked1'
+    self.assertTree(tree)
+
+    # Manually remove svn_hooked1 before synching to make sure it's not
+    # recreated.
+    os.remove(join(self.root_dir, 'src', 'svn_hooked1'))
+
+    # Test incremental versioned sync: sync backward.
+    self.parseGclient(
+        ['sync', '--revision', 'src@1', '--deps', 'mac',
+          '--delete_unversioned_trees', '--jobs', '8'],
+        ['running', 'running', 'running', 'running', 'deleting'],
+        untangle=True)
+    tree = self.mangle_svn_tree(
+        ('trunk/src@1', 'src'),
+        ('trunk/third_party/foo@2', 'src/third_party/fpp'),
+        ('trunk/other@1', 'src/other'),
+        ('trunk/third_party/foo@2', 'src/third_party/prout'))
+    tree['src/file/other/DEPS'] = (
+        self.FAKE_REPOS.svn_revs[2]['trunk/other/DEPS'])
+    self.assertTree(tree)
+    # Test incremental sync: delete-unversioned_trees isn't there.
+    self.parseGclient(['sync', '--deps', 'mac', '--jobs', '8'],
+                      ['running', 'running', 'running', 'running', 'running'],
+                      untangle=True)
+    tree = self.mangle_svn_tree(
+        ('trunk/src@2', 'src'),
+        ('trunk/third_party/foo@2', 'src/third_party/fpp'),
+        ('trunk/third_party/foo@1', 'src/third_party/foo'),
+        ('trunk/other@2', 'src/other'),
+        ('trunk/third_party/foo@2', 'src/third_party/prout'))
+    tree['src/file/other/DEPS'] = (
+        self.FAKE_REPOS.svn_revs[2]['trunk/other/DEPS'])
+    tree['src/svn_hooked1'] = 'svn_hooked1'
+    self.assertTree(tree)
+
   def testRevertAndStatus(self):
     self.gclient(['config', self.svn_base + 'trunk/src/'])
     # Tested in testSync.
     self.gclient(['sync', '--deps', 'mac'])
     write(join(self.root_dir, 'src', 'other', 'hi'), 'Hey!')
 
-    out = self.parseGclient(['status', '--deps', 'mac'],
+    out = self.parseGclient(['status', '--deps', 'mac', '--jobs', '1'],
                             [['running', join(self.root_dir, 'src')],
                              ['running', join(self.root_dir, 'src', 'other')]])
     out = self.svnBlockCleanup(out)
     self.checkString('file', out[0][1])
     self.checkString('other', out[0][2])
     self.checkString('svn_hooked1', out[0][3])
     self.checkString(join('third_party', 'foo'), out[0][4])
     self.checkString('hi', out[1][1])
     self.assertEquals(5, len(out[0]))
     self.assertEquals(2, len(out[1]))
 
     # Revert implies --force implies running hooks without looking at pattern
     # matching.
-    results = self.gclient(['revert', '--deps', 'mac'])
+    results = self.gclient(['revert', '--deps', 'mac', '--jobs', '1'])
     out = self.splitBlock(results[0])
     # src, src/other is missing, src/other, src/third_party/foo is missing,
     # src/third_party/foo, 2 svn hooks, 3 related to File().
     self.assertEquals(10, len(out))
     self.checkString('', results[1])
     self.assertEquals(0, results[2])
     tree = self.mangle_svn_tree(
         ('trunk/src@2', 'src'),
         ('trunk/third_party/foo@1', 'src/third_party/foo'),
         ('trunk/other@2', 'src/other'))
     tree['src/file/other/DEPS'] = (
         self.FAKE_REPOS.svn_revs[2]['trunk/other/DEPS'])
     tree['src/svn_hooked1'] = 'svn_hooked1'
     tree['src/svn_hooked2'] = 'svn_hooked2'
     self.assertTree(tree)
 
-    out = self.parseGclient(['status', '--deps', 'mac'],
+    out = self.parseGclient(['status', '--deps', 'mac', '--jobs', '1'],
                             [['running', join(self.root_dir, 'src')]])
     out = self.svnBlockCleanup(out)
     self.checkString('file', out[0][1])
     self.checkString('other', out[0][2])
     self.checkString('svn_hooked1', out[0][3])
     self.checkString('svn_hooked2', out[0][4])
     self.checkString(join('third_party', 'foo'), out[0][5])
     self.assertEquals(6, len(out[0]))
     self.assertEquals(1, len(out))
 
   def testRevertAndStatusDepsOs(self):
     self.gclient(['config', self.svn_base + 'trunk/src/'])
     # Tested in testSync.
     self.gclient(['sync', '--deps', 'mac', '--revision', 'src@1'])
     write(join(self.root_dir, 'src', 'other', 'hi'), 'Hey!')
 
     # Without --verbose, gclient won't output the directories without
     # modification.
-    out = self.parseGclient(['status', '--deps', 'mac'],
+    out = self.parseGclient(['status', '--deps', 'mac', '--jobs', '1'],
                             [['running', join(self.root_dir, 'src')],
                              ['running', join(self.root_dir, 'src', 'other')]])
     out = self.svnBlockCleanup(out)
     self.checkString('other', out[0][1])
     self.checkString(join('third_party', 'fpp'), out[0][2])
     self.checkString(join('third_party', 'prout'), out[0][3])
     self.checkString('hi', out[1][1])
     self.assertEquals(4, len(out[0]))
     self.assertEquals(2, len(out[1]))
 
     # So verify it works with --verbose.
-    out = self.parseGclient(['status', '--deps', 'mac', '--verbose'],
+    out = self.parseGclient(
+        ['status', '--deps', 'mac', '--verbose', '--jobs', '1'],
         [['running', join(self.root_dir, 'src')],
           ['running', join(self.root_dir, 'src', 'third_party', 'fpp')],
           ['running', join(self.root_dir, 'src', 'other')],
           ['running', join(self.root_dir, 'src', 'third_party', 'prout')]])
     out = self.svnBlockCleanup(out)
     self.checkString('other', out[0][1])
     self.checkString(join('third_party', 'fpp'), out[0][2])
     self.checkString(join('third_party', 'prout'), out[0][3])
     self.checkString('hi', out[2][1])
     self.assertEquals(4, len(out[0]))
     self.assertEquals(1, len(out[1]))
     self.assertEquals(2, len(out[2]))
     self.assertEquals(1, len(out[3]))
     self.assertEquals(4, len(out))
 
     # Revert implies --force implies running hooks without looking at pattern
     # matching.
     # TODO(maruel): In general, gclient revert output is wrong. It should output
     # the file list after some ___ running 'svn status'
-    results = self.gclient(['revert', '--deps', 'mac'])
+    results = self.gclient(['revert', '--deps', 'mac', '--jobs', '1'])
     out = self.splitBlock(results[0])
     self.assertEquals(7, len(out))
     self.checkString('', results[1])
     self.assertEquals(0, results[2])
     tree = self.mangle_svn_tree(
         ('trunk/src@1', 'src'),
         ('trunk/third_party/foo@2', 'src/third_party/fpp'),
         ('trunk/other@1', 'src/other'),
         ('trunk/third_party/prout@2', 'src/third_party/prout'))
     self.assertTree(tree)
 
-    out = self.parseGclient(['status', '--deps', 'mac'],
+    out = self.parseGclient(['status', '--deps', 'mac', '--jobs', '1'],
                             [['running', join(self.root_dir, 'src')]])
     out = self.svnBlockCleanup(out)
     self.checkString('other', out[0][1])
     self.checkString(join('third_party', 'fpp'), out[0][2])
     self.checkString(join('third_party', 'prout'), out[0][3])
     self.assertEquals(4, len(out[0]))
 
   def testRunHooks(self):
     self.gclient(['config', self.svn_base + 'trunk/src/'])
     self.gclient(['sync', '--deps', 'mac'])
@@ skipping 53 matching lines @@
     os.mkdir(other_src)
     res = ('', 'Error: client not configured; see \'gclient config\'\n', 1)
     self.check(res, self.gclient(['status'], other_src))
 
   def testCorrectDirectory(self):
     # Check that when we're in the subdirectory src, the .gclient configuration
     # is used.
     self.gclient(['config', self.svn_base + 'trunk/src/'])
     self.gclient(['sync'])
     src = join(self.root_dir, 'src')
-    res = self.gclient(['status'], src)
+    res = self.gclient(['status', '--jobs', '1'], src)
     self.checkBlock(res[0], [('running', src)])
 
   def testInitialCheckoutNotYetDone(self):
     # Check that gclient can be executed when the initial checkout hasn't been
     # done yet.
     self.gclient(['config', self.svn_base + 'trunk/src/'])
-    self.parseGclient(['sync'],
+    self.parseGclient(['sync', '--jobs', '1'],
                       ['running', 'running',
                        # This is due to the way svn update is called for a
                        # single file when File() is used in a DEPS file.
                        ('running', self.root_dir + '/src/file/other'),
                        'running', 'running', 'running', 'running'])
 
   def testInitialCheckoutFailed(self):
     # Check that gclient can be executed from an arbitrary sub directory if the
     # initial checkout has failed.
     self.gclient(['config', self.svn_base + 'trunk/src/'])
     self.gclient(['sync'])
     # Cripple the checkout.
     os.remove(join(self.root_dir, '.gclient_entries'))
     src = join(self.root_dir, 'src')
-    res = self.gclient(['sync'], src)
+    res = self.gclient(['sync', '--jobs', '1'], src)
     self.checkBlock(res[0],
                     ['running', 'running', 'running'])
 
 
 class GClientSmokeGIT(GClientSmokeBase):
   def setUp(self):
     GClientSmokeBase.setUp(self)
     self.enabled = self.FAKE_REPOS.setUpGIT()
 
   def testSync(self):
     if not self.enabled:
       return
     # TODO(maruel): safesync.
     self.gclient(['config', self.git_base + 'repo_1', '--name', 'src'])
     # Test unversioned checkout.
-    self.parseGclient(['sync', '--deps', 'mac'],
+    self.parseGclient(['sync', '--deps', 'mac', '--jobs', '1'],
                       ['running', 'running', 'running', 'running', 'running'])
     # TODO(maruel): http://crosbug.com/3582 hooks run even if not matching, must
     # add sync parsing to get the list of updated files.
     tree = self.mangle_git_tree(('repo_1@2', 'src'),
                                 ('repo_2@1', 'src/repo2'),
                                 ('repo_3@2', 'src/repo2/repo_renamed'))
     tree['src/git_hooked1'] = 'git_hooked1'
     tree['src/git_hooked2'] = 'git_hooked2'
     self.assertTree(tree)
 
     # Manually remove git_hooked1 before synching to make sure it's not
     # recreated.
     os.remove(join(self.root_dir, 'src', 'git_hooked1'))
 
     # Test incremental versioned sync: sync backward.
-    results = self.gclient(['sync', '--revision',
-                            'src@' + self.githash('repo_1', 1),
-                            '--deps', 'mac', '--delete_unversioned_trees'])
-    # gclient's git output is unparsable and all messed up. Don't look at it, it
-    # hurts the smoke test's eyes. Add "print out" here if you want to dare to
-    # parse it. So just assert it's not empty and look at the result on the file
-    # system instead.
-    self.assertEquals('', results[1])
-    self.assertEquals(0, results[2])
+    self.parseGclient(['sync', '--jobs', '1', '--revision',
+                       'src@' + self.githash('repo_1', 1),
+                       '--deps', 'mac', '--delete_unversioned_trees'],
+                       ['running', 'running', 'deleting'])
     tree = self.mangle_git_tree(('repo_1@1', 'src'),
                                 ('repo_2@2', 'src/repo2'),
                                 ('repo_3@1', 'src/repo2/repo3'),
                                 ('repo_4@2', 'src/repo4'))
     tree['src/git_hooked2'] = 'git_hooked2'
     self.assertTree(tree)
     # Test incremental sync: delete-unversioned_trees isn't there.
-    results = self.gclient(['sync', '--deps', 'mac'])
-    # See comment above about parsing gclient's git output.
-    self.assertEquals('', results[1])
-    self.assertEquals(0, results[2])
+    self.parseGclient(['sync', '--deps', 'mac', '--jobs', '1'],
+        ['running', 'running', 'running'])
     tree = self.mangle_git_tree(('repo_1@2', 'src'),
                                 ('repo_2@1', 'src/repo2'),
                                 ('repo_3@1', 'src/repo2/repo3'),
                                 ('repo_3@2', 'src/repo2/repo_renamed'),
                                 ('repo_4@2', 'src/repo4'))
     tree['src/git_hooked1'] = 'git_hooked1'
     tree['src/git_hooked2'] = 'git_hooked2'
     self.assertTree(tree)
 
   def testSyncIgnoredSolutionName(self):
     """TODO(maruel): This will become an error soon."""
     if not self.enabled:
       return
     self.gclient(['config', self.git_base + 'repo_1', '--name', 'src'])
     self.parseGclient(
-        ['sync', '--deps', 'mac',
+        ['sync', '--deps', 'mac', '--jobs', '1',
          '--revision', 'invalid@' + self.githash('repo_1', 1)],
         ['running', 'running', 'running', 'running', 'running'],
         'Please fix your script, having invalid --revision flags '
             'will soon considered an error.\n')
     tree = self.mangle_git_tree(('repo_1@2', 'src'),
                                 ('repo_2@1', 'src/repo2'),
                                 ('repo_3@2', 'src/repo2/repo_renamed'))
     tree['src/git_hooked1'] = 'git_hooked1'
     tree['src/git_hooked2'] = 'git_hooked2'
     self.assertTree(tree)
 
   def testSyncNoSolutionName(self):
     if not self.enabled:
       return
     # When no solution name is provided, gclient uses the first solution listed.
     self.gclient(['config', self.git_base + 'repo_1', '--name', 'src'])
-    self.parseGclient(['sync', '--deps', 'mac',
+    self.parseGclient(['sync', '--deps', 'mac', '--jobs', '1',
                        '--revision', self.githash('repo_1', 1)],
                       ['running', 'running', 'running', 'running'])
     tree = self.mangle_git_tree(('repo_1@1', 'src'),
                                 ('repo_2@2', 'src/repo2'),
                                 ('repo_3@1', 'src/repo2/repo3'),
                                 ('repo_4@2', 'src/repo4'))
     self.assertTree(tree)
 
+  def testSyncJobs(self):
+    if not self.enabled:
+      return
+    # TODO(maruel): safesync.
+    self.gclient(['config', self.git_base + 'repo_1', '--name', 'src'])
+    # Test unversioned checkout.
+    self.parseGclient(['sync', '--deps', 'mac', '--jobs', '8'],
+                      ['running', 'running', 'running', 'running', 'running'],
+                      untangle=True)
+    # TODO(maruel): http://crosbug.com/3582 hooks run even if not matching, must
+    # add sync parsing to get the list of updated files.
+    tree = self.mangle_git_tree(('repo_1@2', 'src'),
+                                ('repo_2@1', 'src/repo2'),
+                                ('repo_3@2', 'src/repo2/repo_renamed'))
+    tree['src/git_hooked1'] = 'git_hooked1'
+    tree['src/git_hooked2'] = 'git_hooked2'
+    self.assertTree(tree)
+
+    # Manually remove git_hooked1 before synching to make sure it's not
+    # recreated.
+    os.remove(join(self.root_dir, 'src', 'git_hooked1'))
+
+    # Test incremental versioned sync: sync backward.
+    self.parseGclient(
+        ['sync', '--revision', 'src@' + self.githash('repo_1', 1),
+          '--deps', 'mac', '--delete_unversioned_trees', '--jobs', '8'],
+        ['running', 'running', 'deleting'],
+        untangle=True)
+    tree = self.mangle_git_tree(('repo_1@1', 'src'),
+                                ('repo_2@2', 'src/repo2'),
+                                ('repo_3@1', 'src/repo2/repo3'),
+                                ('repo_4@2', 'src/repo4'))
+    tree['src/git_hooked2'] = 'git_hooked2'
+    self.assertTree(tree)
+    # Test incremental sync: delete-unversioned_trees isn't there.
+    self.parseGclient(['sync', '--deps', 'mac', '--jobs', '8'],
+        ['running', 'running', 'running'], untangle=True)
+    tree = self.mangle_git_tree(('repo_1@2', 'src'),
+                                ('repo_2@1', 'src/repo2'),
+                                ('repo_3@1', 'src/repo2/repo3'),
+                                ('repo_3@2', 'src/repo2/repo_renamed'),
+                                ('repo_4@2', 'src/repo4'))
+    tree['src/git_hooked1'] = 'git_hooked1'
+    tree['src/git_hooked2'] = 'git_hooked2'
+    self.assertTree(tree)
+
   def testRevertAndStatus(self):
     """TODO(maruel): Remove this line once this test is fixed."""
     if not self.enabled:
       return
     self.gclient(['config', self.git_base + 'repo_1', '--name', 'src'])
     # Tested in testSync.
     self.gclient(['sync', '--deps', 'mac'])
     write(join(self.root_dir, 'src', 'repo2', 'hi'), 'Hey!')
 
     out = self.parseGclient(['status', '--deps', 'mac'], [])
@@ skipping 87 matching lines @@
 
   def testMultiSolutions(self):
     if not self.enabled:
       return
     self.gclient(['config', '--spec',
         'solutions=['
         '{"name": "src",'
         ' "url": "' + self.svn_base + 'trunk/src/"},'
         '{"name": "src-git",'
         '"url": "' + self.git_base + 'repo_1"}]'])
-    self.parseGclient(['sync', '--deps', 'mac'],
+    self.parseGclient(['sync', '--deps', 'mac', '--jobs', '1'],
         ['running', 'running', 'running',
          # This is due to the way svn update is called for a single
          # file when File() is used in a DEPS file.
          ('running', self.root_dir + '/src/file/other'),
          'running', 'running', 'running', 'running', 'running', 'running',
          'running', 'running'])
     tree = self.mangle_git_tree(('repo_1@2', 'src-git'),
                                 ('repo_2@1', 'src/repo2'),
                                 ('repo_3@2', 'src/repo2/repo_renamed'))
     tree.update(self.mangle_svn_tree(
         ('trunk/src@2', 'src'),
         ('trunk/third_party/foo@1', 'src/third_party/foo'),
         ('trunk/other@2', 'src/other')))
     tree['src/file/other/DEPS'] = (
         self.FAKE_REPOS.svn_revs[2]['trunk/other/DEPS'])
     tree['src/git_hooked1'] = 'git_hooked1'
     tree['src/git_hooked2'] = 'git_hooked2'
     tree['src/svn_hooked1'] = 'svn_hooked1'
     self.assertTree(tree)
 
+  def testMultiSolutionsJobs(self):
+    if not self.enabled:
+      return
+    self.gclient(['config', '--spec',
+        'solutions=['
+        '{"name": "src",'
+        ' "url": "' + self.svn_base + 'trunk/src/"},'
+        '{"name": "src-git",'
+        '"url": "' + self.git_base + 'repo_1"}]'])
+    self.parseGclient(['sync', '--deps', 'mac', '--jobs', '8'],
+        ['running', 'running', 'running',
+         # This is due to the way svn update is called for a single
+         # file when File() is used in a DEPS file.
+         ('running', self.root_dir + '/src/file/other'),
+         'running', 'running', 'running', 'running', 'running', 'running',
+         'running', 'running'],
+        untangle=True)
+    tree = self.mangle_git_tree(('repo_1@2', 'src-git'),
+                                ('repo_2@1', 'src/repo2'),
+                                ('repo_3@2', 'src/repo2/repo_renamed'))
+    tree.update(self.mangle_svn_tree(
+        ('trunk/src@2', 'src'),
+        ('trunk/third_party/foo@1', 'src/third_party/foo'),
+        ('trunk/other@2', 'src/other')))
+    tree['src/file/other/DEPS'] = (
+        self.FAKE_REPOS.svn_revs[2]['trunk/other/DEPS'])
+    tree['src/git_hooked1'] = 'git_hooked1'
+    tree['src/git_hooked2'] = 'git_hooked2'
+    tree['src/svn_hooked1'] = 'svn_hooked1'
+    self.assertTree(tree)
+
   def testMultiSolutionsMultiRev(self):
     if not self.enabled:
       return
     self.gclient(['config', '--spec',
         'solutions=['
         '{"name": "src",'
         ' "url": "' + self.svn_base + 'trunk/src/"},'
         '{"name": "src-git",'
         '"url": "' + self.git_base + 'repo_1"}]'])
     self.parseGclient(
-        ['sync', '--deps', 'mac', '--revision', '1',
+        ['sync', '--deps', 'mac', '--jobs', '1', '--revision', '1',
          '-r', 'src-git@' + self.githash('repo_1', 1)],
         ['running', 'running', 'running', 'running',
          'running', 'running', 'running', 'running'])
     tree = self.mangle_git_tree(('repo_1@1', 'src-git'),
                                 ('repo_2@2', 'src/repo2'),
                                 ('repo_3@1', 'src/repo2/repo3'),
                                 ('repo_4@2', 'src/repo4'))
     tree.update(self.mangle_svn_tree(
         ('trunk/src@1', 'src'),
         ('trunk/third_party/foo@2', 'src/third_party/fpp'),
@@ skipping 79 matching lines @@
   def setUp(self):
     GClientSmokeBase.setUp(self)
     self.FAKE_REPOS.setUpSVN()
     os.rmdir(self.root_dir)
     check_call(['svn', 'checkout', 'svn://127.0.0.1/svn/trunk/webkit',
         self.root_dir, '-q',
         '--non-interactive', '--no-auth-cache',
         '--username', 'user1', '--password', 'foo'])
 
   def testSync(self):
-    self.parseGclient(['sync', '--deps', 'mac'], ['running', 'running'])
+    self.parseGclient(['sync', '--deps', 'mac', '--jobs', '1'],
+        ['running', 'running'])
     tree = self.mangle_svn_tree(
         ('trunk/webkit@2', ''),
         ('trunk/third_party/foo@1', 'foo/bar'))
     self.assertTree(tree)
 
   def testRevertAndStatus(self):
     self.gclient(['sync'])
 
     # TODO(maruel): This is incorrect.
-    out = self.parseGclient(['status', '--deps', 'mac'], [])
+    out = self.parseGclient(['status', '--deps', 'mac', '--jobs', '1'], [])
 
     # Revert implies --force implies running hooks without looking at pattern
     # matching.
-    results = self.gclient(['revert', '--deps', 'mac'])
+    results = self.gclient(['revert', '--deps', 'mac', '--jobs', '1'])
     out = self.splitBlock(results[0])
     self.assertEquals(2, len(out))
     self.checkString(2, len(out[0]))
     self.checkString(2, len(out[1]))
     self.checkString('foo', out[1][1])
     self.checkString('', results[1])
     self.assertEquals(0, results[2])
     tree = self.mangle_svn_tree(
         ('trunk/webkit@2', ''),
         ('trunk/third_party/foo@1', 'foo/bar'))
@@ skipping 25 matching lines @@
     # TODO(maruel): To be added after the refactor.
     #results = self.gclient(['revinfo', '--snapshot'])
     #expected = (
     #    './: None\nfoo/bar: svn://127.0.0.1/svn/trunk/third_party/foo@1\n',
     #    '', 0)
     #self.check(expected, results)
 
   def testRest(self):
     self.gclient(['sync'])
     # TODO(maruel): This is incorrect, it should run on ./ too.
-    out = self.parseGclient(['cleanup', '--deps', 'mac', '--verbose'],
-                            [('running', join(self.root_dir, 'foo', 'bar'))])
-    out = self.parseGclient(['diff', '--deps', 'mac', '--verbose'],
-                            [('running', join(self.root_dir, 'foo', 'bar'))])
+    out = self.parseGclient(
+        ['cleanup', '--deps', 'mac', '--verbose', '--jobs', '1'],
+        [('running', join(self.root_dir, 'foo', 'bar'))])
+    out = self.parseGclient(
+        ['diff', '--deps', 'mac', '--verbose', '--jobs', '1'],
+        [('running', join(self.root_dir, 'foo', 'bar'))])
 
 
 if __name__ == '__main__':
   if '-c' in sys.argv:
     COVERAGE = True
     sys.argv.remove('-c')
     if os.path.exists('.coverage'):
       os.remove('.coverage')
     os.environ['COVERAGE_FILE'] = os.path.join(
         os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
         '.coverage')
   unittest.main()