Update CI/CDs

Author: =

README.md

@@ -79,9 +79,12 @@ async def main():
     loop = asyncio.get_running_loop()
 
     with ThreadPoolExecutorPlus.ThreadPoolExecutor() as pool:
-        result = await loop.run_in_executor(
+        result1 = await loop.run_in_executor(
             pool, blocking_io)
-        print('custom thread pool', result)
+        result2 = await loop.run_in_executor(
+            pool, cpu_bound)
+        print('custom thread pool', result1)
+        print('custom thread pool', result2)
 
 asyncio.run(main())
 ```

tests/test_compatibility.py

@@ -0,0 +1,54 @@
+import os , sys
+sys.path.append(os.getcwd())
+import pytest
+from ThreadPoolExecutorPlus import *
+import concurrent.futures
+import urllib.request
+import asyncio
+
+
+def test_threadpoolexecutor_example():
+    URLS = [
+        'http://www.foxnews.com/',
+        'http://www.cnn.com/',
+        'http://europe.wsj.com/',
+        'http://www.bbc.co.uk/',
+        'http://www.google.com/',
+        'http://www.youtube.com/'
+    ]
+
+    def load_url(url, timeout):
+        with urllib.request.urlopen(url, timeout=timeout) as conn:
+            return conn.read()
+
+    with ThreadPoolExecutor(max_workers=6) as executor:
+        future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}
+        succeed_count = 0
+        for future in concurrent.futures.as_completed(future_to_url):
+            url = future_to_url[future]
+            try:
+                data = future.result()
+            except Exception as exc:
+                pass
+            else:
+                assert len(data) > 0
+                succeed_count += 1
+        assert succeed_count > 0
+
+@pytest.mark.asyncio
+async def test_executing_code_in_thread_or_process_pools():
+
+    def blocking_io():
+        with open('/dev/urandom', 'rb') as f:
+            return f.read(100)
+
+    def cpu_bound():
+        return sum(i * i for i in range(2 * 10 ** 6))
+
+    loop = asyncio.get_running_loop() if 'get_running_loop' in dir(asyncio) else asyncio.get_event_loop()
+
+    with ThreadPoolExecutor() as pool:
+        result1 = await loop.run_in_executor(pool, blocking_io)
+        result2 = await loop.run_in_executor(pool, cpu_bound)
+        assert len(result1) == 100
+        assert result2 == 2666664666667000000

tests/test_feature.py

@@ -0,0 +1,80 @@
+import os , sys
+sys.path.append(os.getcwd())
+import pytest
+from ThreadPoolExecutorPlus import *
+import time
+
+def test_feature():
+
+    def some_func(arg):
+        # does some heavy lifting
+        # outputs some results
+        time.sleep(arg)
+        return arg
+
+    def some_error():
+        raise RuntimeError()
+
+    with ThreadPoolExecutor() as executor:
+        assert executor._max_workers >= executor._min_workers
+
+        # test reuseability
+        results = []
+        _range = 10
+        _sec = 0.5
+        for _ in range(_range):
+            results.append(executor.submit(some_func , _sec / 2))
+            time.sleep(_sec)
+            assert len(executor._threads) == min(_ + 1 , executor._min_workers)
+
+        # test return
+        results = list(map(lambda x:x.result() , results))
+        assert results == [_sec / 2] * _range
+
+        # test raise 
+        result = executor.submit(some_error)
+        time.sleep(_sec)
+        assert result.done()
+        assert isinstance(result.exception() , RuntimeError)
+
+        # test opt
+        _range2 = 2
+        _range3 = 10
+        _time2 = 5
+        _sleeptime = 2
+        _interval = 0.01
+        _inaccuracy = 0.5
+        executor.set_daemon_opts(min_workers = _range2 , max_workers = _range3 , keep_alive_time = _time2)
+        assert executor._min_workers == _range2
+        assert executor._max_workers == _range3
+        assert executor._keep_alive_time == _time2
+
+        # test execute
+        results = []
+        start_time = time.time()
+        for _ in range(_range3):
+            results.append(executor.submit(some_func , _sleeptime))
+            time.sleep(_interval)
+
+        list(map(lambda x:x.result() , results))
+        end_time = time.time()
+        assert (_sleeptime - _inaccuracy) <= (end_time - start_time) <= (_sleeptime + _inaccuracy + _interval * _range3)
+
+        # test shrink
+        assert len(executor._threads) == _range3
+        time.sleep(_time2 + _inaccuracy * 2)
+        assert len(executor._threads) == _range2 or len(executor._threads) == (_range2 + 1)
+
+        # test overflow
+        _range4 = _range2 * 2
+        _time3 = 0.5
+        executor.set_daemon_opts(min_workers = _range2 , max_workers = _range2)
+        results = []
+        start_time = time.time()
+        for _ in range(_range4):
+            results.append(executor.submit(some_func , _time3))
+
+        list(map(lambda x:x.result() , results))
+        end_time = time.time()
+        expect_time = (_time3 * _range4) / _range2
+        assert (expect_time - _inaccuracy) <= (end_time - start_time) <= (expect_time + _inaccuracy)