Add tests for whence.

python · ericsnowcurrently · Apr 11, 2024 · Apr 8, 2024 · Apr 5, 2024 · Apr 5, 2024
commit 175080c83444dc3515602b2a9bddce788a213442
@@ -16,7 +16,7 @@
 )
 from .utils import (
     _captured_script, _run_output, _running, TestBase,
-    requires__testinternalcapi, _testinternalcapi,
+    requires_test_modules, _testinternalcapi,
 )
 
 
@@ -163,7 +163,7 @@ def test_idempotent(self):
             id2 = id(interp)
             self.assertNotEqual(id1, id2)
 
-    @requires__testinternalcapi
+    @requires_test_modules
     def test_created_with_capi(self):
         last = 0
         for id, *_ in _interpreters.list_all():
@@ -668,7 +668,7 @@ def test_running(self):
                 interp.prepare_main({'spam': False})
         interp.exec('assert spam is True')
 
-    @requires__testinternalcapi
+    @requires_test_modules
     def test_created_with_capi(self):
         with self.interpreter_from_capi() as interpid:
             interp = interpreters.Interpreter(interpid)
@@ -1378,7 +1378,7 @@ def test_create(self):
             with self.assertRaises(ValueError):
                 _interpreters.create(orig)
 
-    @requires__testinternalcapi
+    @requires_test_modules
     def test_destroy(self):
         with self.subTest('from _interpreters'):
             interpid = _interpreters.create()
@@ -1439,6 +1439,50 @@ def test_get_config(self):
                 config = _interpreters.get_config(interpid)
             self.assert_ns_equal(config, orig)
 
+    @requires_test_modules
+    def test_whence(self):
+        with self.subTest('main'):
+            interpid, *_ = _interpreters.get_main()
+            whence = _interpreters.whence(interpid)
+            self.assertEqual(whence, _interpreters.WHENCE_RUNTIME)
+
+        with self.subTest('stdlib'):
+            interpid = _interpreters.create()
+            whence = _interpreters.whence(interpid)
+            self.assertEqual(whence, _interpreters.WHENCE_XI)
+
+        for orig, name in {
+            # XXX Also check WHENCE_UNKNOWN.
+            _interpreters.WHENCE_LEGACY_CAPI: 'legacy C-API',
+            _interpreters.WHENCE_CAPI: 'C-API',
+            _interpreters.WHENCE_XI: 'cross-interpreter C-API',
+        }.items():
+            with self.subTest(f'from C-API ({orig}: {name})'):
+                with self.interpreter_from_capi(whence=orig) as interpid:
+                    whence = _interpreters.whence(interpid)
+                self.assertEqual(whence, orig)
+
+        with self.subTest('from C-API, running'):
+            text = self.run_temp_from_capi(dedent(f"""
+                import {_interpreters.__name__} as _interpreters
+                interpid, *_ = _interpreters.get_current()
+                print(_interpreters.whence(interpid))
+                """),
+                config=True)
+            whence = eval(text)
+            self.assertEqual(whence, _interpreters.WHENCE_CAPI)
+
+        with self.subTest('from legacy C-API, running'):
+            ...
+            text = self.run_temp_from_capi(dedent(f"""
+                import {_interpreters.__name__} as _interpreters
+                interpid, *_ = _interpreters.get_current()
+                print(_interpreters.whence(interpid))
+                """),
+                config=False)
+            whence = eval(text)
+            self.assertEqual(whence, _interpreters.WHENCE_LEGACY_CAPI)
+
     def test_is_running(self):
         with self.subTest('main'):
             interpid, *_ = _interpreters.get_main()

@@ -26,12 +26,12 @@
 
 try:
     import _testinternalcapi
+    import _testcapi
 except ImportError:
     _testinternalcapi = None
-else:
-    run_in_interpreter = _testinternalcapi.run_in_subinterp_with_config
+    _testcapi = None
 
-def requires__testinternalcapi(func):
+def requires_test_modules(func):
     return unittest.skipIf(_testinternalcapi is None, "test requires _testinternalcapi module")(func)
 
 
@@ -509,12 +509,31 @@ def run_and_capture(self, interp, script):
         else:
             return text
 
-    @requires__testinternalcapi
+    @requires_test_modules
     @contextlib.contextmanager
-    def interpreter_from_capi(self, config='legacy'):
-        if isinstance(config, str):
+    def interpreter_from_capi(self, config=None, whence=None):
+        if config is False:
+            if whence is None:
+                whence = _interpreters.WHENCE_LEGACY_CAPI
+            else:
+                assert whence in (_interpreters.WHENCE_LEGACY_CAPI,
+                                  _interpreters.WHENCE_UNKNOWN), repr(whence)
+            config = None
+        elif config is True:
+            config = _interpreters.new_config('default')
+        elif config is None:
+            if whence not in (
+                _interpreters.WHENCE_LEGACY_CAPI,
+                _interpreters.WHENCE_UNKNOWN,
+            ):
+                config = _interpreters.new_config('legacy')
+        elif isinstance(config, str):
             config = _interpreters.new_config(config)
