Add gc header size to returned sizeof information

Lib/test/test_sys.py

 # -*- coding: iso-8859-1 -*-
 import unittest, test.test_support
 import sys, cStringIO, os
 import struct
 
 class SysModuleTest(unittest.TestCase):
 
     def test_original_displayhook(self):
         import __builtin__
         savestdout = sys.stdout
@@ skipping 389 matching lines @@
         self.assertEqual(out, unichr(0xa2).encode("cp424"))
 
         env["PYTHONIOENCODING"] = "ascii:replace"
         p = subprocess.Popen([sys.executable, "-c", 'print unichr(0xa2)'],
                              stdout = subprocess.PIPE, env=env)
         out = p.stdout.read().strip()
         self.assertEqual(out, '?')
 
 
 class SizeofTest(unittest.TestCase):
+
+    TPFLAGS_HAVE_GC = 1<<14
 
     def setUp(self):
         self.c = len(struct.pack('c', ' '))
         self.H = len(struct.pack('H', 0))
         self.i = len(struct.pack('i', 0))
         self.l = len(struct.pack('l', 0))
         self.P = len(struct.pack('P', 0))
         # due to missing size_t information from struct, it is assumed that
         # sizeof(Py_ssize_t) = sizeof(void*)
         self.header = 'lP'
         if hasattr(sys, "gettotalrefcount"):
             self.header += '2P'
         self.file = open(test.test_support.TESTFN, 'wb')
 
     def tearDown(self):
         self.file.close()
         test.test_support.unlink(test.test_support.TESTFN)
 
     def check_sizeof(self, o, size, size2=None):
         """Check size of o. Possible are size and optionally size2)."""
         result = sys.getsizeof(o)
+        # add GC header size
+        if type(o).__flags__ & SizeofTest.TPFLAGS_HAVE_GC:
+            size += 32
+            if size2 != None:
+                size2 += 32
         msg = 'wrong size for %s: got %d, expected ' % (type(o), result)
         if (size2 != None) and (result != size):
             self.assertEqual(result, size2, msg + str(size2))
         else:
             self.assertEqual(result, size, msg + str(size))
 
     def calcsize(self, fmt):
         """Wrapper around struct.calcsize which enforces the alignment of the
         end of a structure to the alignment requirement of pointer.
 
         Note: This wrapper should only be used if a pointer member is included
         and no member with a size larger than a pointer exists.
         """
         return struct.calcsize(fmt + '0P')
+
+    def test_gc_head_size(self):
+        # Check that the gc header size is added to objects tracked by the gc.
+        h = self.header
+        size = self.calcsize
+        gc_header_size = 32#struct.calcsize('PPP' + '0P0P')
+        # bool objects are not gc tracked
+        self.assertEqual(sys.getsizeof(True), size(h + 'l'))
+        # but lists are
+        self.assertEqual(sys.getsizeof([]), size(h + 'lPP') + gc_header_size)
 
     def test_standardtypes(self):
         h = self.header
         size = self.calcsize
         # bool
         self.check_sizeof(True, size(h + 'l'))
         # buffer
         self.check_sizeof(buffer(''), size(h + '2P2Pil'))
         # cell
         def get_cell():
@@ skipping 105 matching lines @@
         self.check_sizeof((1,2,3), size(h) + 3*self.P)
 
 
 def test_main():
     test_classes = (SysModuleTest, SizeofTest)
 
     test.test_support.run_unittest(*test_classes)
 
 if __name__ == "__main__":
     test_main()