Supersize diff rewrite + tweaks

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 34 matching lines @@
   def real_decorator(func):
     basename = name
     if not basename:
       basename = func.__name__.replace('test_', '')
     golden_path = os.path.join(_TEST_DATA_DIR, basename + '.golden')
 
     def inner(self):
       actual_lines = func(self)
       actual_lines = (re.sub(r'(elf_mtime=).*', r'\1{redacted}', l)
                       for l in actual_lines)
+      actual_lines = (re.sub(r'(Loaded from ).*', r'\1{redacted}', l)
+                      for l in actual_lines)
 
       if update_goldens:
         with open(golden_path, 'w') as file_obj:
           describe.WriteLines(actual_lines, file_obj.write)
         logging.info('Wrote %s', golden_path)
       else:
         with open(golden_path) as file_obj:
           _AssertGolden(file_obj, actual_lines)
     return inner
   return real_decorator
@@ skipping 14 matching lines @@
     env = None
     if debug_measures:
       env = os.environ.copy()
       env['SUPERSIZE_DISABLE_ASYNC'] = '1'
       env['SUPERSIZE_MEASURE_GZIP'] = '1'
 
     return subprocess.check_output(argv, env=env).splitlines()
 
 
 def _DiffCounts(sym):
-  return (sym.changed_count, sym.added_count, sym.removed_count)
+  counts = sym.CountsByDiffStatus()
+  return (counts[models.DIFF_STATUS_CHANGED],
+          counts[models.DIFF_STATUS_ADDED],
+          counts[models.DIFF_STATUS_REMOVED])
 
 
 class IntegrationTest(unittest.TestCase):
   maxDiff = None  # Don't trucate diffs in errors.
   cached_size_info = [None, None, None]
 
   def _CloneSizeInfo(self, use_output_directory=True, use_elf=True):
     assert not use_elf or use_output_directory
     i = int(use_output_directory) + int(use_elf)
     if not IntegrationTest.cached_size_info[i]:
@@ skipping 97 matching lines @@
   def test_Diff_Aliases1(self):
     size_info1 = self._CloneSizeInfo()
     size_info2 = self._CloneSizeInfo()
 
     # Removing 1 alias should not change the size.
     a1, _, _ = (
         size_info2.raw_symbols.Filter(lambda s: s.num_aliases == 3)[0].aliases)
     size_info2.raw_symbols -= [a1]
     a1.aliases.remove(a1)
     d = diff.Diff(size_info1, size_info2)
-    self.assertEquals(d.raw_symbols.size, 0)
+    self.assertEquals(d.raw_symbols.pss, 0)
     self.assertEquals((0, 0, 1), _DiffCounts(d.raw_symbols))
     # shrinkToFit is in a cluster, so removed turns to a changed when clustered.
     self.assertEquals((1, 0, 0), _DiffCounts(d.symbols.GroupedByFullName()))
 
     # Adding one alias should not change size.
     d = diff.Diff(size_info2, size_info1)
-    self.assertEquals(d.raw_symbols.size, 0)
+    self.assertEquals(d.raw_symbols.pss, 0)
     self.assertEquals((0, 1, 0), _DiffCounts(d.raw_symbols))
     self.assertEquals((1, 0, 0), _DiffCounts(d.symbols.GroupedByFullName()))
 
   def test_Diff_Aliases2(self):
     size_info1 = self._CloneSizeInfo()
     size_info2 = self._CloneSizeInfo()
 
     # Removing 2 aliases should not change the size.
     a1, a2, _ = (
         size_info2.raw_symbols.Filter(lambda s: s.num_aliases == 3)[0].aliases)
     size_info2.raw_symbols -= [a1, a2]
     a1.aliases.remove(a1)
     a1.aliases.remove(a2)
     d = diff.Diff(size_info1, size_info2)
-    self.assertEquals(d.raw_symbols.size, 0)
+    self.assertEquals(d.raw_symbols.pss, 0)
     self.assertEquals((0, 0, 2), _DiffCounts(d.raw_symbols))
     self.assertEquals((1, 0, 1), _DiffCounts(d.symbols.GroupedByFullName()))
 
     # Adding 2 aliases should not change size.
     d = diff.Diff(size_info2, size_info1)
-    self.assertEquals(d.raw_symbols.size, 0)
+    self.assertEquals(d.raw_symbols.pss, 0)
     self.assertEquals((0, 2, 0), _DiffCounts(d.raw_symbols))
     self.assertEquals((1, 1, 0), _DiffCounts(d.symbols.GroupedByFullName()))
 
   def test_Diff_Aliases3(self):
     size_info1 = self._CloneSizeInfo()
     size_info2 = self._CloneSizeInfo()
 
     # Removing all 3 aliases should change the size.
     a1, a2, a3 = (
         size_info2.raw_symbols.Filter(lambda s: s.num_aliases == 3)[0].aliases)
     size_info2.raw_symbols -= [a1, a2, a3]
     d = diff.Diff(size_info1, size_info2)
     self.assertEquals((0, 0, 3), _DiffCounts(d.raw_symbols))
     self.assertEquals((1, 0, 2), _DiffCounts(d.symbols.GroupedByFullName()))
 
     # Adding all 3 aliases should change size.
     d = diff.Diff(size_info2, size_info1)
-    self.assertEquals(d.raw_symbols.size, a1.size)
+    self.assertEquals(d.raw_symbols.pss, a1.size)
     self.assertEquals((0, 3, 0), _DiffCounts(d.raw_symbols))
     self.assertEquals((1, 2, 0), _DiffCounts(d.symbols.GroupedByFullName()))
 
   def test_Diff_Clustering(self):
     size_info1 = self._CloneSizeInfo()
     size_info2 = self._CloneSizeInfo()
     S = '.text'
     size_info1.symbols += [
         models.Symbol(S, 11, name='.L__unnamed_1193', object_path='a'), # 1
         models.Symbol(S, 22, name='.L__unnamed_1194', object_path='a'), # 2
         models.Symbol(S, 33, name='.L__unnamed_1195', object_path='b'), # 3
         models.Symbol(S, 44, name='.L__bar_195', object_path='b'), # 4
         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.Sorted()
-    self.assertEquals(d.symbols.added_count, 0)
+    self.assertEquals(d.symbols.CountsByDiffStatus()[models.DIFF_STATUS_ADDED],
+                      0)
     self.assertEquals(d.symbols.size, 0)
 
   @_CompareWithGolden()
   def test_FullDescription(self):
     size_info = self._CloneSizeInfo()
     # Show both clustered and non-clustered so that they can be compared.
     size_info.symbols = size_info.raw_symbols
     return itertools.chain(
         describe.GenerateLines(size_info, verbose=True),
         describe.GenerateLines(size_info.symbols._Clustered(), recursive=True,
@@ skipping 30 matching lines @@
     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()