Tool to fix calls to scoped_ptr<T>(NULL) to use the default ctor instead

tools/clang/scripts/test_tool.py

 #!/usr/bin/env python
 # Copyright (c) 2013 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.
 
 """Test harness for chromium clang tools."""
 
 import difflib
 import glob
 import json
 import os
 import os.path
 import subprocess
 import shutil
 import sys
 
 
-def _GenerateCompileCommands(files):
+def _GenerateCompileCommands(files, include_paths):

[Nico, 2013/06/11 19:58:13]

fyi: ninja 1.3.4 (now in depot_tools) now has a -t compdb tool for writing
compile dbs. Not sure if that could help.

[dcheng, 2013/06/11 20:07:41]

The problem is these test files don't end up in a gyp anywhere.

   """Returns a JSON string containing a compilation database for the input."""
+  include_path_flags = ''.join('-I %s' % include_path
+                               for include_path in include_paths)
   return json.dumps([{'directory': '.',
-                      'command': 'clang++ -fsyntax-only -c %s' % f,
+                      'command': 'clang++ -fsyntax-only %s -c %s' % (
+                          include_path_flags, f),
                       'file': f} for f in files], indent=2)
 
 
 def _NumberOfTestsToString(tests):
   """Returns an English describing the number of tests."""
   return "%d test%s" % (tests, 's' if tests != 1 else '')
 
 
 def main(argv):
   if len(argv) < 1:
     print 'Usage: test_tool.py <clang tool>'
     print '  <clang tool> is the clang tool to be tested.'
     sys.exit(1)
 
   tool_to_test = argv[0]
   tools_clang_scripts_directory = os.path.dirname(os.path.realpath(__file__))
   tools_clang_directory = os.path.dirname(tools_clang_scripts_directory)
   test_directory_for_tool = os.path.join(
       tools_clang_directory, tool_to_test, 'tests')
   compile_database = os.path.join(test_directory_for_tool,
                                   'compile_commands.json')
   source_files = glob.glob(os.path.join(test_directory_for_tool,
                                         '*-original.cc'))
   actual_files = ['-'.join([source_file.rsplit('-', 2)[0], 'actual.cc'])
                   for source_file in source_files]
   expected_files = ['-'.join([source_file.rsplit('-', 2)[0], 'expected.cc'])
                     for source_file in source_files]
+  include_paths = []
+  include_paths.append(
+      os.path.realpath(os.path.join(tools_clang_directory, '../..')))
 
   try:
     # Set up the test environment.
     for source, actual in zip(source_files, actual_files):
       shutil.copyfile(source, actual)
     # Stage the test files in the git index. If they aren't staged, then
     # run_tools.py will skip them when applying replacements.
     args = ['git', 'add']
     args.extend(actual_files)
     subprocess.check_call(args)
     # Generate a temporary compilation database to run the tool over.
     with open(compile_database, 'w') as f:
-      f.write(_GenerateCompileCommands(actual_files))
+      f.write(_GenerateCompileCommands(actual_files, include_paths))
 
     args = ['python',
             os.path.join(tools_clang_scripts_directory, 'run_tool.py'),
             tool_to_test,
             test_directory_for_tool]
     args.extend(actual_files)
     run_tool = subprocess.Popen(args, stdout=subprocess.PIPE)
     stdout, _ = run_tool.communicate()
     if run_tool.returncode != 0:
       print 'run_tool failed:\n%s' % stdout
@@ skipping 33 matching lines @@
   finally:
     # No matter what, unstage the git changes we made earlier to avoid polluting
     # the index.
     args = ['git', 'reset', '--quiet', 'HEAD']
     args.extend(actual_files)
     subprocess.call(args)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))