add simple downstream test for running python in from library

Author: timfel

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/control/TopLevelExceptionHandler.java

@@ -154,7 +154,7 @@ private void printExc(PException e) {
     }
 
     private void handleSystemExit(PException e) {
-        if (PythonOptions.getOption(context, PythonOptions.PythonInspectFlag) && !getSourceSection().getSource().isInteractive()) {
+        if (PythonOptions.getOption(context, PythonOptions.InspectFlag) && !getSourceSection().getSource().isInteractive()) {
             // Don't exit if -i flag was given and we're not yet running interactively
             return;
         }

mx.graalpython/mx_graalpython.py

@@ -384,6 +384,10 @@ def graalpython_gate_runner(args, tasks):
             if success not in out.data:
                 mx.abort('Output from generated SVM image "' + svm_image + '" did not match success pattern:\n' + success)
 
+    with Task('GraalPython GraalVM shared-library build', tasks, tags=[GraalPythonTags.downstream, GraalPythonTags.graalvm]) as task:
+        if task:
+            run_shared_lib_test()
+
     for name, iterations in sorted(python_test_benchmarks.iteritems()):
         with Task('PythonBenchmarksTest:' + name, tasks, tags=[GraalPythonTags.benchmarks]) as task:
             if task:
@@ -393,6 +397,151 @@ def graalpython_gate_runner(args, tasks):
 mx_gate.add_gate_runner(_suite, graalpython_gate_runner)
 
 
+def run_shared_lib_test(args=None):
+    mx.run_mx(
+        ["--dynamicimports", "/substratevm,/vm",
+         "build", "--force-deprecation-as-warning", "--dependencies",
+         "GRAAL_MANAGEMENT,POLYGLOT_NATIVE_API_HEADERS,libpolyglot.so.image"],
+        nonZeroIsFatal=True
+    )
+    vmdir = os.path.join(mx.suite("truffle").dir, "..", "vm")
+    svm_lib_path = os.path.join(vmdir, "mxbuild", "-".join([mx.get_os(), mx.get_arch()]), "libpolyglot.so.image")
+    fd = name = progname = None
+    try:
+        fd, name = tempfile.mkstemp(suffix='.c')
+        os.write(fd, """
+        #include "stdio.h"
+        #include "polyglot_api.h"
+
+        #define assert_ok(msg, f) { if (!(f)) { \\
+             const poly_extended_error_info* error_info; \\
+             poly_get_last_error_info(isolate_thread, &error_info); \\
+             fprintf(stderr, "%s\\n", error_info->error_message); \\
+             return fprintf(stderr, "%s\\n", msg); } } while (0)
+
+        poly_isolate global_isolate;
+        poly_thread isolate_thread;
+        poly_engine engine;
+        poly_context context;
+
+        static poly_status create_context() {
+            poly_status status;
+
+            if (poly_attach_thread(global_isolate, &isolate_thread)) {
+                return poly_generic_failure;
+            }
+
+            poly_engine_builder engine_builder;
+            status = poly_create_engine_builder(isolate_thread, &engine_builder);
+            if (status != poly_ok) {
+                return status;
+            }
+            status = poly_engine_builder_build(isolate_thread, engine_builder, &engine);
+            if (status != poly_ok) {
+                return status;
+            }
+            poly_context_builder builder;
+            status = poly_create_context_builder(isolate_thread, NULL, 0, &builder);
+            if (status != poly_ok) {
+                return status;
+            }
+            status = poly_context_builder_engine(isolate_thread, builder, engine);
+            if (status != poly_ok) {
+                return status;
+            }
+            status = poly_context_builder_build(isolate_thread, builder, &context);
+            if (status != poly_ok) {
+                return status;
+            }
+
+            poly_destroy_handle(isolate_thread, engine_builder);
+            poly_destroy_handle(isolate_thread, builder);
+
+            return poly_ok;
+        }
+
+        static poly_status tear_down_context() {
+            poly_status status = poly_context_close(isolate_thread, context, true);
+            if (status != poly_ok) {
+                return status;
+            }
+
+            status = poly_destroy_handle(isolate_thread, context);
+            if (status != poly_ok) {
+                return status;
+            }
+
+            status = poly_engine_close(isolate_thread, engine, true);
+            if (status != poly_ok) {
+                return status;
+            }
+
+            status = poly_destroy_handle(isolate_thread, engine);
+            if (status != poly_ok) {
+                return status;
+            }
+
+            if (poly_detach_thread(isolate_thread)) {
+                return poly_ok;
+            }
+
+            return poly_ok;
+        }
+
+        static int test_basic_python_function() {
+            assert_ok("Context creation failed.", create_context() == poly_ok);
+
+            poly_value func;
+            assert_ok("function eval failed", poly_context_eval(isolate_thread, context, "python", "test_func", "def test_func(x):\\n  return x * x\\ntest_func", &func) == poly_ok);
+            int32_t arg_value = 42;
+            poly_value primitive_object;
+            assert_ok("create argument failed", poly_create_int32(isolate_thread, context, arg_value, &primitive_object) == poly_ok);
+            poly_value arg[1] = {primitive_object};
+            poly_value value;
+            assert_ok("invocation was unsuccessful", poly_value_execute(isolate_thread, func, arg, 1, &value) == poly_ok);
+
+            int32_t result_value;
+            poly_value_as_int32(isolate_thread, value, &result_value);
+
+            assert_ok("primitive free failed", poly_destroy_handle(isolate_thread, primitive_object) == poly_ok);
+            assert_ok("value free failed", poly_destroy_handle(isolate_thread, value) == poly_ok);
+            assert_ok("value computation was incorrect", result_value == 42 * 42);
+            assert_ok("func free failed", poly_destroy_handle(isolate_thread, func) == poly_ok);
+            assert_ok("Context tear down failed.", tear_down_context() == poly_ok);
+            return 0;
+        }
+
+        int32_t main(int32_t argc, char **argv) {
+            poly_isolate_params isolate_params = {};
+            if (poly_create_isolate(&isolate_params, &global_isolate)) {
+                return 1;
+            }
+            if (test_basic_python_function()) {
+                return 0;
+            } else {
+                return 1;
+            }
+        }
+        """)
+        os.close(fd)
+        progname = tempfile.mktemp()
+        mx.run(["cc", "-I%s" % svm_lib_path, "-L%s" % svm_lib_path, name, "-o%s" % progname, "-lpolyglot"], nonZeroIsFatal=True)
+        mx.run([progname], env={"LD_LIBRARY_PATH": svm_lib_path})
+    finally:
+        try:
+            os.unlink(progname)
+        except:
+            pass
+        try:
+            os.close(fd)
+        except:
+            pass
+        try:
+            os.unlink(name)
+        except:
+            pass
+
+
 class ArchiveProject(mx.ArchivableProject):
     def __init__(self, suite, name, deps, workingSets, theLicense, **args):
         super(ArchiveProject, self).__init__(suite, name, deps, workingSets, theLicense)
@@ -595,5 +744,6 @@ def python_checkcopyrights(args):
     'delete-graalpython-if-testdownstream': [delete_self_if_testdownstream, ''],
     'python-checkcopyrights': [python_checkcopyrights, 'Make sure code files have copyright notices'],
     'punittest': [punittest, ''],
-    'nativebuild': [nativebuild, '']
+    'nativebuild': [nativebuild, ''],
+    'python-so-test': [run_shared_lib_test, ''],
 })