Make timeout configurable in performance test runner.

tools/unittests/run_perf_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 59 matching lines @@
 
 V8_GENERIC_JSON = {
   "path": ["."],
   "binary": "cc",
   "flags": ["--flag"],
   "generic": True,
   "run_count": 1,
   "units": "ms",
 }
 
-Output = namedtuple("Output", "stdout, stderr")
+Output = namedtuple("Output", "stdout, stderr, timed_out")
 
 class PerfTest(unittest.TestCase):
   @classmethod
   def setUpClass(cls):
     cls.base = path.dirname(path.dirname(path.abspath(__file__)))
     sys.path.append(cls.base)
     cls._cov = coverage.coverage(
         include=([os.path.join(cls.base, "run_perf.py")]))
     cls._cov.start()
     import run_perf
@@ skipping 15 matching lines @@
 
   def tearDown(self):
     if path.exists(TEST_WORKSPACE):
       shutil.rmtree(TEST_WORKSPACE)
 
   def _WriteTestInput(self, json_content):
     self._test_input = path.join(TEST_WORKSPACE, "test.json")
     with open(self._test_input, "w") as f:
       f.write(json.dumps(json_content))
 
-  def _MockCommand(self, *args):
+  def _MockCommand(self, *args, **kwargs):
     # Fake output for each test run.
-    test_outputs = [Output(stdout=arg, stderr=None) for arg in args[1]]
+    test_outputs = [Output(stdout=arg,
+                           stderr=None,
+                           timed_out=kwargs.get("timed_out", False))
+                    for arg in args[1]]
     def execute(*args, **kwargs):
       return test_outputs.pop()
     commands.Execute = MagicMock(side_effect=execute)
 
     # Check that d8 is called from the correct cwd for each test run.
     dirs = [path.join(TEST_WORKSPACE, arg) for arg in args[0]]
     def chdir(*args, **kwargs):
       self.assertEquals(dirs.pop(), args[0])
     os.chdir = MagicMock(side_effect=chdir)
 
@@ skipping 15 matching lines @@
     self.assertEquals([
       {"units": units,
        "graphs": [suite, trace["name"]],
        "results": trace["results"],
        "stddev": trace["stddev"]} for trace in traces],
       self._LoadResults()["traces"])
 
   def _VerifyErrors(self, errors):
     self.assertEquals(errors, self._LoadResults()["errors"])
 
-  def _VerifyMock(self, binary, *args):
+  def _VerifyMock(self, binary, *args, **kwargs):
     arg = [path.join(path.dirname(self.base), binary)]
     arg += args
-    commands.Execute.assert_called_with(arg, timeout=60)
+    commands.Execute.assert_called_with(
+        arg, timeout=kwargs.get("timeout", 60))
 
-  def _VerifyMockMultiple(self, *args):
+  def _VerifyMockMultiple(self, *args, **kwargs):
     expected = []
     for arg in args:
       a = [path.join(path.dirname(self.base), arg[0])]
       a += arg[1:]
-      expected.append(((a,), {"timeout": 60}))
+      expected.append(((a,), {"timeout": kwargs.get("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.assertEquals(0, self._CallMain())
     self._VerifyResults("test", "score", [
       {"name": "Richards", "results": ["1.234"], "stddev": ""},
       {"name": "DeltaBlue", "results": ["10657567"], "stddev": ""},
     ])
@@ skipping 165 matching lines @@
     self._MockCommand(["."], [
       "Trace(Test1), Result(1.234), StdDev(0.23)\n"
       "Trace(Test2), Result(10657567), StdDev(106)\n"])
     self.assertEquals(0, self._CallMain())
     self._VerifyResults("test", "ms", [
       {"name": "Test1", "results": ["1.234"], "stddev": "0.23"},
       {"name": "Test2", "results": ["10657567"], "stddev": "106"},
     ])
     self._VerifyErrors([])
     self._VerifyMock(path.join("out", "x64.release", "cc"), "--flag", "")
+
+  def testOneRunTimingOut(self):
+    test_input = dict(V8_JSON)
+    test_input["timeout"] = 70
+    self._WriteTestInput(test_input)
+    self._MockCommand(["."], [""], timed_out=True)
+    self.assertEquals(1, self._CallMain())
+    self._VerifyResults("test", "score", [
+      {"name": "Richards", "results": [], "stddev": ""},
+      {"name": "DeltaBlue", "results": [], "stddev": ""},
+    ])
+    self._VerifyErrors([
+      "Regexp \"^Richards: (.+)$\" didn't match for test Richards.",
+      "Regexp \"^DeltaBlue: (.+)$\" didn't match for test DeltaBlue.",
+    ])
+    self._VerifyMock(
+        path.join("out", "x64.release", "d7"), "--flag", "run.js", timeout=70)