Fix base_nocompile_tests dependency

tools/nocompile_driver.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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.
 
 """Implements a simple "negative compile" test for C++ on linux.
 
 Sometimes a C++ API needs to ensure that various usages cannot compile. To
 enable unittesting of these assertions, we use this python script to
 invoke gcc on a source file and assert that compilation fails.
 
 For more info, see:
   http://dev.chromium.org/developers/testing/no-compile-tests
 """
 
+import StringIO
 import ast
 import locale
 import os
 import re
 import select
 import shlex
 import subprocess
 import sys
 import time
 
@@ skipping 86 matching lines @@
   raw_expectation = ast.literal_eval(match.group(1))
   assert type(raw_expectation) is list
 
   expectation = []
   for regex_str in raw_expectation:
     assert type(regex_str) is str
     expectation.append(re.compile(regex_str))
   return expectation
 
 
-def ExtractTestConfigs(sourcefile_path):
+def ExtractTestConfigs(sourcefile_path, suite_name):
   """Parses the soruce file for test configurations.
 
   Each no-compile test in the file is separated by an ifdef macro.  We scan
   the source file with the NCTEST_CONFIG_RE to find all ifdefs that look like
   they demark one no-compile test and try to extract the test configuration
   from that.
 
   Args:
     sourcefile_path: The path to the source file.
+    suite_name: The name of the test suite.
 
   Returns:
     A list of test configurations. Each test configuration is a dictionary of
     the form:
 
       { name: 'NCTEST_NAME'
         suite_name: 'SOURCE_FILE_NAME'
         expectations: [re.Pattern, re.Pattern] }
 
     The |suite_name| is used to generate a pretty gtest output on successful
     completion of the no compile test.
 
     The compiled regexps in |expectations| define the valid outputs of the
     compiler.  If any one of the listed patterns matches either the stderr or
     stdout from the compilation, and the compilation failed, then the test is
     considered to have succeeded.  If the list is empty, than we ignore the
     compiler output and just check for failed compilation. If |expectations|
     is actually None, then this specifies a compiler sanity check test, which
     should expect a SUCCESSFUL compilation.
   """
   sourcefile = open(sourcefile_path, 'r')
 
-  # Convert filename from underscores to CamelCase.
-  words = os.path.splitext(os.path.basename(sourcefile_path))[0].split('_')
-  words = [w.capitalize() for w in words]
-  suite_name = 'NoCompile' + ''.join(words)
-
   # Start with at least the compiler sanity test.  You need to always have one
   # sanity test to show that compiler flags and configuration are not just
   # wrong.  Otherwise, having a misconfigured compiler, or an error in the
   # shared portions of the .nc file would cause all tests to erroneously pass.
-  test_configs = [{'name': 'NCTEST_SANITY',
-                   'suite_name': suite_name,
-                   'expectations': None}]
+  test_configs = []
 
   for line in sourcefile:
     match_result = NCTEST_CONFIG_RE.match(line)
     if not match_result:
       continue
 
     groups = match_result.groups()
 
     # Grab the name and remove the defined() predicate if there is one.
     name = groups[0]
