utils/concurrent: Handle an empty futures list better (FutureSetWatcher)

That is, ensure a `doneAll` signal is always emitted

Author: ales-erjavec

Orange/widgets/utils/concurrent.py

@@ -570,10 +570,11 @@ class FutureSetWatcher(QObject):
     doneAll = Signal()
 
     def __init__(self, futures=None, *args, **kwargs):
+        # type: (List[Future], ...) -> None
         super().__init__(*args, **kwargs)
         self.__futures = None
         self.__countdone = 0
-        if futures:
+        if futures is not None:
             self.setFutures(futures)
 
     def setFutures(self, futures):
@@ -608,6 +609,9 @@ def on_done(index, f):
                     pass
 
             future.add_done_callback(partial(on_done, i))
+        if not self.__futures:
+            # `futures` was an empty sequence.
+            methodinvoke(self, "doneAll", ())()
 
     @Slot(int, Future)
     def __emitpending(self, index, future):
@@ -644,6 +648,10 @@ def flush(self):
         assert QThread.currentThread() is self.thread()
         QCoreApplication.sendPostedEvents(self, QEvent.MetaCall)
 
+    def wait(self):
+        assert self.__futures is not None
+        concurrent.futures.wait(self.__futures)
+
 
 class methodinvoke(object):
     """

Orange/widgets/utils/tests/test_concurrent.py

@@ -201,6 +201,31 @@ def as_set(seq):
         self.assertSetEqual(as_set(spy.resultAt), {(0, True)})
         self.assertSetEqual(as_set(spy.exceptionAt), set())
 
+        # doneAll must always be emitted after the doneAt signal.
+        executor = ThreadPoolExecutor(max_workers=2)
+        futures = [executor.submit(pow, 1000, 1000) for _ in range(100)]
+        watcher = FutureSetWatcher(futures)
+        emithistory = []
+        watcher.doneAt.connect(lambda i, f: emithistory.append(("doneAt", i, f)))
+        watcher.doneAll.connect(lambda: emithistory.append(("doneAll", )))
+
+        spy = spies(watcher)
+        watcher.wait()
+        self.assertEqual(len(spy.doneAll), 0)
+        self.assertEqual(len(spy.doneAt), 0)
+        watcher.flush()
+        self.assertEqual(len(spy.doneAt), 100)
+        self.assertEqual(list(spy.doneAll), [[]])
+        self.assertSetEqual(set(emithistory[:-1]),
+                            {("doneAt", i, f) for i, f in enumerate(futures)})
+        self.assertEqual(emithistory[-1], ("doneAll",))
+
+        # doneAll must be emitted even when on an empty futures list
+        watcher = FutureSetWatcher()
+        watcher.setFutures([])
+        spy = spies(watcher)
+        self.assertTrue(spy.doneAll.wait())
+
 
 class TestTask(CoreAppTestCase):