tests: Rename uasyncio to asyncio.

This work was funded through GitHub Sponsors.

Signed-off-by: Jim Mussared <jim.mussared@gmail.com>

tests/extmod/uasyncio_await_return.py → tests/extmod/asyncio_await_return.py

@@ -1,13 +1,10 @@
 # Test that tasks return their value correctly to the caller
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 async def foo():

tests/extmod/uasyncio_basic.py → tests/extmod/asyncio_basic.py

@@ -1,11 +1,8 @@
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 import time
 

tests/extmod/uasyncio_basic2.py → tests/extmod/asyncio_basic2.py

@@ -1,11 +1,8 @@
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 async def forever():

tests/extmod/uasyncio_cancel_fair.py → tests/extmod/asyncio_cancel_fair.py

@@ -2,13 +2,10 @@
 # That tasks which continuously cancel each other don't take over the scheduler
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 async def task(id, other):

tests/extmod/uasyncio_cancel_fair2.py → tests/extmod/asyncio_cancel_fair2.py

@@ -2,13 +2,10 @@
 # That tasks which keeps being cancelled by multiple other tasks gets a chance to run
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 async def task_a():

tests/extmod/uasyncio_cancel_self.py → tests/extmod/asyncio_cancel_self.py

@@ -1,13 +1,10 @@
 # Test a task cancelling itself (currently unsupported)
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 async def task():

tests/extmod/uasyncio_cancel_task.py → tests/extmod/asyncio_cancel_task.py

@@ -1,13 +1,10 @@
 # Test cancelling a task
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 async def task(s, allow_cancel):

tests/extmod/uasyncio_cancel_wait_on_finished.py → tests/extmod/asyncio_cancel_wait_on_finished.py

@@ -1,13 +1,10 @@
 # Test cancelling a task that is waiting on a task that just finishes.
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 async def sleep_task():

tests/extmod/uasyncio_current_task.py → tests/extmod/asyncio_current_task.py

@@ -1,13 +1,10 @@
 # Test current_task() function
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 async def task(result):

tests/extmod/uasyncio_event.py → tests/extmod/asyncio_event.py

@@ -1,13 +1,10 @@
 # Test Event class
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 async def task(id, ev):

tests/extmod/uasyncio_event_fair.py → tests/extmod/asyncio_event_fair.py

@@ -2,13 +2,10 @@
 # That tasks which continuously wait on events don't take over the scheduler
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 async def task1(id):

tests/extmod/uasyncio_exception.py → tests/extmod/asyncio_exception.py

@@ -1,13 +1,10 @@
 # Test general exception handling
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 # main task raising an exception

tests/extmod/uasyncio_fair.py → tests/extmod/asyncio_fair.py

@@ -1,13 +1,10 @@
 # Test fairness of scheduler
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 async def task(id, t):

tests/extmod/uasyncio_gather.py → tests/extmod/asyncio_gather.py

@@ -1,13 +1,10 @@
-# test uasyncio.gather() function
+# test asyncio.gather() function
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 async def factorial(name, number):

tests/extmod/uasyncio_gather_notimpl.py → tests/extmod/asyncio_gather_notimpl.py

@@ -1,13 +1,10 @@
-# Test uasyncio.gather() function, features that are not implemented.
+# Test asyncio.gather() function, features that are not implemented.
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 def custom_handler(loop, context):

tests/extmod/uasyncio_get_event_loop.py → tests/extmod/asyncio_get_event_loop.py

@@ -1,13 +1,10 @@
 # Test get_event_loop()
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 async def main():

tests/extmod/uasyncio_heaplock.py → tests/extmod/asyncio_heaplock.py

@@ -1,6 +1,6 @@
 # test that the following do not use the heap:
 # - basic scheduling of tasks
-# - uasyncio.sleep_ms
+# - asyncio.sleep_ms
 # - StreamWriter.write, stream is blocked and data to write is a bytes object
 # - StreamWriter.write, when stream is not blocked
 
@@ -25,13 +25,10 @@ def f(x):
     raise SystemExit
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 class TestStream:

tests/extmod/uasyncio_lock.py → tests/extmod/asyncio_lock.py

@@ -1,13 +1,10 @@
 # Test Lock class
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 async def task_loop(id, lock):

tests/extmod/uasyncio_lock_cancel.py → tests/extmod/asyncio_lock_cancel.py

@@ -1,13 +1,10 @@
 # Test that locks work when cancelling multiple waiters on the lock
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 async def task(i, lock, lock_flag):

tests/extmod/uasyncio_loop_stop.py → tests/extmod/asyncio_loop_stop.py

@@ -1,13 +1,10 @@
 # Test Loop.stop() to stop the event loop
 
 try:
-    import uasyncio as asyncio
+    import asyncio
 except ImportError:
-    try:
-        import asyncio
-    except ImportError:
-        print("SKIP")
-        raise SystemExit
+    print("SKIP")
+    raise SystemExit
 
 
 async def task():

tests/extmod/uasyncio_micropython.py → tests/extmod/asyncio_micropython.py

@@ -3,41 +3,41 @@
 # - wait_for_ms
 
 try:
-    import time, uasyncio
+    import time, asyncio
 except ImportError:
     print("SKIP")
     raise SystemExit
 
 
 async def task(id, t):
     print("task start", id)
-    await uasyncio.sleep_ms(t)
+    await asyncio.sleep_ms(t)
     print("task end", id)
     return id * 2
 
 
 async def main():
     # Simple sleep_ms
     t0 = time.ticks_ms()
-    await uasyncio.sleep_ms(1)
+    await asyncio.sleep_ms(1)
     print(time.ticks_diff(time.ticks_ms(), t0) < 100)
 
     try:
         # Sleep 1ms beyond maximum allowed sleep value
-        await uasyncio.sleep_ms(time.ticks_add(0, -1) // 2 + 1)
+        await asyncio.sleep_ms(time.ticks_add(0, -1) // 2 + 1)
     except OverflowError:
         print("OverflowError")
 
     # When task finished before the timeout
-    print(await uasyncio.wait_for_ms(task(1, 5), 50))
+    print(await asyncio.wait_for_ms(task(1, 5), 50))
 
     # When timeout passes and task is cancelled
     try:
-        print(await uasyncio.wait_for_ms(task(2, 50), 5))
-    except uasyncio.TimeoutError:
+        print(await asyncio.wait_for_ms(task(2, 50), 5))
+    except asyncio.TimeoutError:
         print("timeout")
 
     print("finish")
 
 
-uasyncio.run(main())
+asyncio.run(main())