1# Protocol Buffers - Google's data interchange format 2# Copyright 2008 Google Inc. All rights reserved. 3# https://developers.google.com/protocol-buffers/ 4# 5# Redistribution and use in source and binary forms, with or without 6# modification, are permitted provided that the following conditions are 7# met: 8# 9# * Redistributions of source code must retain the above copyright 10# notice, this list of conditions and the following disclaimer. 11# * Redistributions in binary form must reproduce the above 12# copyright notice, this list of conditions and the following disclaimer 13# in the documentation and/or other materials provided with the 14# distribution. 15# * Neither the name of Google Inc. nor the names of its 16# contributors may be used to endorse or promote products derived from 17# this software without specific prior written permission. 18# 19# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31"""A subclass of unittest.TestCase which checks for reference leaks. 32 33To use: 34- Use testing_refleak.BaseTestCase instead of unittest.TestCase 35- Configure and compile Python with --with-pydebug 36 37If sys.gettotalrefcount() is not available (because Python was built without 38the Py_DEBUG option), then this module is a no-op and tests will run normally. 39""" 40 41import copyreg 42import gc 43import sys 44import unittest 45 46 47class LocalTestResult(unittest.TestResult): 48 """A TestResult which forwards events to a parent object, except for Skips.""" 49 50 def __init__(self, parent_result): 51 unittest.TestResult.__init__(self) 52 self.parent_result = parent_result 53 54 def addError(self, test, error): 55 self.parent_result.addError(test, error) 56 57 def addFailure(self, test, error): 58 self.parent_result.addFailure(test, error) 59 60 def addSkip(self, test, reason): 61 pass 62 63 64class ReferenceLeakCheckerMixin(object): 65 """A mixin class for TestCase, which checks reference counts.""" 66 67 NB_RUNS = 3 68 69 def run(self, result=None): 70 testMethod = getattr(self, self._testMethodName) 71 expecting_failure_method = getattr(testMethod, "__unittest_expecting_failure__", False) 72 expecting_failure_class = getattr(self, "__unittest_expecting_failure__", False) 73 if expecting_failure_class or expecting_failure_method: 74 return 75 76 # python_message.py registers all Message classes to some pickle global 77 # registry, which makes the classes immortal. 78 # We save a copy of this registry, and reset it before we could references. 79 self._saved_pickle_registry = copyreg.dispatch_table.copy() 80 81 # Run the test twice, to warm up the instance attributes. 82 super(ReferenceLeakCheckerMixin, self).run(result=result) 83 super(ReferenceLeakCheckerMixin, self).run(result=result) 84 85 oldrefcount = 0 86 local_result = LocalTestResult(result) 87 num_flakes = 0 88 89 refcount_deltas = [] 90 while len(refcount_deltas) < self.NB_RUNS: 91 oldrefcount = self._getRefcounts() 92 super(ReferenceLeakCheckerMixin, self).run(result=local_result) 93 newrefcount = self._getRefcounts() 94 # If the GC was able to collect some objects after the call to run() that 95 # it could not collect before the call, then the counts won't match. 96 if newrefcount < oldrefcount and num_flakes < 2: 97 # This result is (probably) a flake -- garbage collectors aren't very 98 # predictable, but a lower ending refcount is the opposite of the 99 # failure we are testing for. If the result is repeatable, then we will 100 # eventually report it, but not after trying to eliminate it. 101 num_flakes += 1 102 continue 103 num_flakes = 0 104 refcount_deltas.append(newrefcount - oldrefcount) 105 print(refcount_deltas, self) 106 107 try: 108 self.assertEqual(refcount_deltas, [0] * self.NB_RUNS) 109 except Exception: # pylint: disable=broad-except 110 result.addError(self, sys.exc_info()) 111 112 def _getRefcounts(self): 113 copyreg.dispatch_table.clear() 114 copyreg.dispatch_table.update(self._saved_pickle_registry) 115 # It is sometimes necessary to gc.collect() multiple times, to ensure 116 # that all objects can be collected. 117 gc.collect() 118 gc.collect() 119 gc.collect() 120 return sys.gettotalrefcount() 121 122 123if hasattr(sys, 'gettotalrefcount'): 124 125 def TestCase(test_class): 126 new_bases = (ReferenceLeakCheckerMixin,) + test_class.__bases__ 127 new_class = type(test_class)( 128 test_class.__name__, new_bases, dict(test_class.__dict__)) 129 return new_class 130 SkipReferenceLeakChecker = unittest.skip 131 132else: 133 # When PyDEBUG is not enabled, run the tests normally. 134 135 def TestCase(test_class): 136 return test_class 137 138 def SkipReferenceLeakChecker(reason): 139 del reason # Don't skip, so don't need a reason. 140 def Same(func): 141 return func 142 return Same 143