add tests for asyncio

.github/workflows/build.yml

@@ -14,3 +14,8 @@ jobs:
       uses: adafruit/workflows-circuitpython-libs/build@main
       with:
         package-prefix: "asyncio"
+
+  test-v9-0-0-alpha5:
+    uses: ./.github/workflows/run-tests.yml
+    with:
+      cp-version: 9.0.0-alpha.5

.github/workflows/run-tests.yml

@@ -0,0 +1,63 @@
+# SPDX-FileCopyrightText: 2014 MicroPython & CircuitPython contributors (https://github.com/adafruit/circuitpython/graphs/contributors)
+#
+# SPDX-License-Identifier: MIT
+
+name: Run tests
+
+on:
+  workflow_call:
+    inputs:
+      cp-version:
+        required: true
+        type: string
+
+jobs:
+  run:
+    runs-on: ubuntu-22.04
+    env:
+      CP_VERSION: ${{ inputs.cp-version }}
+    steps:
+    - name: Set up repository
+      uses: actions/checkout@v3
+      with:
+        submodules: false
+        fetch-depth: 1
+    - name: Set up circuitpython repository
+      uses: actions/checkout@v3
+      with:
+        ref: ${{ inputs.cp-version }}
+        repository: adafruit/circuitpython
+        path: ./circuitpython/
+        submodules: false
+        fetch-depth: 1
+        fetch-tags: true
+    - name: Set up python
+      uses: actions/setup-python@v4
+      with:
+        python-version: 3.8
+    - name: CircuitPython dependencies
+      id: cp-deps
+      run: python tools/ci_fetch_deps.py tests
+      shell: bash
+      working-directory: ./circuitpython/
+    - name: Fetch relevant submodules
+      id: submodules
+      run: python tools/ci_fetch_deps.py tests
+      working-directory: ./circuitpython
+    - name: Install python dependencies
+      run: pip install -r requirements-dev.txt
+      shell: bash
+      working-directory: ./circuitpython/
+    - name: Build mpy-cross
+      run: make -C mpy-cross -j2
+      working-directory: ./circuitpython/
+    - name: Build unix port
+      run: make -C ports/unix VARIANT=coverage BUILD=build-coverage PROG=micropython -j2
+      working-directory: ./circuitpython/
+    - name: Run tests
+      run: ./run_tests.py
+      working-directory: tests
+      env:
+        MICROPY_CPYTHON3: python3.8
+        MICROPY_MICROPYTHON: ../circuitpython/ports/unix/build-coverage/micropython
+        MICROPYPATH: ../:../circuitpython/frozen/Adafruit_CircuitPython_Ticks

tests/.gitignore

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2019 Damien P. George
+#
+# SPDX-License-Identifier: MIT
+*.out

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,5 @@
+# SPDX-FileCopyrightText: 2019 Damien P. George
+#
+# SPDX-License-Identifier: MIT
+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,9 @@
+# SPDX-FileCopyrightText: 2019 Damien P. George
+#
+# SPDX-License-Identifier: MIT
+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,7 @@
+# SPDX-FileCopyrightText: 2019 Damien P. George
+#
+# SPDX-License-Identifier: MIT
+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,27 @@
+# SPDX-FileCopyrightText: 2019 Damien P. George
+#
+# SPDX-License-Identifier: MIT
+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,11 @@
+# SPDX-FileCopyrightText: 2019 Damien P. George
+#
+# SPDX-License-Identifier: MIT
+sleep a
+sleep b 0
+sleep b 1
+sleep b 2
+cancelled a
+done b 0
+done b 1
+done b 2

tests/asyncio/asyncio_cancel_self.py

@@ -0,0 +1,32 @@
+# 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 a task cancelling itself (currently unsupported)
+import asyncio
+
+
+async def task():
+    print("task start")
+    global_task.cancel()
+
+
+async def main():
+    global global_task
+    global_task = asyncio.create_task(task())
+    try:
+        await global_task
+    except asyncio.CancelledError:
+        print("main cancel")
+    print("main done")
+
+
+try:
+    asyncio.run(main())
+except RuntimeError as er:
+    print(er)

tests/asyncio/asyncio_cancel_self.py.exp

@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: 2019 Damien P. George
+#
+# SPDX-License-Identifier: MIT
+task start
+can't cancel self