tests: rework the test for freetype-py

Rework the test for `freetype-py` to accommodate scenarios where the
`freetype` shared library is not originally bundled with the package.

In such cases, `freetype-py` uses `ctypes.util.find_library()` to
discover and load system copy of the `freetype` shared library. This
is also picked up by PyInstaller's `ctypes` analysis; the said
shared library is collected into top-level application directory, and
successfully loaded at run-time.

But as far as the test goes, on Linux (and other POSIX systems except for
macOS), we cannot use the `freetype.FT_Library_filename` variable to
verify that the bundled copy from top-level application is used, because
`ctypes.util.find_library()` does not resolve full paths. Therefore, we
need the test to use `psutil` to dump the list of loaded shared libraries
once `freetype` is imported.

On the other hand, the required `psutil.memory_maps()` function is
unavailable on macOS. But thankfully, `ctypes.util.find_library()` on
macOS does resolve full library paths, so the original test based on
`freetype.FT_Library_filename` should work with both PyPI wheel
(package-bundled shared library) and Homebrew-installed `freetype-py`
(shared library collected from Homebrew library directory).

So in the end, we need two test variants; the original one for macOS
and a new `psutil`-based one for all other POSIX platforms. On Windows,
we can use either variant, as `psutil.memory_maps()` is available and
`ctypes.util.find_library()` resolves full library paths.

Author: rokm

tests/test_libraries.py

@@ -20,7 +20,7 @@
     get_module_attribute,
     is_module_satisfies,
 )
-from PyInstaller.utils.tests import importorskip, requires, xfail
+from PyInstaller.utils.tests import importorskip, importable, requires, xfail
 
 
 @importorskip('fiona')
@@ -1930,31 +1930,71 @@ def test_z3c_rml_rml2pdf(pyi_builder):
     """)
 
 
+# Ensure that the freetype shared library is bundled with the frozen application, and that it is being used (as opposed
+# to the system copy).
 @importorskip('freetype')
-def test_pyi_freetype(pyi_builder):
-    pyi_builder.test_source("""
-        import sys
-        import pathlib
+def test_freetype(pyi_builder):
+    if (is_darwin or is_win) or not importable('psutil'):
+        # This is the original variant of the test, which we need to keep around due to the fact that on macOS, `psutil`
+        # does not provide the `memory_maps()` function, so we cannot use it to inspect loaded shared libraries.
+        # Therefore, we inspect the library path as indicated by the `freetype.FT_Library_filename` variable; even if
+        # `ctypes.util.find_library()` fallback were used by `freetype` to load the shared library (for example, when
+        # using Homebrew-installed `freetype-py` instead of PyPI wheels), on macOS, that function resolves full library
+        # path (in contrast to other POSIX platforms, where it resolves only the basename).
+        #
+        # On Windows, we can use either variant of the test, as `psutil.memory_maps()` is available, and
+        # `ctypes.util.find_library()` resolves full library paths.
+        pyi_builder.test_source("""
+            import sys
+            import pathlib
 
-        import freetype
+            import freetype
 
-        # Ensure that the freetype shared library is bundled with the frozen application; otherwise, freetype might be
-        # using system-wide library.
+            # First, check that freetype.FT_Library_filename is an absolute path; otherwise, it is likely using
+            # basename-only ctypes fallback.
+            ft_library_file = pathlib.Path(freetype.FT_Library_filename)
+            print(f"FT library file (original): {ft_library_file}", file=sys.stderr)
+            assert ft_library_file.is_absolute(), "FT library file is not an absolute path!"
 
-        # First, check that freetype.FT_Library_filename is an absolute path; otherwise, it is likely using
-        # basename-only ctypes fallback.
-        ft_library_file = pathlib.Path(freetype.FT_Library_filename)
-        print(f"FT library file (original): {ft_library_file}", file=sys.stderr)
-        assert ft_library_file.is_absolute(), "FT library file is not an absolute path!"
+            # Check that fully-resolved freetype.FT_Library_filename is anchored in fully-resolved frozen application
+            # directory.
+            app_dir = pathlib.Path(__file__).resolve().parent
+            print(f"Application directory: {app_dir}", file=sys.stderr)
+            ft_library_path = pathlib.Path(ft_library_file).resolve()
+            print(f"FT library file (resolved): {ft_library_path}", file=sys.stderr)
+            assert app_dir in ft_library_path.parents, "FT library is not bundled with frozen application!"
+        """)
+    else:
+        # POSIX variant of the test that uses `psutil` for inspecting loaded shared libraries.
+        pyi_builder.test_source("""
+            import os
+            import pathlib
+            import sys
 
-        # Check that fully-resolved freetype.FT_Library_filename is anchored in fully-resolved frozen application
-        # directory.
-        app_dir = pathlib.Path(__file__).resolve().parent
-        print(f"Application directory: {app_dir}", file=sys.stderr)
-        ft_library_path = pathlib.Path(ft_library_file).resolve()
-        print(f"FT library file (resolved): {ft_library_path}", file=sys.stderr)
-        assert app_dir in ft_library_path.parents, "FT library is not bundled with frozen application!"
-    """)
+            import psutil
+
+            proc = psutil.Process(os.getpid())
+
+            libs_before = [pathlib.Path(lib.path) for lib in proc.memory_maps()]
+
+            print("Importing freetype...", file=sys.stderr)
+            import freetype
+
+            libs_after = [pathlib.Path(lib.path) for lib in proc.memory_maps()]
+
+            libs_new = sorted(set(libs_after) - set(libs_before))
+            print("Shared libraries loaded during freetype import:", file=sys.stderr)
+            for lib in libs_new:
+                print(f" * {lib}", file=sys.stderr)
+
+            libs_freetype = [lib for lib in libs_new if 'freetype' in lib.name]
+            assert len(libs_freetype) >= 1, "No library with 'freetype' in name found!"
+
+            app_dir = pathlib.Path(__file__).parent.resolve()
+            for lib_path in libs_freetype:
+                lib_path = lib_path.resolve()
+                assert app_dir in lib_path.parents, f"{lib_path} is not rooted in top-level application directory!"
+        """)
 
 
 @importorskip('vaderSentiment')