Fix Native Python incompatibilities in tests

Summary:
Need to actually import it in some of these tests that use subprocesses.

Rewrite the one native test that tries to dlopen _cinderx.so, that doesn't work
with Native Python as there is no _cinderx.so.

Reviewed By: DinoV

Differential Revision: D86524535

fbshipit-source-id: 7f3c18e4fd4dcc652358ad55f2224aacdebf8ae3

Author: alexmalyshev

cinderx/PythonLib/test_cinderx/test_cinderjit.py

@@ -1636,8 +1636,7 @@ def junk{i}(j):
             def run_test(
                 asserts_func: Callable[[list[str]], None], params: list[str]
             ) -> None:
-                # Disable the import of the site module with `-S` so Imports Monitor isn't enabled
-                args = [sys.executable, "-S"]
+                args = [sys.executable]
                 args.extend(params)
                 args.append("mod.py")
                 proc = subprocess.run(
@@ -1665,8 +1664,8 @@ def onek_asserts(actual_stdout: list[str]) -> None:
                 used_size = int(actual_stdout[1].split(" ")[1])
                 self.assertGreater(used_size, 1024)
                 # This is a bit fragile because it depends on what the initial 'zeroth'
-                # allocation is; we assume < 200K.
-                self.assertLess(used_size, 1024 * 200)
+                # allocation is; we assume < 600K.
+                self.assertLess(used_size, 1024 * 600)
 
             # Run the zero-assert tests with JitAuto=1000 to test "normal" behavior
             # where we compile some code but don't have any limits to trip.

cinderx/PythonLib/test_cinderx/test_compiler/test_static/native.py

@@ -1,8 +1,6 @@
 # Copyright (c) Meta Platforms, Inc. and affiliates.
-from .common import StaticTestBase
 
-import xxclassloader  # usort: skip
-import _cinderx
+from .common import StaticTestBase
 
 
 class NativeDecoratorTests(StaticTestBase):
@@ -256,48 +254,26 @@ def invoke_abs(i: int) -> int:
 
     def test_invoke_native_fn_multiple_args(self) -> None:
         codestr = f"""
-        from __static__ import native, int64, box
-        from typing import Final
-
-        LIB_NAME: Final[str] = "{_cinderx.__file__}"
-
-        @native(LIB_NAME)
-        def native_add(a: int64, b: int64) -> int64:
-            pass
-
-        def invoke_add(i: int, j: int) -> int:
-            k: int64 = int64(i)
-            l: int64 = int64(j)
-            return box(native_add(k, l))
-        """
-
-        with self.in_strict_module(codestr) as mod:
-            self.assertEqual(mod.invoke_add(6, 5), 11)
-            self.assertEqual(mod.invoke_add(-1, 5), 4)
-            self.assertEqual(mod.invoke_add(-1, -5), -6)
-
-    def test_invoke_native_fn_heterogenous_args(self) -> None:
-        codestr = f"""
-        from __static__ import native, int64, uint8, box
+        from __static__ import native, int32, box
         from typing import Final
 
-        LIB_NAME: Final[str] = "{_cinderx.__file__}"
+        LIB_NAME: Final[str] = "libc.so.6"
 
         @native(LIB_NAME)
-        def native_sub(a: int64, b: uint8) -> int64:
+        def div(a: int32, b: int32) -> int32:
+            # This returns a div_t but that's okay as the ABI will put the
+            # numerator in RAX.
+            #
+            # There are no other C stdlib functions that take multiple arguments
+            # that are only integers.  Everything else takes pointers or
+            # doubles, and doubles aren't supported yet, TODO(T130985738).
             pass
 
-        def invoke_sub(i: int, j: int) -> int:
-            k: int64 = int64(i)
-            l: uint8 = uint8(j)
-            return box(native_sub(k, l))
+        def invoke_div(i: int32, j: int32) -> int:
+            k: int32 = int32(i)
+            l: int32 = int32(j)
+            return box(div(k, l))
         """
 
         with self.in_strict_module(codestr) as mod:
-            self.assertEqual(mod.invoke_sub(6, 5), 1)
-            self.assertEqual(mod.invoke_sub(-1, 5), -6)
-            self.assertEqual(mod.invoke_sub(-1, 0), -1)
-
-            with self.assertRaisesRegex(OverflowError, "int overflow"):
-                # -1 can't be represented in uint8
-                mod.invoke_sub(0, -1)
+            self.assertEqual(mod.invoke_div(15, 3), 5)

cinderx/PythonLib/test_cinderx/test_enabling_parallel_gc.py

@@ -18,6 +18,8 @@
 class TestEnablingParallelGc(unittest.TestCase):
     def test_gc_settings(self) -> None:
         codestr = textwrap.dedent("""
+            import cinderx
+
             import gc
             def g():
                 return gc.get_threshold()

cinderx/PythonLib/test_cinderx/test_jitlist.py

@@ -253,7 +253,9 @@ def test_precompile_all_bad_args(self) -> None:
             cinderx.jit.precompile_all(workers=200000)
 
     def test_fail_on_parse_error_startup(self) -> None:
-        code = 'print("Hello world!")'
+        code = """if 1:
+        import cinderx.jit
+        print("Hello world!")"""
         jitlist = "OH NO"
         with tempfile.TemporaryDirectory() as tmp:
             dirpath = Path(tmp)