Stackless issue #147: fix deprecation warnings in Stackless tests

Don't use deprecated functions in the Stackless test suite.
(cherry picked from commit 6c49d91)

Author: Anselm Kruis

Stackless/unittests/test_defects.py

@@ -375,7 +375,7 @@ def test_tasklet_end_with_wrong_recursion_level(self):
         # test for issue #91 https://bitbucket.org/stackless-dev/stackless/issues/91/
         """A test for issue #91, wrong recursion level after tasklet re-binding
 
-        Assertion failed: ts->recursion_depth == 0 || (ts->st.main == NULL && prev == next), file ..\Stackless\module\scheduling.c, line 1291
+        Assertion failed: ts->recursion_depth == 0 || (ts->st.main == NULL && prev == next), file ../Stackless/module/scheduling.c, line 1291
         The assertion fails with ts->recursion_depth > 0
 
         It is in function

Stackless/unittests/test_miscell.py

@@ -281,7 +281,7 @@ def t():
         s.throw(TaskletExit)
         # the tasklet should be dead
         stackless.run()
-        self.assertRaisesRegexp(RuntimeError, "dead", s.run)
+        self.assertRaisesRegex(RuntimeError, "dead", s.run)
 
     def test_dead(self):
         c = stackless.channel()
@@ -684,7 +684,7 @@ def test_handler(self):
     def test_borken_handler(self):
         stackless.tasklet(self.func)(self.borken_handler)
         with self.handlerctxt(self.borken_handler):
-            self.assertRaisesRegexp(IndexError, "mods", stackless.run)
+            self.assertRaisesRegex(IndexError, "mods", stackless.run)
         self.assertTrue(self.ran)
         self.assertTrue(self.handled)
 
@@ -871,13 +871,13 @@ def test_bind(self):
 
         self.assertFalse(t.alive)
         self.assertIsNone(t.frame)
-        self.assertEquals(t.nesting_level, 0)
+        self.assertEqual(t.nesting_level, 0)
 
         t.bind(None)  # must not change the tasklet
 
         self.assertFalse(t.alive)
         self.assertIsNone(t.frame)
-        self.assertEquals(t.nesting_level, 0)
+        self.assertEqual(t.nesting_level, 0)
 
         t.bind(self.task)
         t.setup(False)
@@ -900,7 +900,7 @@ def test_bind(self):
     def test_bind_fail_not_callable(self):
         class C(object):
             pass
-        self.assertRaisesRegexp(TypeError, "callable", stackless.getcurrent().bind, C())
+        self.assertRaisesRegex(TypeError, "callable", stackless.getcurrent().bind, C())
 
     def test_unbind_ok(self):
         if not stackless.enable_softswitch(None):
@@ -926,7 +926,7 @@ def test_unbind_ok(self):
         self.assertEqual(self.finally_run_count, 0)
 
     def test_unbind_fail_current(self):
-        self.assertRaisesRegexp(RuntimeError, "current tasklet", stackless.getcurrent().bind, None)
+        self.assertRaisesRegex(RuntimeError, "current tasklet", stackless.getcurrent().bind, None)
 
     def test_unbind_fail_scheduled(self):
         t = stackless.tasklet(self.task)(False)
@@ -938,7 +938,7 @@ def test_unbind_fail_scheduled(self):
         self.assertTrue(t.alive)
         self.assertIsInstance(t.frame, types.FrameType)
 
-        self.assertRaisesRegexp(RuntimeError, "scheduled", t.bind, None)
+        self.assertRaisesRegex(RuntimeError, "scheduled", t.bind, None)
 
     def test_unbind_fail_cstate(self):
         t = stackless.tasklet(self.task)(True)
@@ -951,7 +951,7 @@ def test_unbind_fail_cstate(self):
         self.assertGreaterEqual(t.nesting_level, 1)
         self.assertIsInstance(t.frame, types.FrameType)
 
-        self.assertRaisesRegexp(RuntimeError, "C state", t.bind, None)
+        self.assertRaisesRegex(RuntimeError, "C state", t.bind, None)
 
         # remove the tasklet. Must run the finally clause
         t = None
@@ -1180,7 +1180,7 @@ def test_switch_blocked(self):
         t = stackless.tasklet(self.blocked_target)()
         t.run()
         self.assertTrue(t.blocked)
-        self.assertRaisesRegexp(RuntimeError, "blocked", t.switch)
+        self.assertRaisesRegex(RuntimeError, "blocked", t.switch)
         self.c.send(None)
         self.assertTrue(self.finished)
 
@@ -1195,7 +1195,7 @@ def test_switch_trapped(self):
         t = stackless.tasklet(self.target)()
         self.assertFalse(t.paused)
         with switch_trapped():
-            self.assertRaisesRegexp(RuntimeError, "switch_trap", t.switch)
+            self.assertRaisesRegex(RuntimeError, "switch_trap", t.switch)
         self.assertFalse(t.paused)
         t.switch()
         self.assertTrue(self.finished)
@@ -1210,7 +1210,7 @@ def test_switch_blocked_trapped(self):
         t.run()
         self.assertTrue(t.blocked)
         with switch_trapped():
-            self.assertRaisesRegexp(RuntimeError, "blocked", t.switch)
+            self.assertRaisesRegex(RuntimeError, "blocked", t.switch)
         self.assertTrue(t.blocked)
         self.c.send(None)
         self.assertTrue(self.finished)
@@ -1220,7 +1220,7 @@ def test_switch_paused_trapped(self):
         t.bind(args=())
         self.assertTrue(t.paused)
         with switch_trapped():
-            self.assertRaisesRegexp(RuntimeError, "switch_trap", t.switch)
+            self.assertRaisesRegex(RuntimeError, "switch_trap", t.switch)
         self.assertTrue(t.paused)
         t.switch()
         self.assertTrue(self.finished)

Stackless/unittests/test_pickle.py

@@ -565,7 +565,7 @@ def f2():
         wrap_frame = r[0](*r[1])
         self.assertIsInstance(wrap_frame, stackless._wrap.frame)
         invalid_state = r[2][:-2] + ((("Not a", "tuple of 3", "integers"),), r[2][-1])
-        self.assertRaisesRegexp(TypeError, "an integer is required", wrap_frame.__setstate__, invalid_state)
+        self.assertRaisesRegex(TypeError, "an integer is required", wrap_frame.__setstate__, invalid_state)
         # must not raise an assertion
         wrap_frame.__setstate__(r[2])
         self.assertIs(type(wrap_frame), types.FrameType)

Stackless/unittests/test_sched_cb.py

@@ -141,9 +141,9 @@ def cb(prev, next):
         stackless.set_schedule_callback(None)
         for real_name, ex, current_name in switches:
             if real_name:
-                self.assertEquals(real_name, current_name)
+                self.assertEqual(real_name, current_name)
             if ex:
-                self.assertEquals(ex.name, current_name)
+                self.assertEqual(ex.name, current_name)
 
     def testGetCallback(self):
         mon = SchedulingMonitor()

Stackless/unittests/test_thread.py

@@ -282,7 +282,7 @@ def job():
     def test_rebind_nontrivial(self):
         end, task = self.create_remote_tasklet(nontrivial=True)
         try:
-            self.assertRaisesRegexp(RuntimeError, "C state", task.bind_thread)
+            self.assertRaisesRegex(RuntimeError, "C state", task.bind_thread)
         finally:
             end()
 
@@ -385,7 +385,7 @@ def test_rebound_tasklet_from_dead_thread(self):
 
     def test_bind_runnable(self):
         theThread, t = self.create_thread_task()
-        self.assertRaisesRegexp(RuntimeError, "runnable", t.bind_thread)
+        self.assertRaisesRegex(RuntimeError, "runnable", t.bind_thread)
         theThread.join()
 
     def test_death(self):
@@ -586,7 +586,7 @@ def tasklet_runnable_action(self):
     def test_rebind_runnable(self):
         theThread, t = self.create_thread_task(self.tasklet_runnable_action)
         with theThread:
-            self.assertRaisesRegexp(RuntimeError, 'runnable', t.bind_thread)
+            self.assertRaisesRegex(RuntimeError, 'runnable', t.bind_thread)
             self.channel.send(None)
 
 
@@ -603,7 +603,7 @@ def test_switch(self):
         with theThread:
             time.sleep(0.01)
             self.assertTrue(t.paused)
-            self.assertRaisesRegexp(RuntimeError, "different thread", t.switch)
+            self.assertRaisesRegex(RuntimeError, "different thread", t.switch)
 
 
 class SetupFromDifferentThreadTest(RemoteTaskletTests):

Stackless/unittests/test_tracing.py

@@ -128,13 +128,13 @@ def testSetTraceOnCurrent(self):
     def testSetTraceOnDeadTasklet(self):
         t = stackless.tasklet()
         self.assertIsNone(t.trace_function)
-        self.assertRaisesRegexp(RuntimeError, "tasklet is not alive",
+        self.assertRaisesRegex(RuntimeError, "tasklet is not alive",
                                 setattr, t, "trace_function", self.nullTraceFunc)
 
     def testSetProfileOnDeadTasklet(self):
         t = stackless.tasklet()
         self.assertIsNone(t.trace_function)
-        self.assertRaisesRegexp(RuntimeError, "tasklet is not alive",
+        self.assertRaisesRegex(RuntimeError, "tasklet is not alive",
                                 setattr, t, "profile_function", self.nullTraceFunc)
 
     def testSetTraceOnTasklet1(self):

Stackless/unittests/test_tstate.py

@@ -255,7 +255,7 @@ def testTracedMainNormalTasklet(self):
         self.maxDiff = None
         expected = [('mark', self.Tasklet2.__name__, i) for i in
                     ('start', 'before schedule', 'after schedule', 'end schedule')]
-        self.assertEquals(trace_in_tasklet, expected)
+        self.assertEqual(trace_in_tasklet, expected)
 
     # Test the combination of Exception and Trace State
 
@@ -334,7 +334,7 @@ def testReduceOfTracingState(self):
         # test if the tracing cframe is present / not present
         reduce_frame = get_reduce_frame()
         self.assertListEqual(reduced_tasklet1[2][3], [reduce_frame(frame)])
-        self.assertEquals(len(reduced_tasklet2[2][3]), 2)
+        self.assertEqual(len(reduced_tasklet2[2][3]), 2)
         self.assertIs(reduced_tasklet2[2][3][0], reduce_frame(frame))
         self.assertIsInstance(reduced_tasklet2[2][3][1], stackless.cframe)
 

Stackless/unittests/test_watchdog.py

@@ -188,16 +188,14 @@ def test_nested2(self):
 
     def test_tasklet_with_schedule(self):
         # make sure that we get enough tick counting
-        try:
-            hold = sys.getcheckinterval()
-        except AttributeError:
-            hold = 10  # default before 2.3
-        sys.setcheckinterval(10)
+        hold = sys.getswitchinterval()
+        self.addCleanup(sys.setswitchinterval, hold)
+        sys.setswitchinterval(0.001)
 
         n1 = self.run_tasklets(runtask)
         n2 = self.run_tasklets(runtask2)
 
-        sys.setcheckinterval(hold)
+        sys.setswitchinterval(hold)
         if self.verbose:
             print()
             print(20 * "*", "runtask:", n1, "runtask2:", n2)
@@ -333,26 +331,26 @@ class TestDeadlock(StacklessTestCase):
     def testReceiveOnMain(self):
         """Thest that we get a deadock exception if main tries to block"""
         self.c = stackless.channel()
-        self.assertRaisesRegexp(RuntimeError, "Deadlock", self.c.receive)
+        self.assertRaisesRegex(RuntimeError, "Deadlock", self.c.receive)
 
     def test_main_receiving_endttasklet(self):
         """Test that the main tasklet is interrupted when a tasklet ends"""
         c = stackless.channel()
         t = stackless.tasklet(lambda: None)()
-        self.assertRaisesRegexp(RuntimeError, "receiving", c.receive)
+        self.assertRaisesRegex(RuntimeError, "receiving", c.receive)
 
     def test_main_sending_enddtasklet(self):
         """Test that the main tasklet is interrupted when a tasklet ends"""
         c = stackless.channel()
         t = stackless.tasklet(lambda: None)()
-        self.assertRaisesRegexp(RuntimeError, "sending", c.send, None)
+        self.assertRaisesRegex(RuntimeError, "sending", c.send, None)
 
     def test_main_gets_exception(self):
         """Test that a custom exception is transfered to a blocked main"""
         def task():
             raise ZeroDivisionError("mumbai")
         stackless.tasklet(task)()
-        self.assertRaisesRegexp(ZeroDivisionError, "mumbai", stackless.channel().receive)
+        self.assertRaisesRegex(ZeroDivisionError, "mumbai", stackless.channel().receive)
 
     @require_one_thread
     def test_tasklet_deadlock(self):
@@ -361,7 +359,7 @@ def test_tasklet_deadlock(self):
 
         def task():
             c = stackless.channel()
-            self.assertRaisesRegexp(RuntimeError, "Deadlock", c.receive)
+            self.assertRaisesRegex(RuntimeError, "Deadlock", c.receive)
             mc.send(None)
         t = stackless.tasklet(task)()
         mc.receive()
@@ -375,7 +373,7 @@ def task():
             stackless.channel().receive()
         t = stackless.tasklet(task)()
         # main should get the tasklet's exception
-        self.assertRaisesRegexp(RuntimeError, "Deadlock", mc.receive)
+        self.assertRaisesRegex(RuntimeError, "Deadlock", mc.receive)
 
     def test_error_propagation_when_not_deadlock(self):
         def task1():
@@ -386,7 +384,7 @@ def task2():
 
         t1 = stackless.tasklet(task1)()
         t2 = stackless.tasklet(task2)()
-        self.assertRaisesRegexp(ZeroDivisionError, "bar", stackless.run)
+        self.assertRaisesRegex(ZeroDivisionError, "bar", stackless.run)
 
 
 class TestNewWatchdog(StacklessTestCase):
@@ -471,7 +469,7 @@ def errfunc():
 
         def runner_func():
             stackless.tasklet(errfunc)()
-            self.assertRaisesRegexp(RuntimeError, "foo", stackless.run)
+            self.assertRaisesRegex(RuntimeError, "foo", stackless.run)
             self.done += 1
         stackless.tasklet(runner_func)()
         stackless.run()