Fixed test/core_multifile_actions.py, fix #164

Add test/semaphore.py for testing of JAM_SEMAPHORE.

Closes #543

Add testing of exclusive tests. There are tests that need to run exclusive, i.e. serially, in order to guarantee correct operation. For example the semaphore test that run additional parallel tasks. Without the exclusive operation the OS resources can starve the launching of such parallel sub-tasks.

Author: paolopas

doc/src/history.adoc

@@ -23,6 +23,8 @@
 * Fix crash when reflecting environment variables that happen to have an empty
   value.
   -- _zyk2507_
+* Fix testing of JAM_SEMAPHORE.
+  -- _Paolo Pastori_
 
 == Version 5.4.2
 

test/core_multifile_actions.py

@@ -133,30 +133,6 @@
 ...updated 3 targets...
 """)
 
-# JAM_SEMAPHORE rules:
-#
-# - if two updating actions have targets that share a semaphore,
-#   these actions cannot be run in parallel.
-#
-t.write("file.jam", """\
-actions update
-{
-    echo updating $(<)
-}
-
-targets = x1 x2 ;
-JAM_SEMAPHORE on $(targets) = <s>update_sem ;
-update x1 x2 ;
-""")
-t.run_build_system(["-ffile.jam", "x1"], stdout="""\
-...found 2 targets...
-...updating 2 targets...
-update x1
-updating x1 x2
-
-...updated 2 targets...
-""")
-
 # A target can appear multiple times in an action
 t.write("file.jam", """\
 actions update
@@ -206,6 +182,4 @@
 ...updated 4 targets...
 """)
 
-
-
 t.cleanup()

test/semaphore.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+
+# Copyright 2026 Paolo Pastori
+# Copyright 2026 Rene Ferdinand Rivera Morell
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE.txt or https://www.bfgroup.xyz/b2/LICENSE.txt)
+
+# Test for the JAM_SEMAPHORE variable:
+# verify that actions for targets sharing the same named semaphore
+# cannot be run in parallel.
+
+import sys
+
+
+def touch(fname):
+    with open(fname, "w"):
+        pass
+
+
+def update(mode, sentry, secs, target):
+    from os.path import isfile
+    from time import sleep
+    from os import unlink
+
+    secs = float(secs)
+    other = {"x1": "x2", "x2": "x1"}
+    # Indicate we started.
+    touch(sentry + target)
+    # Check for parallel action to start.
+    while not isfile(sentry + other[target]) and secs > 0:
+        sleep(0.05)
+        secs -= 0.05
+    if mode == "parallel":
+        # Did not see the other action start in time.
+        if secs <= 0:
+            raise TimeoutError
+        # Both actions are now running in parallel.
+        print("PARALLEL UPDATE")
+        sleep(secs)
+    else:
+        # For semaphore mode, having the sentry check not time out means the
+        # parallel action ran, ignoring the semaphore.
+        if secs > 0:
+            raise RuntimeError
+    # Indicate we completed, and create our result target.
+    unlink(sentry + target)
+    touch(target)
+
+
+if len(sys.argv) == 5:
+    # called by jam update action
+    # python semaphore.py <sentry_fname> <sleep_secs> <target_fname>
+    update(*sys.argv[1:])
+    sys.exit()
+
+import os.path
+
+# remember this script absolute pathname
+script = os.path.abspath(__file__)
+
+import BoostBuild
+
+t = BoostBuild.Tester(["-ffile.jam"], pass_toolset=False)
+
+# 1. test parallel execution of update
+t.write(
+    "file.jam",
+    """\
+actions update
+{{
+    "{0}" "{1}" parallel sentry 1 $(<)
+}}
+update x1 ;
+update x2 ;
+DEPENDS all : x1 x2 ;
+""".format(
+        sys.executable, script
+    ),
+)
+
+t.run_build_system(extra_args=["-j2"])
+t.expect_addition("x1")
+t.expect_addition("x2")
+t.expect_output_lines("PARALLEL UPDATE")
+
+t.rm("x1")
+t.rm("x2")
+
+# 2. test parallel execution suppression by JAM_SEMAPHORE
+t.write(
+    "file.jam",
+    """\
+actions update
+{{
+    "{0}" "{1}" semaphore sentry 1 $(<)
+}}
+JAM_SEMAPHORE on x1 x2 = <s>update_sem ;
+update x1 ;
+update x2 ;
+DEPENDS all : x1 x2 ;
+""".format(
+        sys.executable, script
+    ),
+)
+
+expected_output = """\
+...found 3 targets...
+...updating 2 targets...
+update x1
+update x2
+
+...updated 2 targets...
+"""
+
+t.run_build_system(stdout=expected_output, extra_args=["-j2"])
+t.expect_addition("x1")
+t.expect_addition("x2")
+
+t.cleanup()