Stackless issue python#199: stackless call "asyncio._CTask"

Remove an unused static function, add test cases and change-log.

Author: Anselm Kruis

Modules/_asynciomodule.c

@@ -2540,23 +2540,19 @@ task_step_impl_stackless(PyObject *retval, long *step, PyObject **ob1, PyObject
 static PyStacklessFunctionDeclarationObject task_step_impl_declaration = {
         PyObject_HEAD_INIT(NULL)
         task_step_impl_stackless,
-        "task_step_impl_stackless"
+        "_task_step_impl_stackless"
 };
-#endif
 
 static PyObject *
-task_step_impl(TaskObj *task, PyObject *exc)
+task_step_impl_part1(TaskObj *task, PyObject *exc, int *failed)
 {
-#ifdef STACKLESS
-    return PyStackless_CallFunction(&task_step_impl_declaration, Py_None,
-        (PyObject *)task, exc, NULL, 0, NULL);
-}
+    STACKLESS_GETARG();
+#else  /* #ifdef STACKLESS */
 
 static PyObject *
-task_step_impl_part1(TaskObj *task, PyObject *exc, int *failed)
+task_step_impl(TaskObj *task, PyObject *exc)
 {
-#endif
-    STACKLESS_GETARG();
+#endif  /* #ifdef STACKLESS */
     int res;
     int clear_exc = 0;
     PyObject *result = NULL;

Stackless/changelog.txt

@@ -9,6 +9,13 @@ What's New in Stackless 3.X.X?
 
 *Release date: 20XX-XX-XX*
 
+- https://github.com/stackless-dev/stackless/issues/199
+  Enable stackless calls of coroutines wrapped in "asyncio._CTask", if
+  soft-switching is enabled. Now asyncio runs coroutines stackless.
+
+- https://github.com/stackless-dev/stackless/issues/196
+  Stackless can now pickle coroutine_wrapper objects.
+
 - https://github.com/stackless-dev/stackless/issues/190
   Silently ignore attempts to close a running generator, coroutine or
   asynchronous generator. This avoids spurious error messages, if such an

Stackless/unittests/test_generator.py

@@ -6,6 +6,7 @@
 import pickle
 import contextlib
 import sys
+import asyncio
 
 from support import test_main  # @UnusedImport
 from support import StacklessTestCase, captured_stderr
@@ -242,5 +243,48 @@ def test_finalizer(self):
                     self._test_finalizer(pf_dump, pf_load)
 
 
+class TestStacklessOperations(StacklessTestCase):
+    def assertLevel(self, expected=0):
+        self.assertTrue(stackless.current.alive)
+        if stackless.enable_softswitch(None):
+            self.assertEqual(stackless.current.nesting_level, expected)
+        else:
+            self.assertGreater(stackless.current.nesting_level, expected)
+
+    @types.coroutine
+    def coro1yield(self):
+        yield
+
+    async def coro(self):
+        self.assertLevel()
+        await self.coro1yield()
+        self.assertLevel()
+        await self.coro1yield()
+        self.assertLevel()
+
+    def _test_asyncio(self, task_class):
+        async def test():
+            try:
+                await self.coro()
+            finally:
+                loop.stop()
+
+        asyncio.set_event_loop(asyncio.new_event_loop())
+        self.addCleanup(asyncio.set_event_loop, None)
+        loop = asyncio.get_event_loop()
+        task = task_class(test())
+        asyncio.ensure_future(task)
+        try:
+            loop.run_forever()
+        finally:
+            loop.close()
+
+    def test_asyncio_PyTask(self):
+        self._test_asyncio(asyncio.tasks._PyTask)
+
+    def test_asyncio_CTask(self):
+        self._test_asyncio(asyncio.tasks._CTask)
+
+
 if __name__ == '__main__':
     unittest.main()