@@ skipping 16 matching lines @@
     sourcefile_path: The path to the source file.
     cflags: A string with all the CFLAGS to give to gcc. This string will be
             split by shelex so be careful with escaping.
     config: A dictionary describing the test.  See ExtractTestConfigs
       for a description of the config format.
 
   Returns:
     A dictionary containing all the information about the started test. The
     fields in the dictionary are as follows:
       { 'proc': A subprocess object representing the compiler run.
-        'cmdline': The exectued command line.
+        'cmdline': The executed command line.
         'name': The name of the test.
         'suite_name': The suite name to use when generating the gunit test
                       result.
         'terminate_timeout': The timestamp in seconds since the epoch after
                              which the test should be terminated.
         'kill_timeout': The timestamp in seconds since the epoch after which
                         the test should be given a hard kill signal.
         'started_at': A timestamp in seconds since the epoch for when this test
                       was started.
         'aborted_at': A timestamp in seconds since the epoch for when this test
@@ skipping 108 matching lines @@
   # cause we can only call this once on the Popen object, and lots of stuff
   # below will want access to it.
   proc = test['proc']
   (stdout, stderr) = proc.communicate()
 
   if test['aborted_at'] != 0:
     FailTest(resultfile, test, "Compile timed out. Started %f ended %f." %
              (test['started_at'], test['aborted_at']))
     return
 
-  if test['expectations'] is None:
-    # This signals a compiler sanity check test. Fail iff compilation failed.
-    if proc.poll() == 0:
-      PassTest(resultfile, test)
-      return
-    else:
-      FailTest(resultfile, test, 'Sanity compile failed. Is compiler borked?',
-               stdout, stderr)
-      return
-  elif proc.poll() == 0:
+  if proc.poll() == 0:
     # Handle failure due to successful compile.
     FailTest(resultfile, test,
              'Unexpected successful compilation.',
              stdout, stderr)
     return
   else:
     # Check the output has the right expectations.  If there are no
     # expectations, then we just consider the output "matched" by default.
     if len(test['expectations']) == 0:
       PassTest(resultfile, test)
@@ skipping 72 matching lines @@
 
   parallelism = int(sys.argv[1])
   sourcefile_path = sys.argv[2]
   cflags = sys.argv[3]
   resultfile_path = sys.argv[4]
 
   timings = {'started': time.time()}
 
   ValidateInput(parallelism, sourcefile_path, cflags, resultfile_path)
 
-  test_configs = ExtractTestConfigs(sourcefile_path)
+  # Convert filename from underscores to CamelCase.
+  words = os.path.splitext(os.path.basename(sourcefile_path))[0].split('_')
+  words = [w.capitalize() for w in words]
+  suite_name = 'NoCompile' + ''.join(words)
+
+  test_configs = ExtractTestConfigs(sourcefile_path, suite_name)
   timings['extract_done'] = time.time()
 
-  resultfile = open(resultfile_path, 'w')
+  resultfile = StringIO.StringIO()
   resultfile.write(RESULT_FILE_HEADER % sourcefile_path)
 
   # Run the no-compile tests, but ensure we do not run more than |parallelism|
   # tests at once.
   timings['header_written'] = time.time()
   executing_tests = {}
   finished_tests = []
+
+  test = StartTest(
+      sourcefile_path,
+      cflags + ' -MMD -MF %s.d -MT %s' % (resultfile_path, resultfile_path),
+      { 'name': 'NCTEST_SANITY',
+        'suite_name': suite_name,
+        'expectations': None,
+      })
+  executing_tests[test['name']] = test
+
   for config in test_configs:
     # CompleteAtLeastOneTest blocks until at least one test finishes. Thus, this
     # acts as a semaphore.  We cannot use threads + a real semaphore because
     # subprocess forks, which can cause all sorts of hilarity with threads.
     if len(executing_tests) >= parallelism:
       finished_tests.extend(CompleteAtLeastOneTest(resultfile, executing_tests))
 
     if config['name'].startswith('DISABLED_'):
       PassTest(resultfile, config)
     else:
       test = StartTest(sourcefile_path, cflags, config)
       assert test['name'] not in executing_tests
       executing_tests[test['name']] = test
 
   # If there are no more test to start, we still need to drain the running
   # ones.
   while len(executing_tests) > 0:
     finished_tests.extend(CompleteAtLeastOneTest(resultfile, executing_tests))
   timings['compile_done'] = time.time()
 
   for test in finished_tests:
+    if test['name'] == 'NCTEST_SANITY':
+      _, stderr = test['proc'].communicate()
+      return_code = test['proc'].poll()
+      if return_code != 0:
+        sys.stderr.write(stderr)
+      continue
     ProcessTestResult(resultfile, test)
   timings['results_processed'] = time.time()
 
-  # We always know at least a sanity test was run.
-  WriteStats(resultfile, finished_tests[0]['suite_name'], timings)
+  WriteStats(resultfile, suite_name, timings)
+
+  if return_code == 0:
+    with open(resultfile_path, 'w') as fd:
+      fd.write(resultfile.getvalue())
 
   resultfile.close()
+  sys.exit(return_code)
 
 
 if __name__ == '__main__':
   main()