Let benchmark runner exit with proper return codes.

tools/unittests/run_benchmarks_test.py

 #!/usr/bin/env python
 # Copyright 2014 the V8 project authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 from collections import namedtuple
 import coverage
 import json
 from mock import DEFAULT
 from mock import MagicMock
@@ skipping 107 matching lines @@
     os.chdir = MagicMock(side_effect=chdir)
 
   def _CallMain(self, *args):
     self._test_output = path.join(TEST_WORKSPACE, "results.json")
     all_args=[
       "--json-test-results",
       self._test_output,
       self._test_input,
     ]
     all_args += args
-    run_benchmarks.Main(all_args)
+    return run_benchmarks.Main(all_args)
 
   def _LoadResults(self):
     with open(self._test_output) as f:
       return json.load(f)
 
   def _VerifyResults(self, suite, units, traces):
     self.assertEquals([
       {"units": units,
        "graphs": [suite, trace["name"]],
        "results": trace["results"]} for trace in traces],
@@ skipping 11 matching lines @@
     expected = []
     for arg in args:
       a = [path.join(path.dirname(self.base), arg[0])]
       a += arg[1:]
       expected.append(((a,), {"timeout": 60}))
     self.assertEquals(expected, commands.Execute.call_args_list)
 
   def testOneRun(self):
     self._WriteTestInput(V8_JSON)
     self._MockCommand(["."], ["x\nRichards: 1.234\nDeltaBlue: 10657567\ny\n"])
-    self._CallMain()
+    self.assertEquals(0, self._CallMain())
     self._VerifyResults("test", "score", [
       {"name": "Richards", "results": ["1.234"]},
       {"name": "DeltaBlue", "results": ["10657567"]},
     ])
     self._VerifyErrors([])
     self._VerifyMock(path.join("out", "x64.release", "d7"), "--flag", "run.js")
 
   def testTwoRuns_Units_SuiteName(self):
     test_input = dict(V8_JSON)
     test_input["run_count"] = 2
     test_input["name"] = "v8"
     test_input["units"] = "ms"
     self._WriteTestInput(test_input)
     self._MockCommand([".", "."],
                       ["Richards: 100\nDeltaBlue: 200\n",
                        "Richards: 50\nDeltaBlue: 300\n"])
-    self._CallMain()
+    self.assertEquals(0, self._CallMain())
     self._VerifyResults("v8", "ms", [
       {"name": "Richards", "results": ["50", "100"]},
       {"name": "DeltaBlue", "results": ["300", "200"]},
     ])
     self._VerifyErrors([])
     self._VerifyMock(path.join("out", "x64.release", "d7"), "--flag", "run.js")
 
   def testTwoRuns_SubRegexp(self):
     test_input = dict(V8_JSON)
     test_input["run_count"] = 2
     del test_input["results_regexp"]
     test_input["benchmarks"][0]["results_regexp"] = "^Richards: (.+)$"
     test_input["benchmarks"][1]["results_regexp"] = "^DeltaBlue: (.+)$"
     self._WriteTestInput(test_input)
     self._MockCommand([".", "."],
                       ["Richards: 100\nDeltaBlue: 200\n",
                        "Richards: 50\nDeltaBlue: 300\n"])
-    self._CallMain()
+    self.assertEquals(0, self._CallMain())
     self._VerifyResults("test", "score", [
       {"name": "Richards", "results": ["50", "100"]},
       {"name": "DeltaBlue", "results": ["300", "200"]},
     ])
     self._VerifyErrors([])
     self._VerifyMock(path.join("out", "x64.release", "d7"), "--flag", "run.js")
 
   def testNestedSuite(self):
     self._WriteTestInput(V8_NESTED_SUITES_JSON)
     self._MockCommand(["delta_blue", "sub/leaf", "richards"],
                       ["DeltaBlue: 200\n",
                        "Simple: 1 ms.\n",
                        "Simple: 2 ms.\n",
                        "Simple: 3 ms.\n",
                        "Richards: 100\n",
                        "Richards: 50\n"])
-    self._CallMain()
+    self.assertEquals(0, self._CallMain())
     self.assertEquals([
       {"units": "score",
        "graphs": ["test", "Richards"],
        "results": ["50", "100"]},
       {"units": "ms",
        "graphs": ["test", "Sub", "Leaf"],
        "results": ["3", "2", "1"]},
       {"units": "score",
        "graphs": ["test", "DeltaBlue"],
        "results": ["200"]},
       ], self._LoadResults()["traces"])
     self._VerifyErrors([])
     self._VerifyMockMultiple(
         (path.join("out", "x64.release", "d7"), "--flag", "file1.js",
          "file2.js", "run.js"),
         (path.join("out", "x64.release", "d7"), "--flag", "file1.js",
          "file2.js", "run.js"),
         (path.join("out", "x64.release", "d8"), "--flag", "run.js"),
         (path.join("out", "x64.release", "d8"), "--flag", "run.js"),
         (path.join("out", "x64.release", "d8"), "--flag", "run.js"),
         (path.join("out", "x64.release", "d8"), "--flag", "--flag2", "run.js"))
 
   def testBuildbot(self):
     self._WriteTestInput(V8_JSON)
     self._MockCommand(["."], ["Richards: 1.234\nDeltaBlue: 10657567\n"])
-    self._CallMain("--buildbot")
+    self.assertEquals(0, self._CallMain("--buildbot"))
     self._VerifyResults("test", "score", [
       {"name": "Richards", "results": ["1.234"]},
       {"name": "DeltaBlue", "results": ["10657567"]},
     ])
     self._VerifyErrors([])
     self._VerifyMock(path.join("out", "Release", "d7"), "--flag", "run.js")
 
   def testRegexpNoMatch(self):
     self._WriteTestInput(V8_JSON)
     self._MockCommand(["."], ["x\nRichaards: 1.234\nDeltaBlue: 10657567\ny\n"])
-    self._CallMain()
+    self.assertEquals(1, self._CallMain())
     self._VerifyResults("test", "score", [
       {"name": "Richards", "results": []},
       {"name": "DeltaBlue", "results": ["10657567"]},
     ])
     self._VerifyErrors(
         ["Regexp \"^Richards: (.+)$\" didn't match for benchmark Richards."])
     self._VerifyMock(path.join("out", "x64.release", "d7"), "--flag", "run.js")