python
diff --git a/‎Lib/multiprocessing/process.py‎
Lines changed: 5 additions & 0 deletions b/‎Lib/multiprocessing/process.py‎
Lines changed: 5 additions & 0 deletions
diff --git a/‎Lib/test/regrtest.py‎
Lines changed: 36 additions & 1 deletion b/‎Lib/test/regrtest.py‎
Lines changed: 36 additions & 1 deletion
diff --git a/‎Lib/test/test_descr.py‎
Lines changed: 8 additions & 0 deletions b/‎Lib/test/test_descr.py‎
Lines changed: 8 additions & 0 deletions
diff --git a/‎Lib/threading.py‎
Lines changed: 4 additions & 0 deletions b/‎Lib/threading.py‎
Lines changed: 4 additions & 0 deletions
diff --git a/‎Misc/NEWS‎
Lines changed: 5 additions & 0 deletions b/‎Misc/NEWS‎
Lines changed: 5 additions & 0 deletions
diff --git a/‎Objects/typeobject.c‎
Lines changed: 1 addition & 1 deletion b/‎Objects/typeobject.c‎
Lines changed: 1 addition & 1 deletion
@@ -42,6 +42,7 @@
 import sys
 import signal
 import itertools
+from _weakrefset import WeakSet
 
 #
 #
@@ -109,6 +110,7 @@ def __init__(self, group=None, target=None, name=None, args=(), kwargs={},
         self._kwargs = dict(kwargs)
         self._name = name or type(self).__name__ + '-' + \
                      ':'.join(str(i) for i in self._identity)
+        _dangling.add(self)
 
     def run(self):
         '''
@@ -344,3 +346,6 @@ def __init__(self):
 for name, signum in list(signal.__dict__.items()):
     if name[:3]=='SIG' and '_' not in name:
         _exitcode_to_name[-signum] = name
+
+# For debug and leak testing
+_dangling = WeakSet()
@@ -182,6 +182,15 @@
 import warnings
 from inspect import isabstract
 
+try:
+    import threading
+except ImportError:
+    threading = None
+try:
+    import multiprocessing.process
+except ImportError:
+    multiprocessing = None
+
 
 # Some times __path__ and __file__ are not absolute (e.g. while running from
 # Lib/) and, if we change the CWD to run the tests in a temporary dir, some
@@ -930,7 +939,8 @@ def __init__(self, testname, verbose=0, quiet=False):
                  'os.environ', 'sys.path', 'sys.path_hooks', '__import__',
                  'warnings.filters', 'asyncore.socket_map',
                  'logging._handlers', 'logging._handlerList', 'sys.gettrace',
-                 'sys.warnoptions')
+                 'sys.warnoptions', 'threading._dangling',
+                 'multiprocessing.process._dangling')
 
     def get_sys_argv(self):
         return id(sys.argv), sys.argv, sys.argv[:]
@@ -1023,6 +1033,31 @@ def restore_sys_warnoptions(self, saved_options):
         sys.warnoptions = saved_options[1]
         sys.warnoptions[:] = saved_options[2]
 
+    # Controlling dangling references to Thread objects can make it easier
+    # to track reference leaks.
+    def get_threading__dangling(self):
+        if not threading:
+            return None
+        # This copies the weakrefs without making any strong reference
+        return threading._dangling.copy()
+    def restore_threading__dangling(self, saved):
+        if not threading:
+            return
+        threading._dangling.clear()
+        threading._dangling.update(saved)
+
+    # Same for Process objects
+    def get_multiprocessing_process__dangling(self):
+        if not multiprocessing:
+            return None
+        # This copies the weakrefs without making any strong reference
+        return multiprocessing.process._dangling.copy()
+    def restore_multiprocessing_process__dangling(self, saved):
+        if not multiprocessing:
+            return
+        multiprocessing.process._dangling.clear()
+        multiprocessing.process._dangling.update(saved)
+
     def resource_info(self):
         for name in self.resources:
             method_suffix = name.replace('.', '_')
 
@@ -4247,6 +4247,14 @@ class FakeStr:
         with self.assertRaises(TypeError):
             str.__add__(fake_str, "abc")
 
+    def test_repr_as_str(self):
+        # Issue #11603: crash or infinite loop when rebinding __str__ as
+        # __repr__.
+        class Foo:
+            pass
+        Foo.__repr__ = Foo.__str__
+        foo = Foo()
+        str(foo)
 
 class DictProxyTests(unittest.TestCase):
     def setUp(self):
 
@@ -6,6 +6,7 @@
 from time import time as _time, sleep as _sleep
 from traceback import format_exc as _format_exc
 from collections import deque
+from _weakrefset import WeakSet
 
 # Note regarding PEP 8 compliant names
 #  This threading model was originally inspired by Java, and inherited
@@ -608,6 +609,8 @@ def _newname(template="Thread-%d"):
 _active = {}    # maps thread id to Thread object
 _limbo = {}
 
+# For debug and leak testing
+_dangling = WeakSet()
 
 # Main class for threads
 
@@ -645,6 +648,7 @@ def __init__(self, group=None, target=None, name=None,
         # sys.stderr is not stored in the class like
         # sys.exc_info since it can be changed between instances
         self._stderr = _sys.stderr
+        _dangling.add(self)
 
     def _reset_internal_locks(self):
         # private!  Called by _after_fork() to reset our internal locks as
 
@@ -228,6 +228,9 @@ Core and Builtins
 Library
 -------
 
+- Issue #11603: Fix a crash when __str__ is rebound as __repr__.  Patch by
+  Andreas Stührk.
+
 - Issue #11321: Fix a crash with multiple imports of the _pickle module when
   embedding Python.  Patch by Andreas Stührk.
 
@@ -1033,6 +1036,8 @@ Extension Modules
 Tests
 -----
 
+- Issue #12573: Add resource checks for dangling Thread and Process objects.
+
 - Issue #12549: Correct test_platform to not fail when OS X returns 'x86_64'
   as the processor type on some Mac systems.
 
 
@@ -2968,7 +2968,7 @@ object_str(PyObject *self)
     unaryfunc f;
 
     f = Py_TYPE(self)->tp_repr;
-    if (f == NULL)
+    if (f == NULL || f == object_str)
         f = object_repr;
     return f(self);
 }
Original file line number	Diff line number	Diff line change
`@@ -2968,7 +2968,7 @@ object_str(PyObject *self)`
`2968`	`2968`	`unaryfunc f;`
`2969`	`2969`
`2970`	`2970`	`f = Py_TYPE(self)->tp_repr;`
`2971`		`- if (f == NULL)`
	`2971`	`+ if (f == NULL \|\| f == object_str)`
`2972`	`2972`	`f = object_repr;`
`2973`	`2973`	`return f(self);`
`2974`	`2974`	`}`