-        interpid = _testinternalcapi.create_interpreter()
+
+        if whence is None:
+            whence = _interpreters.WHENCE_XI
+
+        interpid = _testinternalcapi.create_interpreter(config, whence=whence)
         try:
             yield interpid
         finally:
@@ -535,7 +554,7 @@ def capturing(self, script):
         with capturing:
             yield wrapped, capturing.final(force=True)
 
-    @requires__testinternalcapi
+    @requires_test_modules
     def run_from_capi(self, interpid, script, *, main=False):
         with self.capturing(script) as (wrapped, results):
             rc = _testinternalcapi.exec_interpreter(interpid, wrapped, main=main)
@@ -622,7 +641,7 @@ def exec_interp(script):
         with self._running(run_interp, exec_interp):
             yield
 
-    @requires__testinternalcapi
+    @requires_test_modules
     @contextlib.contextmanager
     def running_from_capi(self, interpid, *, main=False):
         def run_interp(script):
@@ -634,12 +653,20 @@ def exec_interp(script):
         with self._running(run_interp, exec_interp):
             yield
 
-    @requires__testinternalcapi
+    @requires_test_modules
     def run_temp_from_capi(self, script, config='legacy'):
-        if isinstance(config, str):
-            config = _interpreters.new_config(config)
+        if config is False:
+            # Force using Py_NewInterpreter().
+            run_in_interp = (lambda s, c: _testcapi.run_in_subinterp(s))
+            config = None
+        else:
+            run_in_interp = _testinternalcapi.run_in_subinterp_with_config
+            if config is True:
+                config = 'default'
+            if isinstance(config, str):
+                config = _interpreters.new_config(config)
         with self.capturing(script) as (wrapped, results):
-            rc = run_in_interpreter(wrapped, config)
+            rc = run_in_interp(wrapped, config)
             assert rc == 0, rc
         results.raise_if_failed()
         return results.stdout
diff --git a/Modules/_testinternalcapi.c b/Modules/_testinternalcapi.c
@@ -1443,17 +1443,20 @@ create_interpreter(PyObject *self, PyObject *args, PyObject *kwargs)
     PyObject *configobj = NULL;
     long whence = _PyInterpreterState_WHENCE_XI;
     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
-                                     "|O$p:create_interpreter", kwlist,
+                                     "|O$l:create_interpreter", kwlist,
                                      &configobj, &whence))
     {
         return NULL;
     }
+    if (configobj == Py_None) {
+        configobj = NULL;
+    }
 
     // Resolve the config.
     PyInterpreterConfig *config = NULL;
     PyInterpreterConfig _config;
     if (whence == _PyInterpreterState_WHENCE_UNKNOWN
-            || whence == _PyInterpreterState_WHENCE_UNKNOWN)
+            || whence == _PyInterpreterState_WHENCE_LEGACY_CAPI)
     {
         if (configobj != NULL) {
             PyErr_SetString(PyExc_ValueError, "got unexpected config");

@@ -1868,8 +1868,8 @@ void
 _PyXI_EndInterpreter(PyInterpreterState *interp,
                      PyThreadState *tstate, PyThreadState **p_save_tstate)
 {
-    PyThreadState *cur_tstate = PyThreadState_GET();
     PyThreadState *save_tstate = NULL;
+    PyThreadState *cur_tstate = PyThreadState_GET();
     if (tstate == NULL) {
         if (PyThreadState_GetInterpreter(cur_tstate) == interp) {
             tstate = cur_tstate;
@@ -1889,7 +1889,18 @@ _PyXI_EndInterpreter(PyInterpreterState *interp,
         }
     }
 
-    Py_EndInterpreter(tstate);
+    long whence = _PyInterpreterState_GetWhence(interp);
+    assert(whence != _PyInterpreterState_WHENCE_RUNTIME);
+    if (whence == _PyInterpreterState_WHENCE_UNKNOWN) {
+        assert(!interp->_ready);
+        PyThreadState *tstate = PyThreadState_New(interp);
+        save_tstate = PyThreadState_Swap(tstate);
+        _PyInterpreterState_Clear(tstate);
+        PyInterpreterState_Delete(interp);
+    }
+    else {
+        Py_EndInterpreter(tstate);
+    }
 
     if (p_save_tstate != NULL) {
         save_tstate = *p_save_tstate;