[pygobject/benzea/gio-asyncio] fixup

[Benjamin Berg <bberg src gnome org>]

commit 78f10c455838c66481748ce8f004f36991268cee
Author: Benjamin Berg <bberg redhat com>
Date:   Mon Nov 22 16:27:45 2021 +0100

    fixup

 gi/events.py         | 14 +++++-----
 tests/test_events.py | 74 +++++++++++++++++++++++++++++-----------------------
 2 files changed, 50 insertions(+), 38 deletions(-)
---
diff --git a/gi/events.py b/gi/events.py
index 54ab229a..78b96fba 100644
--- a/gi/events.py
+++ b/gi/events.py
@@ -159,10 +159,11 @@ class GLibEventLoop(asyncio.SelectorEventLoop):
             if source:
                 source.destroy()
 
+            # Setup a new source with a higher priority than our main one
             source = GLib.unix_signal_source_new(sig)
-
             source.set_name(f"asyncio signal watch for {sig}")
-            source.attach(GLib.MainContext.get_thread_default())
+            source.set_priority(GLib.PRIORITY_HIGH)
+            source.attach(self._context)
             source.set_callback(self._signal_cb, sig)
 
             self.__signal_handlers[sig] = (source, callback, args)
@@ -291,10 +292,11 @@ class GLibEventLoopPolicy(events.AbstractEventLoopPolicy):
         if loop is None:
             # We do permit unsetting the current loop/context
             old = self._loops.pop(hash(ctx), None)
-            if old and hash(old._context) != hash(ctx):
-                warnings.warn('GMainContext was changed unknowingly by asyncio integration!', RuntimeWarning)
-            elif old and ctx_td:
-                GLib.MainContext.pop_thread_default(ctx_td)
+            if old:
+                if hash(old._context) != hash(ctx):
+                    warnings.warn('GMainContext was changed unknowingly by asyncio integration!', 
RuntimeWarning)
+                if ctx_td:
+                    GLib.MainContext.pop_thread_default(ctx_td)
         else:
             # Only allow attaching if the thread has no main context yet
             if ctx:
diff --git a/tests/test_events.py b/tests/test_events.py
index 31fb8223..97852fb7 100644
--- a/tests/test_events.py
+++ b/tests/test_events.py
@@ -32,6 +32,7 @@ import gi
 import gi.events
 import asyncio
 import threading
+from gi.repository import GLib
 
 from test import support
 from asyncio import base_events
@@ -47,37 +48,41 @@ if sys.platform != 'win32':
 
     class GLibEventLoopTests(UnixEventLoopTestsMixin, test_utils.TestCase):
 
-        # Python 3.6 asyncio.sleep requires the policy to be set globally
-        @classmethod
-        def setUpClass(cls):
-            policy = gi.events.GLibEventLoopPolicy()
-            # Nop out set_child_watcher to not throw a NotImplemented error
-            policy.set_child_watcher = lambda *args: None
-
-            # Wrap set_event_loop to only check and unset (but not set)
-            # See create_event_loop()
-            def set_event_loop(loop):
-                nonlocal policy
-                nonlocal orig_set_event_loop
-                if loop is not None:
-                    assert policy.get_event_loop() == loop
-                else:
-                    orig_set_event_loop(loop)
-
-            orig_set_event_loop = policy.set_event_loop
-            policy.set_event_loop = set_event_loop
-
-            asyncio.set_event_loop_policy(policy)
-            super().setUpClass()
-            print("class set up")
+        def __init__(self, *args):
+            super().__init__(*args)
+            self.loop = None
 
-        @classmethod
-        def tearDownClass(cls):
-            print("tearing down class")
-            asyncio.set_event_loop_policy(None)
-            print("event loop policy cleared")
-            super().tearDownClass()
-            print("tearing down class done")
+        # Python 3.6 asyncio.sleep requires the policy to be set globally
+#        @classmethod
+#        def setUpClass(cls):
+#            policy = gi.events.GLibEventLoopPolicy()
+#            # Nop out set_child_watcher to not throw a NotImplemented error
+#            policy.set_child_watcher = lambda *args: None
+
+#            # Wrap set_event_loop to only check and unset (but not set)
+#            # See create_event_loop()
+#            def set_event_loop(loop):
+#                nonlocal policy
+#                nonlocal orig_set_event_loop
+#                if loop is not None:
+#                    assert policy.get_event_loop() == loop
+#                else:
+#                    orig_set_event_loop(loop)
+
+#            orig_set_event_loop = policy.set_event_loop
+#            policy.set_event_loop = set_event_loop
+
+#            asyncio.set_event_loop_policy(policy)
+#            super().setUpClass()
+#            print("class set up")
+
+#        @classmethod
+#        def tearDownClass(cls):
+#            print("tearing down class")
+#            asyncio.set_event_loop_policy(None)
+#            print("event loop policy cleared")
+#            super().tearDownClass()
+#            print("tearing down class done")
 
         def setUp(self):
             print("running", os.environ['PYTEST_CURRENT_TEST'])
@@ -103,9 +108,14 @@ if sys.platform != 'win32':
             print('test case tear down done')
 
         def create_event_loop(self):
-            # Aour policy does not support explicitly creating an event loop
+            return gi.events.GLibEventLoop(GLib.MainContext())
+
+            # Our policy does not support explicitly creating an event loop
             # that will be used for the main thread.
-            # So, create the loop by fetching it instead.
+            # So, create the loop by fetching it instead; and close self.loop
+            if self.loop is not None and not self.loop.is_closed():
+                print("closing loop")
+                self.loop.close()
             asyncio.get_event_loop_policy().set_event_loop(None)
             return asyncio.get_event_loop_policy().get_event_loop()