Test ignored-error storage across translation units

.gitea/workflows/ci.yaml

@@ -37,6 +37,23 @@ jobs:
           fail_on_failure: 'true'
       - run: echo "🍏 This job's status is ${{ job.status }}."
 
+  sanitizer:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+      - name: dependencies
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y cmake gcc moreutils
+      - name: build with AddressSanitizer and UBSan
+        run: |
+          cmake -S . -B build/asan -DAKERR_SANITIZE=address,undefined
+          cmake --build build/asan
+      - name: test with AddressSanitizer and UBSan
+        run: ctest --test-dir build/asan --output-on-failure
+      - run: echo "🍏 This job's status is ${{ job.status }}."
+
   coverage:
     runs-on: ubuntu-latest
     steps:

CMakeLists.txt

@@ -282,6 +282,22 @@ foreach(_test IN LISTS AKERR_TESTS)
     endif()
 endforeach()
 
+# The ignored-error slot is declared in the public header but must have one
+# library definition. Compare its address from two translation units, and
+# compile the consumer-facing test with all ordinary warnings enabled: a
+# header-local TLS definition would both duplicate storage and warn when unused.
+add_executable(test_err_ignore_multitu
+               tests/err_ignore_multitu.c
+               tests/err_ignore_multitu_helper.c)
+target_include_directories(test_err_ignore_multitu
+                           PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/tests)
+target_link_libraries(test_err_ignore_multitu PRIVATE akerror)
+target_compile_options(test_err_ignore_multitu PRIVATE -Wall -Wextra -Werror)
+if(AKERR_THREAD_SAFE)
+    target_link_libraries(test_err_ignore_multitu PRIVATE Threads::Threads)
+endif()
+add_test(NAME err_ignore_multitu COMMAND test_err_ignore_multitu)
+
 # HANDLE_GROUP deliberately enters the next case label. Keep that public macro
 # compiling with the warning enabled, so a future macro edit cannot restore the
 # warning for consumers which adopt -Wextra.
@@ -361,17 +377,8 @@ configure_package_config_file(
     INSTALL_DESTINATION ${akerror_install_cmakedir}
 )
 
-# The SOVERSION is the project major version, so packages with the same major
-# are ABI-compatible and a different major must be rejected.
-write_basic_package_version_file(
-    "${CMAKE_CURRENT_BINARY_DIR}/akerrorConfigVersion.cmake"
-    VERSION ${PROJECT_VERSION}
-    COMPATIBILITY SameMajorVersion
-)
-
 install(FILES
     "${CMAKE_CURRENT_BINARY_DIR}/akerrorConfig.cmake"
-    "${CMAKE_CURRENT_BINARY_DIR}/akerrorConfigVersion.cmake"
     DESTINATION ${akerror_install_cmakedir}
 )
 

scripts/mutation_test.py

@@ -25,6 +25,8 @@ Usage:
     --work DIR          scratch dir for the mutated copy (default: a temp dir)
     --timeout SECONDS   per-suite ctest timeout (default: 120)
     --threshold PCT     exit non-zero if mutation score < PCT (default: 0 = off)
+    --cmake-arg ARG     pass an additional argument to the mutant CMake configure;
+                        repeat for multiple arguments (e.g. -DAKERR_SANITIZE=thread)
     --list              only list the mutants that would be run, then exit
     --keep              keep the scratch working copy on exit (for debugging)
     -j N                (reserved) currently runs sequentially
@@ -199,10 +201,11 @@ def generate_mutants(root, rel_target):
 # --------------------------------------------------------------------------- #
 
 class Runner:
-    def __init__(self, work, timeout):
+    def __init__(self, work, timeout, cmake_args):
         self.work = work
         self.build = os.path.join(work, "build")
         self.timeout = timeout
+        self.cmake_args = cmake_args
 
     def _run(self, cmd, timeout=None):
         return subprocess.run(
@@ -211,7 +214,8 @@ class Runner:
         )
 
     def configure(self):
