test: rewrite TestGilString to match exact issue #370 reproduction

Rebuilds the gilstring example as a minimal two-extension test: gilstring
(Hello) and simple (Add) are each built into the same workdir and imported
in the same Python process, interleaved over 5000 iterations — matching the
exact script from the issue report. Replaces the single-extension approach
that could not trigger the cross-extension GIL/cgo crash.

Author: b-long

_examples/gilstring/gilstring.go

@@ -3,36 +3,12 @@
 // license that can be found in the LICENSE file.
 
 // Package gilstring is a regression test for the GIL ordering bug (issue #370).
-// It exercises go2py string conversion through functions, struct fields,
-// slice elements, and map values — all of which previously ran C.CString
-// without holding the GIL, causing crashes under repeated calls.
+// It mirrors the exact reproduction from the issue report: a string-returning
+// function called alongside an integer function from a second extension in the
+// same Python process, which triggers crashes under repeated calls.
 package gilstring
 
 import "fmt"
 
-// Add returns the sum of its arguments, mirroring simple.Add from the issue
-// report reproduction script.
-func Add(i, j int) int { return i + j }
-
-// Hello returns a greeting string, mirroring hi.Hello from the issue report
-// reproduction script. Returning a non-trivial string stresses go2py
-// string conversion (C.CString) on every call.
+// Hello returns a greeting string, mirroring hi.Hello from the issue report.
 func Hello(s string) string { return fmt.Sprintf("Hello, %s!", s) }
-
-// Item is a struct with a string field to exercise struct member string getters.
-type Item struct {
-	Label string
-	Count int
-}
-
-// MakeItem returns an Item with the given label.
-func MakeItem(s string) Item { return Item{Label: s, Count: len(s)} }
-
-// GetLabel returns the Label field of an Item.
-func GetLabel(i Item) string { return i.Label }
-
-// StringSlice returns a slice of strings.
-func StringSlice() []string { return []string{"alpha", "beta", "gamma"} }
-
-// StringMap returns a map with string values.
-func StringMap() map[string]string { return map[string]string{"key": "value"} }

_examples/gilstring/test.py

@@ -5,33 +5,14 @@
 ## py2/py3 compat
 from __future__ import print_function
 
-import gilstring
-
-# Regression test for GIL ordering bug (issue #370 / PR #386).
-# Mirrors the exact reproduction script from the issue report:
-#   for _ in range(5000):
-#       Add(2, 2)
-#       Hello('hi')
-# Integer arithmetic (Add) interleaved with string-returning calls (Hello)
-# stresses the go2py C.CString path that previously ran without the GIL held.
-N = 5000
-
-for _ in range(N):
-    assert gilstring.Add(2, 2) == 4
-    assert gilstring.Hello("hi") == "Hello, hi!"
-
-# Struct string fields, slice elements, and map values exercise additional
-# go2py string conversion paths from the same bug.
-for _ in range(N):
-    item = gilstring.MakeItem("hello")
-    assert item.Label == "hello", item.Label
-
-for _ in range(N):
-    s = gilstring.StringSlice()
-    assert s[0] == "alpha", s[0]
-
-for _ in range(N):
-    m = gilstring.StringMap()
-    assert m["key"] == "value", m["key"]
+# Regression test for GIL ordering bug (issue #370).
+# Exact reproduction from the issue report: two separately-built gopy
+# extensions loaded in the same process, with calls interleaved in a loop.
+from gilstring.gilstring import Hello
+from simple.simple import Add
+
+for _ in range(5000):
+    Add(2, 2)
+    Hello('hi')
 
 print("OK")

main_test.go

@@ -785,16 +785,68 @@ OK
 	})
 }
 
+// TestGilString is a regression test for the GIL ordering bug (issue #370).
+// It replicates the exact reproduction from the issue report: two separately-built
+// gopy extensions (gilstring and simple) loaded in the same Python process, with
+// calls interleaved in a loop of 5000 iterations.
 func TestGilString(t *testing.T) {
-	// t.Parallel()
-	path := "_examples/gilstring"
-	testPkg(t, pkg{
-		path:   path,
-		lang:   features[path],
-		cmd:    "build",
-		extras: nil,
-		want:   []byte("OK\n"),
-	})
+	backends := []string{"py3"}
+	for _, be := range backends {
+		vm, ok := testBackends[be]
+		if !ok || vm == "" {
+			t.Logf("Skipped testing backend %s for TestGilString\n", be)
+			continue
+		}
+		t.Run(be, func(t *testing.T) {
+			cwd, _ := os.Getwd()
+
+			workdir, err := os.MkdirTemp("", "gopy-")
+			if err != nil {
+				t.Fatalf("could not create workdir: %v", err)
+			}
+			defer os.RemoveAll(workdir)
+			defer bind.ResetPackages()
+
+			// Build gilstring into workdir.
+			writeGoMod(t, cwd, workdir)
+			if err := run([]string{"build", "-vm=" + vm, "-output=" + workdir, "./_examples/gilstring"}); err != nil {
+				t.Fatalf("error building gilstring: %v", err)
+			}
+			bind.ResetPackages()
+
+			// Build simple into workdir alongside gilstring.
+			writeGoMod(t, cwd, workdir)
+			if err := run([]string{"build", "-vm=" + vm, "-output=" + workdir, "./_examples/simple"}); err != nil {
+				t.Fatalf("error building simple: %v", err)
+			}
+
+			// Copy test.py into workdir.
+			tstSrc := filepath.Join(cwd, "_examples/gilstring/test.py")
+			tstDst := filepath.Join(workdir, "test.py")
+			if err := copyCmd(tstSrc, tstDst); err != nil {
+				t.Fatalf("error copying test.py: %v", err)
+			}
+
+			env := make([]string, len(testEnvironment))
+			copy(env, testEnvironment)
+			env = append(env, fmt.Sprintf("PYTHONPATH=%s", workdir))
+
+			cmd := exec.Command(vm, "./test.py")
+			cmd.Env = env
+			cmd.Dir = workdir
+			cmd.Stdin = os.Stdin
+			buf, err := cmd.CombinedOutput()
+			if err != nil {
+				t.Fatalf("error running python module: err=%v\n%s", err, string(buf))
+			}
+
+			got := strings.Replace(string(buf), "\r\n", "\n", -1)
+			want := "OK\n"
+			if got != want {
+				t.Fatalf("got:\n%s\nwant:\n%s", got, want)
+			}
+		})
+	}
 }
 
 func TestPackagePrefix(t *testing.T) {