supersize: Add symbol.template_name, and strip <>s from symbol.name

tools/binary_size/libsupersize/integration_test.py

 #!/usr/bin/env python
 # Copyright 2017 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 contextlib
 import copy
 import difflib
 import glob
 import itertools
@@ skipping 103 matching lines @@
       else:
         args += ['--no-source-paths']
       if use_elf:
         args += ['--elf-file', _TEST_ELF_PATH]
       _RunApp('archive', args, debug_measures=debug_measures)
       size_info = archive.LoadAndPostProcessSizeInfo(temp_file.name)
     # Check that saving & loading is the same as directly parsing the .map.
     expected_size_info = self._CloneSizeInfo(
         use_output_directory=use_output_directory, use_elf=use_elf)
     self.assertEquals(expected_size_info.metadata, size_info.metadata)
-    expected = list(describe.GenerateLines(expected_size_info.Cluster()))
-    actual = list(describe.GenerateLines(size_info.Cluster()))
+    expected = list(describe.GenerateLines(expected_size_info.Clustered()))
+    actual = list(describe.GenerateLines(size_info.Clustered()))
     self.assertEquals(expected, actual)
 
     sym_strs = (repr(sym) for sym in size_info.symbols)
     stats = describe.DescribeSizeInfoCoverage(size_info)
     if size_info.metadata:
       metadata = describe.DescribeMetadata(size_info.metadata)
     else:
       metadata = []
     return itertools.chain(metadata, stats, sym_strs)
 
@@ skipping 16 matching lines @@
   @_CompareWithGolden()
   def test_Console(self):
     with tempfile.NamedTemporaryFile(suffix='.size') as size_file, \
          tempfile.NamedTemporaryFile(suffix='.txt') as output_file:
       file_format.SaveSizeInfo(self._CloneSizeInfo(), size_file.name)
       query = [
           'ShowExamples()',
           'ExpandRegex("_foo_")',
           'canned_queries.CategorizeGenerated()',
           'canned_queries.CategorizeByChromeComponent()',
+          'canned_queries.TemplatesByName()',
           'Print(size_info, to_file=%r)' % output_file.name,
       ]
       ret = _RunApp('console', [size_file.name, '--query', '; '.join(query)])
       with open(output_file.name) as f:
         ret.extend(l.rstrip() for l in f)
       return ret
 
   @_CompareWithGolden()
   def test_Diff_NullDiff(self):
     with tempfile.NamedTemporaryFile(suffix='.size') as temp_file:
       file_format.SaveSizeInfo(self._CloneSizeInfo(), temp_file.name)
       return _RunApp('diff', [temp_file.name, temp_file.name])
 
   @_CompareWithGolden()
   def test_Diff_Basic(self):
     size_info1 = self._CloneSizeInfo(use_elf=False)
     size_info2 = self._CloneSizeInfo(use_elf=False)
     size_info1.metadata = {"foo": 1, "bar": [1,2,3], "baz": "yes"}
     size_info2.metadata = {"foo": 1, "bar": [1,3], "baz": "yes"}
     size_info1.symbols -= size_info1.symbols[:2]
     size_info2.symbols -= size_info2.symbols[-3:]
     size_info1.symbols[1].size -= 10
     d = diff.Diff(size_info1, size_info2)
-    d.symbols = d.symbols.Cluster().Sorted()
+    d.symbols = d.symbols.Clustered().Sorted()
     return describe.GenerateLines(d, verbose=True)
 
   def test_Diff_Aliases1(self):
     size_info1 = self._CloneSizeInfo()
     size_info2 = self._CloneSizeInfo()
 
     # Removing 1 alias should not change the size.
     a1, _, _ = (
         size_info2.symbols.Filter(lambda s: s.num_aliases == 3)[0].aliases)
     size_info2.symbols -= [a1]
@@ skipping 55 matching lines @@
         models.Symbol(S, 55, name='.L__bar_1195', object_path='b'), # 5
     ]
     size_info2.symbols += [
         models.Symbol(S, 33, name='.L__unnamed_2195', object_path='b'), # 3
         models.Symbol(S, 11, name='.L__unnamed_2194', object_path='a'), # 1
         models.Symbol(S, 22, name='.L__unnamed_2193', object_path='a'), # 2
         models.Symbol(S, 44, name='.L__bar_2195', object_path='b'), # 4
         models.Symbol(S, 55, name='.L__bar_295', object_path='b'), # 5
     ]
     d = diff.Diff(size_info1, size_info2)
-    d.symbols = d.symbols.Cluster().Sorted()
+    d.symbols = d.symbols.Clustered().Sorted()
     self.assertEquals(d.symbols.added_count, 0)
     self.assertEquals(d.symbols.size, 0)
 
 
   @_CompareWithGolden()
   def test_FullDescription(self):
-    return describe.GenerateLines(self._CloneSizeInfo().Cluster(),
+    return describe.GenerateLines(self._CloneSizeInfo().Clustered(),
                                   recursive=True, verbose=True)
 
   @_CompareWithGolden()
   def test_SymbolGroupMethods(self):
     all_syms = self._CloneSizeInfo().symbols
     global_syms = all_syms.WhereNameMatches('GLOBAL')
     # Tests Filter(), Inverted(), and __sub__().
     non_global_syms = global_syms.Inverted()
     self.assertEqual(non_global_syms, (all_syms - global_syms))
     # Tests Sorted() and __add__().
     self.assertEqual(all_syms.Sorted(),
                      (global_syms + non_global_syms).Sorted())
-    # Tests GroupByNamespace() and __len__().
+    # Tests GroupedByName() and __len__().
     return itertools.chain(
-        ['GroupByNamespace()'],
-        describe.GenerateLines(all_syms.GroupByNamespace()),
-        ['GroupByNamespace(depth=1)'],
-        describe.GenerateLines(all_syms.GroupByNamespace(depth=1)),
-        ['GroupByNamespace(depth=1, fallback=None)'],
-        describe.GenerateLines(all_syms.GroupByNamespace(depth=1,
-                                                         fallback=None)),
-        ['GroupByNamespace(depth=1, min_count=2)'],
-        describe.GenerateLines(all_syms.GroupByNamespace(depth=1, min_count=2)),
+        ['GroupedByName()'],
+        describe.GenerateLines(all_syms.GroupedByName()),
+        ['GroupedByName(depth=1)'],
+        describe.GenerateLines(all_syms.GroupedByName(depth=1)),
+        ['GroupedByName(depth=-1)'],
+        describe.GenerateLines(all_syms.GroupedByName(depth=-1)),
+        ['GroupedByName(depth=1, min_count=2)'],
+        describe.GenerateLines(all_syms.GroupedByName(depth=1, min_count=2)),
     )
 
 
 def main():
   argv = sys.argv
   if len(argv) > 1 and argv[1] == '--update':
     argv.pop(0)
     global update_goldens
     update_goldens = True
     for f in glob.glob(os.path.join(_TEST_DATA_DIR, '*.golden')):
       os.unlink(f)
 
   unittest.main(argv=argv, verbosity=2)
 
 
 if __name__ == '__main__':
   main()