Sometimes unittest's assertRaises increases reference counter of callable. This can break tests in tricky cases. Not seen in 2.X version. Demo file attached.

This is presumably a result of the exception object being saved on the context manager object and there being a circular reference chain that doesn't immediately get GCed.  This is just how python works.I don't know if it would be sensible/useful to use the new lightweight traceback stuff in assertRaises.  If so it would probably have to be optional for backward compatibility reasons.

It seems, as a minimum it must be noticed in docs.

I don't think we make any guarantees for or against references, but - we attempt to free references already (see how we call clear_frames), so this is a bug, pure and simple.

As Robert noted, this is a straight up error, where the clear_frames() call and deleting the exception traceback from the saved object aren't enough to drop all references to `callable_obj`.The trick is that the cleanup code isn't accounting for __cause__ and __context__: it's only clearing and dropping the traceback for the topmost exception in the chain.In Vjacheslav's example, there are *two* tracebacks to worry about: both the top level one (which is getting cleaned up) and the inner one from exc.__context__ which isn't being touched.We could likely use a "traceback.clear_all_frames()" helper that walks an exception tree clearing *all* the traceback frames, both on the original exception, and on all the __cause__ and __context__ attributes.(We can't just clear __cause__ and __context__, since those can be accessed and tested when using the context manager form and the `exception` attribute)

I've been looking into this further, and a reproducer that's independent of assertRaises() is to just bind the function to a local variable name in an outer function:    def outer():        callable_obj = f        try:            callable_obj()        except Exception as exc:            return excThat should make it easier to test a basic recursive "clear_all_frames" operation like:    def clear_all_frames(exc):        cause = exc.__cause__        if cause is not None:            clear_all_frames(cause)        context = exc.__context__        if context is not None:            clear_all_frames(context)        traceback.clear_frames(exc.__traceback__)

Victor's PR takes a more pragmatic approach to address this problem: rather than adding the ability to clear the frames for an arbitrary exception tree, it just uses a try/finally in a couple of key unittest function definitions to clear the offending circular references by setting them to None.

New changesetbbd3cf8f1ef1e91a8d6dac6411e18b4b9084abf5 by Victor Stinner in branch 'master':Fix ref cycles in TestCase.assertRaises() (#193)https://github.com/python/cpython/commit/bbd3cf8f1ef1e91a8d6dac6411e18b4b9084abf5

It seems like Python 2.7 is not affected.

New changeset50dbf577e10f806056d60ac956db0748d2cc8257 by Victor Stinner in branch '3.6':bpo-23890: Fix ref cycle in TestCase.assertRaises (#858)https://github.com/python/cpython/commit/50dbf577e10f806056d60ac956db0748d2cc8257

New changeset3dc573c8d19dc42ed786ca3237afdad183c41ca0 by Victor Stinner in branch '3.5':Fix ref cycles in TestCase.assertRaises() (#193) (#2228)https://github.com/python/cpython/commit/3dc573c8d19dc42ed786ca3237afdad183c41ca0

Thank you Vjacheslav Fyodorov for your bug report! The bug should now be fixed in 3.5, 3.6 and master (future 3.7) branches.Python 2.7 is not affected by the bug.