def testException(self):
"""
Tests the exception storage
"""
event = utilities.EventData()
# "Raise" an exception
exception = Exception("Some dummy exception")
event.raise_exception(exception)
# Check content
self.assertTrue(event.is_set(), "Event has not been set")
self.assertIsNone(event.data, "Non-None data")
self.assertIs(event.exception, exception, "Invalid exception")
# Check the behavior of "wait"
try:
event.wait()
except Exception as ex:
self.assertIs(ex, exception, "Not the same exception")
self.assertTrue(event.is_set(), "Event has been cleared")
else:
self.fail("Exception not raised")
# Clear
event.clear()
self.assertFalse(event.is_set(), "Event has been set")
self.assertIsNone(event.data, "Non-None data")
self.assertIsNone(event.exception, "Non-None exception")
def run(self, method, *args, **kwargs):
"""
Runs the given method in the main thread
:param method: The method to call
:param args: Method arguments
:param kwargs: Method keyword arguments
:return: The result of the method
:raise ValueError: Qt is not started yet
"""
if self.__waiting_calls is None:
raise ValueError("UI not yet set up")
# Make an event object
event = utils.EventData()
# Add the method to the waiting list
self.__waiting_calls.put((method, args, kwargs, event))
# Emit to signal, to let Qt execute __ui_runner
self.__ui_queued.emit()
# Force Qt to handle the event
self.__app.processEvents()
# Wait for the event before returning
return event.wait()
def testSetClear(self):
"""
Tests set() and clear() operations
"""
# Initial condition
event = utilities.EventData()
self.assertFalse(event.is_set(), "Event initially set")
self.assertIsNone(event.data, "Non-None data")
self.assertIsNone(event.exception, "Non-None exception")
# No-data set
event.set()
self.assertTrue(event.is_set(), "Event not set")
self.assertIsNone(event.data, "Non-None data")
self.assertIsNone(event.exception, "Non-None exception")
# Clear
event.clear()
self.assertFalse(event.is_set(), "Event still set")
self.assertIsNone(event.data, "Non-None data")
self.assertIsNone(event.exception, "Non-None exception")
# Set data
data = object()
event.set(data)
self.assertTrue(event.is_set(), "Event not set")
self.assertIs(event.data, data, "Invalid event data")
self.assertIsNone(event.exception, "Non-None exception")
# Clear
event.clear()
self.assertFalse(event.is_set(), "Event still set")
self.assertIsNone(event.data, "Non-None data")
self.assertIsNone(event.exception, "Non-None exception")
def testBadCallback(self):
"""
Tests behavior on callback error
"""
future = threadpool.FutureResult()
args = (1, 2, 3)
flag = utilities.EventData()
def dummy():
"""
Callback without arguments
"""
flag.set()
# Bad number of arguments: no exception must be raised
future.set_callback(dummy)
future.execute(self._simple_call, args, None)
self.assertFalse(flag.is_set(), "Flag shouldn't be set...")
def raising(data, exception, ex):
"""
Callback raising an exception
"""
flag.set()
raise ex
exception = ValueError("Dummy error")
future.set_callback(raising, exception)
self.assertTrue(flag.is_set(), "Callback not called")
def testCallbackException(self):
"""
Tests the callback method in case of exception
"""
# Set the callback before calling the method
flag = utilities.EventData()
future = threadpool.FutureResult()
future.set_callback(self._callback, flag)
self.assertFalse(flag.is_set(), "Flag already set")
# Execute
try:
future.execute(self._raise_call, None, None)
except Exception as ex:
# Store it
exception = ex
else:
self.fail("Exception wasn't propagated")
# Check event content
self.assertTrue(flag.is_set(), "Callback method not called")
self.assertIs(flag.exception, exception, "Exception not set")
self.assertIsNone(flag.data, "Data set")
# ... Re-set the callback (should be re-called)
flag.clear()
self.assertFalse(flag.is_set(), "Flag already set")
future.set_callback(self._callback, flag)
# Check event content
self.assertTrue(flag.is_set(), "Callback method not called")
self.assertIs(flag.exception, exception, "Exception not set")
self.assertIsNone(flag.data, "Data set")
def testCallback(self):
"""
Tests the callback method
"""
# Set the callback before calling the method
flag = utilities.EventData()
future = threadpool.FutureResult()
future.set_callback(self._callback, flag)
self.assertFalse(flag.is_set(), "Flag already set")
# Execute
args = (1, 2, 3)
future.execute(self._simple_call, args, None)
# Check event content
self.assertTrue(flag.is_set(), "Callback method not called")
self.assertIsNone(flag.exception, "Exception set")
self.assertEqual(flag.data, args, "Data not set")
# ... Re-set the callback (should be re-called)
flag.clear()
self.assertFalse(flag.is_set(), "Flag already set")
future.set_callback(self._callback, flag)
# Check event content
self.assertTrue(flag.is_set(), "Callback method not called")
self.assertIsNone(flag.exception, "Exception set")
self.assertEqual(flag.data, args, "Data not set")
def testWait(self):
"""
Tests the wait() method
"""
event = utilities.EventData()
self.assertFalse(event.wait(.1), "Timed out wait must return False")
start = time.time()
threading.Timer(1, event.set).start()
self.assertFalse(event.wait(.1), "Timed out wait must return False")
self.assertTrue(event.wait(), "Wait should return true on set")
self.assertLessEqual(time.time() - start, 2, "Too long to wait")
self.assertTrue(event.wait(.5),
"Already set event shoudn't block wait()")
self.assertTrue(event.wait(),
"Already set event shoudn't block wait()")
def run(self, method, *args, **kwargs):
"""
Runs the given method in the main thread
:param method: The method to call
:param args: Method arguments
:param kwargs: Method keyword arguments
:return: The result of the method
"""
# Make an event object
event = utils.EventData()
# Call the runner
AppHelper.callAfter(self.__ui_runner, event, method, args, kwargs)
# Wait for it
return event.wait()
def run(self, method, *args, **kwargs):
"""
Runs the given method in the main thread
:param method: The method to call
:param args: Method arguments
:param kwargs: Method keyword arguments
:return: The result of the method
"""
# Make an event object
event = utils.EventData()
# Add the method to the waiting list
self._queue.put((method, args, kwargs, event))
# Wait for it...
event.wait()
return event.data
def testWaitException(self):
"""
Tests the exception effect on wait()
"""
event = utilities.EventData()
exception = Exception("Some dummy exception")
# "Raise" an exception
threading.Timer(.5, event.raise_exception, [exception]).start()
# Check the behavior of "wait"
try:
event.wait()
except Exception as ex:
self.assertIs(ex, exception, "Not the same exception")
else:
self.fail("Exception not raised")
# Check content
self.assertTrue(event.is_set(), "Event has been cleared")
self.assertIsNone(event.data, "Non-None data")
self.assertIs(event.exception, exception, "Invalid exception")
def __init__(self, timeout):
"""
The temporal proxy
"""
self.__event = utilities.EventData()
self.__timeout = timeout