  class GCTogglingTests(unittest.TestCase):
      def setUp(self):
          gc.enable()
-diff -up Python-2.7.3/Modules/gcmodule.c.gc-assertions Python-2.7.3/Modules/gcmodule.c
---- Python-2.7.3/Modules/gcmodule.c.gc-assertions	2012-04-09 19:07:34.000000000 -0400
-+++ Python-2.7.3/Modules/gcmodule.c	2013-02-20 16:28:21.029536600 -0500
-@@ -21,6 +21,73 @@
- #include "Python.h"
- #include "frameobject.h"        /* for PyFrame_ClearFreeList */
- 
-+/* 
-+   Define a pair of assertion macros.
-+
-+   These work like the regular C assert(), in that they will abort the
-+   process with a message on stderr if the given condition fails to hold,
-+   but compile away to nothing if NDEBUG is defined.
-+
-+   However, before aborting, Python will also try to call _PyObject_Dump() on
-+   the given object.  This may be of use when investigating bugs in which a
-+   particular object is corrupt (e.g. buggy a tp_visit method in an extension
-+   module breaking the garbage collector), to help locate the broken objects.
-+
-+   The WITH_MSG variant allows you to supply an additional message that Python
-+   will attempt to print to stderr, after the object dump.
-+*/
-+#ifdef NDEBUG
-+/* No debugging: compile away the assertions: */
-+#define PyObject_ASSERT_WITH_MSG(obj, expr, msg) ((void)0)
-+#else
-+/* With debugging: generate checks: */
-+#define PyObject_ASSERT_WITH_MSG(obj, expr, msg) \
-+  ((expr)                                           \
-+   ? (void)(0)                                      \
-+   : _PyObject_AssertFailed((obj),                  \
-+                            (msg),                  \
-+                            (__STRING(expr)),       \
-+                            (__FILE__),             \
-+                            (__LINE__),             \
-+                            (__PRETTY_FUNCTION__)))
-+#endif
-+
-+#define PyObject_ASSERT(obj, expr) \
-+  PyObject_ASSERT_WITH_MSG(obj, expr, NULL)
-+
-+static void _PyObject_AssertFailed(PyObject *,  const char *,
-+				   const char *, const char *, int,
-+				   const char *);
-+
-+static void
-+_PyObject_AssertFailed(PyObject *obj, const char *msg, const char *expr,
-+		       const char *file, int line, const char *function)
-+{
-+    fprintf(stderr,
-+            "%s:%d: %s: Assertion \"%s\" failed.\n",
-+            file, line, function, expr);
-+    if (msg) {
-+        fprintf(stderr, "%s\n", msg);
-+    }
-+
-+    fflush(stderr);
-+
-+    if (obj) {
-+        /* This might succeed or fail, but we're about to abort, so at least
-+           try to provide any extra info we can: */
-+        _PyObject_Dump(obj);
-+    }
-+    else {
-+        fprintf(stderr, "NULL object\n");
-+    }
-+
-+    fflush(stdout);
-+    fflush(stderr);
-+
-+    /* Terminate the process: */
-+    abort();
-+}
-+
- /* Get an object's GC head */
- #define AS_GC(o) ((PyGC_Head *)(o)-1)
- 
-@@ -288,7 +355,8 @@ update_refs(PyGC_Head *containers)
- {
-     PyGC_Head *gc = containers->gc.gc_next;
-     for (; gc != containers; gc = gc->gc.gc_next) {
--        assert(gc->gc.gc_refs == GC_REACHABLE);
-+        PyObject_ASSERT(FROM_GC(gc),
-+                        gc->gc.gc_refs == GC_REACHABLE);
-         gc->gc.gc_refs = Py_REFCNT(FROM_GC(gc));
-         /* Python's cyclic gc should never see an incoming refcount
-          * of 0:  if something decref'ed to 0, it should have been
-@@ -308,7 +376,8 @@ update_refs(PyGC_Head *containers)
-          * so serious that maybe this should be a release-build
-          * check instead of an assert?
-          */
--        assert(gc->gc.gc_refs != 0);
-+        PyObject_ASSERT(FROM_GC(gc),
-+                        gc->gc.gc_refs != 0);
-     }
- }
- 
-@@ -323,7 +392,9 @@ visit_decref(PyObject *op, void *data)
-          * generation being collected, which can be recognized
-          * because only they have positive gc_refs.
-          */
--        assert(gc->gc.gc_refs != 0); /* else refcount was too small */
-+        PyObject_ASSERT_WITH_MSG(FROM_GC(gc),
-+                                 gc->gc.gc_refs != 0,
-+                                 "refcount was too small");
-         if (gc->gc.gc_refs > 0)
-             gc->gc.gc_refs--;
-     }
-@@ -383,9 +454,10 @@ visit_reachable(PyObject *op, PyGC_Head
-          * If gc_refs == GC_UNTRACKED, it must be ignored.
-          */
-          else {
--            assert(gc_refs > 0
--                   || gc_refs == GC_REACHABLE
--                   || gc_refs == GC_UNTRACKED);
-+             PyObject_ASSERT(FROM_GC(gc),
-+                             gc_refs > 0
-+                             || gc_refs == GC_REACHABLE
-+                             || gc_refs == GC_UNTRACKED);
-          }
-     }
-     return 0;
-@@ -427,7 +499,7 @@ move_unreachable(PyGC_Head *young, PyGC_
-              */
-             PyObject *op = FROM_GC(gc);
-             traverseproc traverse = Py_TYPE(op)->tp_traverse;
--            assert(gc->gc.gc_refs > 0);
-+            PyObject_ASSERT(op, gc->gc.gc_refs > 0);
-             gc->gc.gc_refs = GC_REACHABLE;
-             (void) traverse(op,
-                             (visitproc)visit_reachable,
-@@ -494,7 +566,8 @@ move_finalizers(PyGC_Head *unreachable,
-     for (gc = unreachable->gc.gc_next; gc != unreachable; gc = next) {
-         PyObject *op = FROM_GC(gc);
- 
--        assert(IS_TENTATIVELY_UNREACHABLE(op));
-+        PyObject_ASSERT(op, IS_TENTATIVELY_UNREACHABLE(op));
-+
-         next = gc->gc.gc_next;
- 
-         if (has_finalizer(op)) {
-@@ -570,7 +643,7 @@ handle_weakrefs(PyGC_Head *unreachable,
-         PyWeakReference **wrlist;
- 
-         op = FROM_GC(gc);
--        assert(IS_TENTATIVELY_UNREACHABLE(op));
-+        PyObject_ASSERT(op, IS_TENTATIVELY_UNREACHABLE(op));
-         next = gc->gc.gc_next;
- 
-         if (! PyType_SUPPORTS_WEAKREFS(Py_TYPE(op)))
-@@ -591,9 +664,9 @@ handle_weakrefs(PyGC_Head *unreachable,
-              * the callback pointer intact.  Obscure:  it also
-              * changes *wrlist.
-              */
--            assert(wr->wr_object == op);
-+            PyObject_ASSERT(wr->wr_object, wr->wr_object == op);
-             _PyWeakref_ClearRef(wr);
--            assert(wr->wr_object == Py_None);
-+            PyObject_ASSERT(wr->wr_object, wr->wr_object == Py_None);
-             if (wr->wr_callback == NULL)
-                 continue;                       /* no callback */
- 
-@@ -627,7 +700,7 @@ handle_weakrefs(PyGC_Head *unreachable,
-      */
-             if (IS_TENTATIVELY_UNREACHABLE(wr))
-                 continue;
--            assert(IS_REACHABLE(wr));
-+            PyObject_ASSERT(op, IS_REACHABLE(wr));
- 
-             /* Create a new reference so that wr can't go away
-              * before we can process it again.
-@@ -636,7 +709,8 @@ handle_weakrefs(PyGC_Head *unreachable,
- 
-             /* Move wr to wrcb_to_call, for the next pass. */
-             wrasgc = AS_GC(wr);
--            assert(wrasgc != next); /* wrasgc is reachable, but
-+            PyObject_ASSERT(op, wrasgc != next);
-+                                    /* wrasgc is reachable, but
-                                        next isn't, so they can't
-                                        be the same */
-             gc_list_move(wrasgc, &wrcb_to_call);
-@@ -652,11 +726,11 @@ handle_weakrefs(PyGC_Head *unreachable,
- 
-         gc = wrcb_to_call.gc.gc_next;
-         op = FROM_GC(gc);
--        assert(IS_REACHABLE(op));
--        assert(PyWeakref_Check(op));
-+        PyObject_ASSERT(op, IS_REACHABLE(op));
-+        PyObject_ASSERT(op, PyWeakref_Check(op));
-         wr = (PyWeakReference *)op;
-         callback = wr->wr_callback;
--        assert(callback != NULL);
-+        PyObject_ASSERT(op, callback != NULL);
- 
-         /* copy-paste of weakrefobject.c's handle_callback() */
-         temp = PyObject_CallFunctionObjArgs(callback, wr, NULL);
-@@ -759,7 +833,7 @@ delete_garbage(PyGC_Head *collectable, P
-         PyGC_Head *gc = collectable->gc.gc_next;
-         PyObject *op = FROM_GC(gc);
- 
--        assert(IS_TENTATIVELY_UNREACHABLE(op));
-+        PyObject_ASSERT(op, IS_TENTATIVELY_UNREACHABLE(op));
-         if (debug & DEBUG_SAVEALL) {
-             PyList_Append(garbage, op);
-         }

 ### Tests
 ###############################################################################
 
@@ -476,6 +479,49 @@ class GCTests(unittest.TestCase):
             # would be damaged, with an empty __dict__.
             self.assertEqual(x, None)
 

diff -up Python-2.7.11/Lib/test/test_gc.py.gc-assertions Python-2.7.11/Lib/test/test_gc.py
--- Python-2.7.11/Lib/test/test_gc.py.gc-assertions	2015-12-13 10:03:24.645178822 +0000
+++ Python-2.7.11/Lib/test/test_gc.py	2015-12-13 10:05:40.851023704 +0000
@@ -1,6 +1,7 @@
 import unittest
-from test.test_support import verbose, run_unittest, start_threads
+from test.test_support import verbose, run_unittest, start_threads, import_module
 import sys
+import sysconfig
 import time
 import gc
 import weakref
@@ -38,6 +39,8 @@ class GC_Detector(object):
         self.wr = weakref.ref(C1055820(666), it_happened)
 
 