-        r = self._run(["cmake", "-S", ".", "-B", "build"], timeout=self.timeout)
+        r = self._run(["cmake", "-S", ".", "-B", "build", *self.cmake_args],
+                      timeout=self.timeout)
         return r.returncode == 0, r.stdout
 
     def build_and_test(self):
@@ -307,6 +311,8 @@ def main():
     ap.add_argument("--work", default=None)
     ap.add_argument("--timeout", type=int, default=120)
     ap.add_argument("--threshold", type=float, default=0.0)
+    ap.add_argument("--cmake-arg", action="append", default=[],
+                    help="pass an argument to the mutant CMake configure; repeatable")
     ap.add_argument("--junit", default=None,
                     help="write a JUnit XML report to this path")
     ap.add_argument("--max-mutants", type=int, default=0,
@@ -354,7 +360,7 @@ def main():
     print(f"\nCopying sources to scratch dir: {work}")
     copy_tree(root, work)
 
-    runner = Runner(work, args.timeout)
+    runner = Runner(work, args.timeout, args.cmake_arg)
 
     print("Configuring baseline ...")
     ok, out = runner.configure()

src/error.c

@@ -664,7 +664,7 @@ static akerr_ErrorContext AKERR_NOIGNORE *akerr_reserve_status_range_locked(int
 			"must not overflow int)",
 			count, first_status, owner == NULL ? "(null)" : owner,
 			AKERR_MAX_STATUS_RANGE_OWNER_LENGTH);
-    last_status = first_status + count - 1;
+    last_status = first_status + (count - 1);
 
     for ( int i = 0; i < akerr_status_range_count; i++ ) {
 	if ( first_status <= akerr_status_ranges[i].last &&

tests/MUTATION.md

@@ -32,6 +32,9 @@ scripts/mutation_test.py --target src/error.c --list
 
 # Gate CI: exit non-zero if the score drops below 90%
 scripts/mutation_test.py --threshold 90
+
+# Check concurrency mutants under ThreadSanitizer
+scripts/mutation_test.py --cmake-arg=-DAKERR_SANITIZE=thread
 ```
 
 Via CMake (configures a build first if needed):
@@ -40,8 +43,10 @@ Via CMake (configures a build first if needed):
 cmake --build build --target mutation
 ```
 
-Useful flags: `--timeout SECONDS` (per-suite build+test cap; a mutant that
-hangs is counted as killed), `--keep` (retain the scratch copy for debugging),
+Useful flags: `--cmake-arg ARG` (pass a CMake configure argument to every
+mutant build; repeat it for multiple arguments), `--timeout SECONDS` (per-suite
+build+test cap; a mutant that hangs is counted as killed), `--keep` (retain the
+scratch copy for debugging),
 `--work DIR` (use a specific scratch directory), `--junit FILE` (write a JUnit
 XML report — surviving mutants appear as failing test cases).
 

tests/err_ignore_multitu.c

@@ -0,0 +1,18 @@
+#include "akerror.h"
+#include "err_ignore_multitu.h"
+#include <stdio.h>
+
+int main(void)
+{
+    akerr_ErrorContext **main_address = &__akerr_last_ignored;
+    akerr_ErrorContext **helper_address = akerr_multitu_snapshot_address();
+
+    if ( main_address != helper_address ) {
+	fprintf(stderr,
+		"CHECK FAILED: ignored-error storage differs between translation units\n");
+	return 1;
+    }
+
+    fprintf(stderr, "err_ignore_multitu ok\n");
+    return 0;
+}

tests/err_ignore_multitu.h

@@ -0,0 +1,8 @@
+#ifndef AKERR_TEST_IGNORE_MULTITU_H
+#define AKERR_TEST_IGNORE_MULTITU_H
+
+#include "akerror.h"
+
+akerr_ErrorContext **akerr_multitu_snapshot_address(void);
+
+#endif

tests/err_ignore_multitu_helper.c

@@ -0,0 +1,6 @@
+#include "err_ignore_multitu.h"
+
+akerr_ErrorContext **akerr_multitu_snapshot_address(void)
+{
+    return &__akerr_last_ignored;
+}