test/lib_event.py
changeset 42 0ff56f7216ee
parent 40 a5d498bbf40a
child 56 07ed878c847b
equal deleted inserted replaced
41:02f7c0539843 42:0ff56f7216ee
    40             loop(nonblock=False) on an empty event_base returns False
    40             loop(nonblock=False) on an empty event_base returns False
    41         """
    41         """
    42 
    42 
    43         self.assertFalse(self.ev_base.loop(nonblock=True))
    43         self.assertFalse(self.ev_base.loop(nonblock=True))
    44 
    44 
    45  
    45 class TestEvent (unittest.TestCase) :
       
    46     """
       
    47         Simple event bits.
       
    48     """
       
    49 
       
    50     def setUp (self) :
       
    51         self.ev_base = event_base()
       
    52         self.ev = event(self.ev_base, 0, EV_READ)
       
    53 
       
    54     def test_add (self) :
       
    55         """
       
    56             .add() works.
       
    57         """
       
    58 
       
    59         self.assertFalse(self.ev.pending(EV_READ))
       
    60 
       
    61         self.ev.add()
       
    62         
       
    63         self.assertTrue(self.ev.pending(EV_READ))
       
    64 
       
    65     def test_add_timeout (self) :
       
    66         """
       
    67             .add() with timeout works
       
    68         """
       
    69 
       
    70         self.ev.add(1.1)
       
    71         self.assertTrue(self.ev.pending())
       
    72     
       
    73     def test_add_del (self) :
       
    74         """
       
    75             .add() and then .delete() works
       
    76         """
       
    77 
       
    78         self.assertFalse(self.ev.pending())
       
    79         
       
    80         # add it in
       
    81         self.ev.add()
       
    82 
       
    83         self.assertTrue(self.ev.pending())
       
    84 
       
    85         # ensure that the ev_base is indeed not empty
       
    86         self.assertTrue(self.ev_base.loop(nonblock=True))
       
    87 
       
    88     
       
    89         # remove it again
       
    90         self.ev.delete()
       
    91 
       
    92         self.assertFalse(self.ev.pending())
       
    93 
       
    94         # ensure that the ev_base is indeed empty
       
    95         self.assertFalse(self.ev_base.loop(nonblock=True))
       
    96     
       
    97     def test_invalid_base (self) :
       
    98         """
       
    99             Building an event with invalid base (None) fails
       
   100         """
       
   101         
       
   102         # XXX: this doesn't actually seem to check against None, just the type..?
       
   103         self.assertRaises(TypeError, event, None, 0, EV_READ)
       
   104 
       
   105     def test_illegal_fd (self) :
       
   106         """
       
   107             Building an event with an illegal fd (-1) fails
       
   108         """
       
   109 
       
   110         self.assertRaises(ValueError, event, self.ev_base, -1, EV_READ)
       
   111 
       
   112     def test_invalid_fd (self) :
       
   113         """
       
   114             Building an event with an invalid fd (>= 0) fails when calling .add()
       
   115         """
       
   116         
       
   117         ev = event(self.ev_base, 666, EV_READ)
       
   118         
       
   119         # XXX: be more specific about Exception
       
   120         self.assertRaises(Exception, ev.add)
       
   121     
       
   122     def test_invalid_mask_zero (self) :
       
   123         """
       
   124             Building an event with an invalid mask (0)... XXX: works?
       
   125         """
       
   126         
       
   127         ev = event(self.ev_base, 0, 0)
       
   128         ev.add()
       
   129 
    46 class TestEventPipe (unittest.TestCase) :
   130 class TestEventPipe (unittest.TestCase) :
    47     """
   131     """
    48         Test basic event stuff using a pipe.
   132         Test basic event stuff using a pipe.
    49     """
   133     """
    50 
   134 
   101         # loop once
   185         # loop once
   102         self.ev_base.loop(nonblock=True)
   186         self.ev_base.loop(nonblock=True)
   103 
   187 
   104         # test
   188         # test
   105         self.assertEquals(ev.ev_out, None)
   189         self.assertEquals(ev.ev_out, None)
   106 
   190     
   107 if __name__ == '__main__' :
   191 if __name__ == '__main__' :
   108     unittest.main()
   192     unittest.main()