Reactivate the importing test.

hpy/devel/__init__.py

@@ -112,6 +112,9 @@ def __bootstrap__():
     ext_filepath = pkg_resources.resource_filename(__name__, {ext_file!r})
     m = load_from_spec(Spec({module_name!r}, ext_filepath))
     m.__file__ = ext_filepath
+    m.__loader__ = __loader__
+    m.__package__ = __package__
+    m.__spec__ = __spec__
     sys.modules[__name__] = m
 
 __bootstrap__()

test/support.py

@@ -216,9 +216,10 @@ def load_module(self, name, mod_filename):
                 "Test module {!r} already present in sys.modules".format(name))
         importlib.invalidate_caches()
         mod_dir = os.path.dirname(mod_filename)
+        sys.path.insert(0, mod_dir)
         try:
-            sys.path.insert(0, mod_dir)
             module = importlib.import_module(name)
+            assert sys.modules[name] is module
         finally:
             # assert that the module import didn't change the sys.path entry
             # that was added above, then remove the entry.
@@ -243,9 +244,34 @@ def make_module(self, main_src, name='mytest', extra_sources=()):
         return self.compiler.make_module(ExtensionTemplate, main_src, name,
                                          extra_sources)
 
-    def should_check_refcount(self):
-        # defaults to True on CPython, but is set to False by e.g. PyPy
-        return sys.implementation.name == 'cpython'
+    def supports_refcounts(self):
+        """ Returns True if the underlying Python implementation supports
+            reference counts.
+
+            By default returns True on CPython and False on other
+            implementations.
+        """
+        return sys.implementation.name == "cpython"
+
+    def supports_ordinary_make_module_imports(self):
+        """ Returns True if `.make_module(...)` loads modules using a
+            standard Python import mechanism (e.g. `importlib.import_module`).
+
+            By default returns True because the base implementation of
+            `.make_module(...)` uses an ordinary import. Sub-classes that
+            override `.make_module(...)` may also want to override this
+            method.
+        """
+        return True
+
+    def supports_sys_executable(self):
+        """ Returns True is `sys.executable` is set to a value that allows
+            a Python equivalent to the current Python to be launched via, e.g.,
+            `subprocess.run(...)`.
+
+            By default returns `True` if sys.executable is set to a true value.
+        """
+        return bool(getattr(sys, "executable", None))
 
 
 # the few functions below are copied and adapted from cffi/ffiplatform.py

test/test_cpy_compat.py

@@ -3,7 +3,7 @@
 
 class TestCPythonCompatibility(HPyTest):
 
-    # One note about the should_check_refcount() in the tests below: on
+    # One note about the supports_refcounts() in the tests below: on
     # CPython, handles are actually implemented as INCREF/DECREF, so we can
     # check e.g. after an HPy_Dup the refcnt is += 1. However, on PyPy they
     # are implemented in a completely different way which is unrelated to the
@@ -35,7 +35,7 @@ def test_frompyobject(self):
         x = mod.f()
         assert x[0] == 1234
         assert len(x) == 2
-        if self.should_check_refcount():
+        if self.supports_refcounts():
             assert x == [1234, +1]
 
     def test_aspyobject(self):
@@ -97,7 +97,7 @@ def test_hpy_close(self):
             @INIT
         """)
         x = mod.f()
-        if self.should_check_refcount():
+        if self.supports_refcounts():
             assert x == -1
 
     def test_hpy_dup(self):
@@ -123,7 +123,7 @@ def test_hpy_dup(self):
             @INIT
         """)
         x = mod.f()
-        if self.should_check_refcount():
+        if self.supports_refcounts():
             assert x == +1
 
     def test_many_handles(self):

test/test_hpyerr.py

@@ -35,7 +35,7 @@ def test_FatalError(self):
             @EXPORT(f)
             @INIT
         """)
-        if not hasattr(sys, "executable"):
+        if not self.supports_sys_executable():
             # if sys.executable is not available (e.g. inside pypy app-level)
             # tests, then skip the rest of this test
             return

test/test_hpytype.py

@@ -192,7 +192,7 @@ def test_HPy_New(self):
     def test_refcount(self):
         import pytest
         import sys
-        if not self.should_check_refcount():
+        if not self.supports_refcounts():
             pytest.skip()
         mod = self.make_module("""
             @DEFINE_PointObject

test/test_importing.py

@@ -1,31 +1,19 @@
-import pytest as pytest_collecting
-
 from .support import HPyTest
 
-# this function should probably goes somewhere into hpy.universal and/or and
-# hpy package and/or an import hook, or whatever. I do not want to think about
-# this now.
-def import_module_properly(mod):
-    raise NotImplementedError("fix me eventually")
-
-# this was moved from support.py, where it did not belong
-## class HPyLoader(ExtensionFileLoader):
-##     def create_module(self, spec):
-##         import hpy.universal
-##         return hpy.universal.load_from_spec(spec)
-
 
 class TestImporting(HPyTest):
 
-    @pytest_collecting.mark.xfail
     def test_importing_attributes(self):
-        import sys
-        modname = 'mytest'
-        so_filename = self.compile_module("""
+        import pytest
+        if not self.supports_ordinary_make_module_imports():
+            pytest.skip()
+        mod = self.make_module("""
             @INIT
-        """, name=modname)
-        mod = import_module_properly(so_filename, modname)
-        assert mod in sys.modules
+        """, name='mytest')
+        assert mod.__name__ == 'mytest'
+        assert mod.__package__ == ''
+        assert mod.__doc__ == 'some test for hpy'
         assert mod.__loader__.name == 'mytest'
         assert mod.__spec__.loader is mod.__loader__
+        assert mod.__spec__.name == 'mytest'
         assert mod.__file__