test/lib_event.py
changeset 56 07ed878c847b
parent 42 0ff56f7216ee
equal deleted inserted replaced
55:99c4344a35ce 56:07ed878c847b
     1 import unittest
     1 import unittest
     2 
     2 
     3 from qmsk.net.lib.event2.base import event_base
     3 from qmsk.net.lib.event2.base import event_base
     4 from qmsk.net.lib.event2.event import event
     4 from qmsk.net.lib.event2.event import event, CallbackEvent
     5 from qmsk.net.lib.event2.constants import *
     5 from qmsk.net.lib.event2.constants import *
     6 
     6 
     7 import os
     7 import os
     8 
     8 
     9 class MyEvent (event) :
     9 class MyEvent (event) :
    18     def __call__ (self, fd, mask) :
    18     def __call__ (self, fd, mask) :
    19         self.ev_out = mask
    19         self.ev_out = mask
    20 
    20 
    21         self.res = (mask == self.ev_in)
    21         self.res = (mask == self.ev_in)
    22 
    22 
       
    23 
    23 class TestEventBase (unittest.TestCase) :
    24 class TestEventBase (unittest.TestCase) :
    24     """
    25     """
    25         Simple event_base bits
    26         Simple event_base bits
    26     """
    27     """
    27     
    28     
    39         """
    40         """
    40             loop(nonblock=False) on an empty event_base returns False
    41             loop(nonblock=False) on an empty event_base returns False
    41         """
    42         """
    42 
    43 
    43         self.assertFalse(self.ev_base.loop(nonblock=True))
    44         self.assertFalse(self.ev_base.loop(nonblock=True))
       
    45 
    44 
    46 
    45 class TestEvent (unittest.TestCase) :
    47 class TestEvent (unittest.TestCase) :
    46     """
    48     """
    47         Simple event bits.
    49         Simple event bits.
    48     """
    50     """
   124             Building an event with an invalid mask (0)... XXX: works?
   126             Building an event with an invalid mask (0)... XXX: works?
   125         """
   127         """
   126         
   128         
   127         ev = event(self.ev_base, 0, 0)
   129         ev = event(self.ev_base, 0, 0)
   128         ev.add()
   130         ev.add()
       
   131     
       
   132     def test_init_nonalive (self) :
       
   133         """
       
   134             An event is not alive after init
       
   135         """
       
   136 
       
   137         ev = event(self.ev_base, 0, 0)
       
   138 
       
   139         self.assertFalse(ev.alive)
       
   140 
       
   141     def test_add_alive (self) :
       
   142         """
       
   143             An event is considered alive and pending after add
       
   144         """
       
   145 
       
   146         ev = event(self.ev_base, 0, EV_READ)
       
   147         ev.add()
       
   148 
       
   149         self.assertTrue(ev.alive)
       
   150 
       
   151     def test_del_nonalive (self) :
       
   152         """
       
   153             An event is not considered alive anymore after del
       
   154         """
       
   155     
       
   156         ev = event(self.ev_base, 0, EV_READ)
       
   157         ev.add()
       
   158 
       
   159         ev.delete()
       
   160 
       
   161         self.assertFalse(ev.alive)
       
   162 
       
   163     def test_fire_nonalive (self) :
       
   164         """
       
   165             An event is not considered alive anymore during callback execution the callback fires, nor afterwards
       
   166         """
       
   167 
       
   168         fired = []
       
   169 
       
   170         def cb (ev, what) :
       
   171             fired.append(1)
       
   172 
       
   173             self.assertFalse(ev.alive)
       
   174         
       
   175         ev = CallbackEvent(self.ev_base, 0, EV_READ, cb)
       
   176         ev.add(-1)
       
   177         
       
   178         self.ev_base.loop()
       
   179 
       
   180         # fired
       
   181         self.assertTrue(fired)
       
   182         
       
   183         # not alive anymore
       
   184         self.assertFalse(ev.alive)
       
   185 
       
   186     def test_fire_add_alive (self) :
       
   187         """
       
   188             An event is considered alive if it is re-added during callback exec
       
   189         """
       
   190 
       
   191         ev = CallbackEvent(self.ev_base, 0, EV_READ,
       
   192             lambda ev, what: ev.add()
       
   193         )
       
   194 
       
   195         ev.add(0)
       
   196 
       
   197         self.ev_base.loop(once=True, nonblock=True)
       
   198 
       
   199         # still alive
       
   200         self.assertTrue(ev.alive)
       
   201     
       
   202     def test_persistent_fire_alive (self) :
       
   203         """
       
   204             A persistent event is still considered alive during and after callback exec
       
   205         """
       
   206 
       
   207         ev = CallbackEvent(self.ev_base, 0, EV_READ,
       
   208             lambda ev, what: self.assertTrue(ev.alive)
       
   209         )
       
   210 
       
   211         ev.add()
       
   212 
       
   213         self.ev_base.loop(once=True, nonblock=True)
       
   214         
       
   215         # persists -> stays alive
       
   216         self.assertTrue(ev.alive)
       
   217 
   129 
   218 
   130 class TestEventPipe (unittest.TestCase) :
   219 class TestEventPipe (unittest.TestCase) :
   131     """
   220     """
   132         Test basic event stuff using a pipe.
   221         Test basic event stuff using a pipe.
   133     """
   222     """