test: add tests from circuitpython proper

Author: imnotjames

tests/asyncio/asyncio_await_return.py

@@ -0,0 +1,28 @@
+# SPDX-FileCopyrightText: 2019 Damien P. George
+#
+# SPDX-License-Identifier: MIT
+#
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019 Damien P. George
+#
+# pylint: skip-file
+#
+# Test that tasks return their value correctly to the caller
+
+import asyncio
+
+
+async def example():
+    return 42
+
+
+async def main():
+    # Call function directly via an await
+    print(await example())
+
+    # Create a task and await on it
+    task = asyncio.create_task(example())
+    print(await task)
+
+
+asyncio.run(main())

tests/asyncio/asyncio_await_return.py.exp

@@ -0,0 +1,2 @@
+42
+42

tests/asyncio/asyncio_basic.py

@@ -0,0 +1,50 @@
+# SPDX-FileCopyrightText: 2019 Damien P. George
+#
+# SPDX-License-Identifier: MIT
+#
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019 Damien P. George
+#
+# pylint: skip-file
+
+import asyncio
+import time
+
+
+if hasattr(time, "ticks_ms"):
+    ticks = time.ticks_ms
+    ticks_diff = time.ticks_diff
+else:
+    ticks = lambda: int(time.time() * 1000)
+    ticks_diff = lambda t1, t0: t1 - t0
+
+
+async def delay_print(t, s):
+    await asyncio.sleep(t)
+    print(s)
+
+
+async def main():
+    print("start")
+
+    await asyncio.sleep(0.001)
+    print("after sleep")
+
+    t0 = ticks()
+    await delay_print(0.2, "short")
+    t1 = ticks()
+    await delay_print(0.4, "long")
+    t2 = ticks()
+    await delay_print(-1, "negative")
+    t3 = ticks()
+
+    print(
+        "took {} {} {}".format(
+            round(ticks_diff(t1, t0), -2),
+            round(ticks_diff(t2, t1), -2),
+            round(ticks_diff(t3, t2), -2),
+        )
+    )
+
+
+asyncio.run(main())

tests/asyncio/asyncio_basic.py.exp

@@ -0,0 +1,6 @@
+start
+after sleep
+short
+long
+negative
+took 200 400 0

tests/asyncio/asyncio_basic2.py

@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: 2019 Damien P. George
+#
+# SPDX-License-Identifier: MIT
+#
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019 Damien P. George
+#
+# pylint: skip-file
+
+import asyncio
+
+
+async def forever():
+    print("forever start")
+    await asyncio.sleep(10)
+
+
+async def main():
+    print("main start")
+    asyncio.create_task(forever())
+    await asyncio.sleep(0.001)
+    print("main done")
+    return 42
+
+
+print(asyncio.run(main()))

tests/asyncio/asyncio_basic2.py.exp

@@ -0,0 +1,4 @@
+main start
+forever start
+main done
+42

tests/asyncio/asyncio_cancel_fair.py

@@ -0,0 +1,38 @@
+# SPDX-FileCopyrightText: 2019 Damien P. George
+#
+# SPDX-License-Identifier: MIT
+#
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019 Damien P. George
+#
+# pylint: skip-file
+#
+# Test fairness of cancelling a task
+# That tasks which continuously cancel each other don't take over the scheduler
+import asyncio
+
+
+async def task(id, other):
+    for i in range(3):
+        try:
+            print("start", id)
+            await asyncio.sleep(0)
+            print("done", id)
+        except asyncio.CancelledError as er:
+            print("cancelled", id)
+        if other is not None:
+            print(id, "cancels", other)
+            tasks[other].cancel()
+
+
+async def main():
+    global tasks
+    tasks = [
+        asyncio.create_task(task(0, 1)),
+        asyncio.create_task(task(1, 0)),
+        asyncio.create_task(task(2, None)),
+    ]
+    await tasks[2]
+
+
+asyncio.run(main())

tests/asyncio/asyncio_cancel_fair.py.exp

@@ -0,0 +1,24 @@
+start 0
+start 1
+start 2
+done 0
+0 cancels 1
+start 0
+cancelled 1
+1 cancels 0
+start 1
+done 2
+start 2
+cancelled 0
+0 cancels 1
+start 0
+cancelled 1
+1 cancels 0
+start 1
+done 2
+start 2
+cancelled 0
+0 cancels 1
+cancelled 1
+1 cancels 0
+done 2

tests/asyncio/asyncio_cancel_fair2.py

@@ -0,0 +1,38 @@
+# SPDX-FileCopyrightText: 2019 Damien P. George
+#
+# SPDX-License-Identifier: MIT
+#
+# MicroPython uasyncio module
+# MIT license; Copyright (c) 2019 Damien P. George
+#
+# pylint: skip-file
+#
+# Test fairness of cancelling a task
+# That tasks which keeps being cancelled by multiple other tasks gets a chance to run
+import asyncio
+
+
+async def task_a():
+    try:
+        while True:
+            print("sleep a")
+            await asyncio.sleep(0)
+    except asyncio.CancelledError:
+        print("cancelled a")
+
+
+async def task_b(id, other):
+    while other.cancel():
+        print("sleep b", id)
+        await asyncio.sleep(0)
+    print("done b", id)
+
+
+async def main():
+    t = asyncio.create_task(task_a())
+    for i in range(3):
+        asyncio.create_task(task_b(i, t))
+    await t
+
+
+asyncio.run(main())

tests/asyncio/asyncio_cancel_fair2.py.exp

@@ -0,0 +1,8 @@
+sleep a
+sleep b 0
+sleep b 1
+sleep b 2
+cancelled a
+done b 0
+done b 1
+done b 2