Add python standard library tests

Author: thetianshuhuang

python/Makefile

@@ -0,0 +1,23 @@
+WASM_DIR=$(ROOT_WASM_DIR)/python
+DATA_DIR=$(ROOT_DATA_DIR)/python
+
+
+.PHONY: all clean
+all:
+	mkdir -p $(DATA_DIR)
+	cp -r python-tests $(DATA_DIR)/tests
+
+clean:
+	rm -r $(WASM_DIR)
+	rm -r $(DATA_DIR)
+
+
+python-tests:
+
+tests.json: results
+	python filter2.py
+
+results:
+	python filter.py
+	rm -r tempcwd
+	rm tmp.py

python/README.md

@@ -0,0 +1,18 @@
+Python based benchmarks.
+
+
+- hashlib
+- hmac
+- secrets
+- base64
+- gzip
+- bz2
+- lzma
+- zipfile
+- tarfile
+- zlib
+- pickle
+- random
+- statistics
+- re
+- difflib

python/filter.py

@@ -0,0 +1,14 @@
+import subprocess
+import os
+from tqdm import tqdm
+
+PYTHON="./btime ../../runtimes/bin/iwasm -v=0 --dir=. python.iwasm.aot python-tests/{}"
+
+def _run(p):
+    if p.endswith(".py") and p.startswith("test"):
+        with open("results/{}".format(p), 'w') as f:
+            subprocess.call(PYTHON.format(p), shell=True, stdout=f, stderr=f)
+
+
+for p in tqdm(os.listdir("python-tests")):
+    _run(p)

python/filter2.py

@@ -0,0 +1,15 @@
+import os
+import json
+import jsbeautifier
+
+args = []
+for p in sorted(os.listdir("results")):
+    with open(os.path.join("results", p)) as f:
+        contents = f.readline()
+    if not contents.startswith("process exited"):
+        args.append(["data/python/tests/{}".format(p)])
+
+with open("tests.json", 'w') as f:
+    out = json.dumps(args)
+    out = jsbeautifier.beautify(out, jsbeautifier.default_options())
+    f.write(out)

python/python-tests/_test_atexit.py

@@ -0,0 +1,136 @@
+"""
+Tests run by test_atexit in a subprocess since it clears atexit callbacks.
+"""
+import atexit
+import sys
+import unittest
+from test import support
+
+
+class GeneralTest(unittest.TestCase):
+    def setUp(self):
+        atexit._clear()
+
+    def tearDown(self):
+        atexit._clear()
+
+    def assert_raises_unraisable(self, exc_type, func, *args):
+        with support.catch_unraisable_exception() as cm:
+            atexit.register(func, *args)
+            atexit._run_exitfuncs()
+
+            self.assertEqual(cm.unraisable.object, func)
+            self.assertEqual(cm.unraisable.exc_type, exc_type)
+            self.assertEqual(type(cm.unraisable.exc_value), exc_type)
+
+    def test_order(self):
+        # Check that callbacks are called in reverse order with the expected
+        # positional and keyword arguments.
+        calls = []
+
+        def func1(*args, **kwargs):
+            calls.append(('func1', args, kwargs))
+
+        def func2(*args, **kwargs):
+            calls.append(('func2', args, kwargs))
+
+        # be sure args are handled properly
+        atexit.register(func1, 1, 2)
+        atexit.register(func2)
+        atexit.register(func2, 3, key="value")
+        atexit._run_exitfuncs()
+
+        self.assertEqual(calls,
+                         [('func2', (3,), {'key': 'value'}),
+                          ('func2', (), {}),
+                          ('func1', (1, 2), {})])
+
+    def test_badargs(self):
+        def func():
+            pass
+
+        # func() has no parameter, but it's called with 2 parameters
+        self.assert_raises_unraisable(TypeError, func, 1 ,2)
+
+    def test_raise(self):
+        def raise_type_error():
+            raise TypeError
+
+        self.assert_raises_unraisable(TypeError, raise_type_error)
+
+    def test_raise_unnormalized(self):
+        # bpo-10756: Make sure that an unnormalized exception is handled
+        # properly.
+        def div_zero():
+            1 / 0
+
+        self.assert_raises_unraisable(ZeroDivisionError, div_zero)
+
+    def test_exit(self):
+        self.assert_raises_unraisable(SystemExit, sys.exit)
+
+    def test_stress(self):
+        a = [0]
+        def inc():
+            a[0] += 1
+
+        for i in range(128):
+            atexit.register(inc)
+        atexit._run_exitfuncs()
+
+        self.assertEqual(a[0], 128)
+
+    def test_clear(self):
+        a = [0]
+        def inc():
+            a[0] += 1
+
+        atexit.register(inc)
+        atexit._clear()
+        atexit._run_exitfuncs()
+
+        self.assertEqual(a[0], 0)
+
+    def test_unregister(self):
+        a = [0]
+        def inc():
+            a[0] += 1
+        def dec():
+            a[0] -= 1
+
+        for i in range(4):
+            atexit.register(inc)
+        atexit.register(dec)
+        atexit.unregister(inc)
+        atexit._run_exitfuncs()
+
+        self.assertEqual(a[0], -1)
+
+    def test_bound_methods(self):
+        l = []
+        atexit.register(l.append, 5)
+        atexit._run_exitfuncs()
+        self.assertEqual(l, [5])
+
+        atexit.unregister(l.append)
+        atexit._run_exitfuncs()
+        self.assertEqual(l, [5])
+
+    def test_atexit_with_unregistered_function(self):
+        # See bpo-46025 for more info
+        def func():
+            atexit.unregister(func)
+            1/0
+        atexit.register(func)
+        try:
+            with support.catch_unraisable_exception() as cm:
+                atexit._run_exitfuncs()
+                self.assertEqual(cm.unraisable.object, func)
+                self.assertEqual(cm.unraisable.exc_type, ZeroDivisionError)
+                self.assertEqual(type(cm.unraisable.exc_value), ZeroDivisionError)
+        finally:
+            atexit.unregister(func)
+
+
+if __name__ == "__main__":
+    unittest.main()