Add a first test for tools/find_runtime_symbols.

tools/find_runtime_symbols/find_runtime_symbols.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 import json
 import logging
 import os
-import re
 import sys
 
 from static_symbols import StaticSymbolsInFile
 from proc_maps import ProcMaps
 
 
 _MAPS_FILENAME = 'maps'
 _FILES_FILENAME = 'files.json'
 
 
 class _ListOutput(object):
   def __init__(self, result):
     self.result = result
 
-  def output(self, address, symbol):
+  def output(self, address, symbol):  # pylint: disable=W0613
     self.result.append(symbol)
 
 
 class _DictOutput(object):
   def __init__(self, result):
     self.result = result
 
   def output(self, address, symbol):
     self.result[address] = symbol
 
@@ skipping 39 matching lines @@
 
   @staticmethod
   def load(prepared_data_dir):
     symbols_in_process = RuntimeSymbolsInProcess()
 
     with open(os.path.join(prepared_data_dir, _MAPS_FILENAME), mode='r') as f:
       symbols_in_process._maps = ProcMaps.load(f)
     with open(os.path.join(prepared_data_dir, _FILES_FILENAME), mode='r') as f:
       files = json.load(f)
 
+    # pylint: disable=W0212
     for vma in symbols_in_process._maps.iter(ProcMaps.executable_and_constants):
       file_entry = files.get(vma.name)
       if not file_entry:
         continue
 
       static_symbols = StaticSymbolsInFile(vma.name)
 
       nm_entry = file_entry.get('nm')
       if nm_entry and nm_entry['format'] == 'bsd':
         with open(os.path.join(prepared_data_dir, nm_entry['file']), 'r') as f:
@@ skipping 31 matching lines @@
       found = symbols_in_process.find_typeinfo(address)
       if found:
         if found.startswith('typeinfo for '):
           outputter.output(address, found[13:])
         else:
           outputter.output(address, found)
       else:
         outputter.output(address, '0x%016x' % address)
 
 
-def find_runtime_typeinfo_symbols_list(static_symbols, addresses):
+def find_runtime_typeinfo_symbols_list(symbols_in_process, addresses):
   result = []
-  _find_runtime_typeinfo_symbols(static_symbols, addresses, _ListOutput(result))
+  _find_runtime_typeinfo_symbols(
+      symbols_in_process, addresses, _ListOutput(result))
   return result
 
 
-def find_runtime_typeinfo_symbols_dict(static_symbols, addresses):
+def find_runtime_typeinfo_symbols_dict(symbols_in_process, addresses):
   result = {}
-  _find_runtime_typeinfo_symbols(static_symbols, addresses, _DictOutput(result))
+  _find_runtime_typeinfo_symbols(
+      symbols_in_process, addresses, _DictOutput(result))
   return result
 
 
-def find_runtime_typeinfo_symbols_file(static_symbols, addresses, f):
+def find_runtime_typeinfo_symbols_file(symbols_in_process, addresses, f):
   _find_runtime_typeinfo_symbols(
-      static_symbols, addresses, _FileOutput(f, False))
+      symbols_in_process, addresses, _FileOutput(f, False))
 
 
-def find_runtime_symbols_list(static_symbols, addresses):
+def find_runtime_symbols_list(symbols_in_process, addresses):
   result = []
-  _find_runtime_symbols(static_symbols, addresses, _ListOutput(result))
+  _find_runtime_symbols(symbols_in_process, addresses, _ListOutput(result))
   return result
 
 
-def find_runtime_symbols_dict(static_symbols, addresses):
+def find_runtime_symbols_dict(symbols_in_process, addresses):
   result = {}
-  _find_runtime_symbols(static_symbols, addresses, _DictOutput(result))
+  _find_runtime_symbols(symbols_in_process, addresses, _DictOutput(result))
   return result
 
 
-def find_runtime_symbols_file(static_symbols, addresses, f):
+def find_runtime_symbols_file(symbols_in_process, addresses, f):
   _find_runtime_symbols(
-      static_symbols, addresses, _FileOutput(f, False))
+      symbols_in_process, addresses, _FileOutput(f, False))
 
 
 def main():
   # FIX: Accept only .pre data
   if len(sys.argv) < 2:
     sys.stderr.write("""Usage:
 %s /path/to/prepared_data_dir/ < addresses.txt
 """ % sys.argv[0])
     return 1
 
   log = logging.getLogger('find_runtime_symbols')
   log.setLevel(logging.WARN)
   handler = logging.StreamHandler()
   handler.setLevel(logging.WARN)
   formatter = logging.Formatter('%(message)s')
   handler.setFormatter(formatter)
   log.addHandler(handler)
 
   prepared_data_dir = sys.argv[1]
   if not os.path.exists(prepared_data_dir):
     log.warn("Nothing found: %s" % prepared_data_dir)
     return 1
   if not os.path.isdir(prepared_data_dir):
     log.warn("Not a directory: %s" % prepared_data_dir)
     return 1
 
   symbols_in_process = RuntimeSymbolsInProcess.load(prepared_data_dir)
-  return find_runtime_symbols_file(static_symbols, sys.stdin, sys.stdout)
+  return find_runtime_symbols_file(symbols_in_process, sys.stdin, sys.stdout)
 
 
 if __name__ == '__main__':
   sys.exit(main())