@@ -71,7 +71,12 @@ def attempt_results(root_dir):
                 # proposing for quarantine.
                 continue
             test_id = "{}.{}".format(classname, name)
-            if case.find("skipped") is None:
+            # gtest writes status="notrun" (e.g. DISABLED_ tests, never run)
+            # with no result element; counting those as observed would claim a
+            # test ran and passed when it never started. Gradle's XML leaves
+            # the status attribute empty and marks skips with <skipped>, so
+            # this only bites gtest reports.
+            if case.find("skipped") is None and case.get("status") != "notrun":
                 observed.add(test_id)
             problem = case.find("failure")
             if problem is None:
@@ -134,6 +139,14 @@ def cmd_count(args):
 # review on this PR against commit 5f01c39c, before the fix here).
 _WORKER_DIED_RE = re.compile(r"finished with non-zero exit value")
 
+# Marker printed by .gitlab/scripts/run-gtest-quarantine.sh when a gtest
+# binary exited non-zero without writing its JUnit XML -- a sanitizer abort
+# (ASan exit 1, TSan exit 66) kills the binary before gtest writes anything,
+# so the abort reaches the classifier only through this log line.
+_ABORTED_WITHOUT_RESULTS_RE = re.compile(
+    r"ABORTED: \S+ exited \d+ without producing test results"
+)
+
 
 def non_test_task_failures(log_path, test_task_pattern):
     """Gradle task names blamed for a failure, other than the test task itself.
@@ -162,14 +175,17 @@ def cut_short_marker(log_path, musl=False):
     caller happened not to pass.
 
     `musl=True` drops _WORKER_DIED_RE from consideration: see its docstring
-    for why that line is ambiguous there. The crash banner alone still
-    catches a genuine musl crash.
+    for why that line is ambiguous there. The crash banner and the gtest
+    abort marker alone still catch a genuine cut-short run.
     """
     if not log_path or not os.path.isfile(log_path):
         return None
-    pattern = _CRASH_RE if musl else re.compile(
-        "{}|{}".format(_CRASH_RE.pattern, _WORKER_DIED_RE.pattern)
-    )
+    if musl:
+        pattern = re.compile("{}|{}".format(_CRASH_RE.pattern, _ABORTED_WITHOUT_RESULTS_RE.pattern))
+    else:
+        pattern = re.compile("{}|{}|{}".format(
+            _CRASH_RE.pattern, _WORKER_DIED_RE.pattern, _ABORTED_WITHOUT_RESULTS_RE.pattern
+        ))
     with open(log_path, errors="replace") as handle:
         for line in handle:
             m = pattern.search(line)
 
@@ -86,6 +86,17 @@
     for suffix in _SYNTHETIC_SUITE_SUFFIXES
 )
 
+# The GitLab sanitizer gtest jobs run native binaries that never link a JDK,
+# so their cells carry no jdk axis and no slow-suite suffix -- three tokens
+# only (the quarantine.txt gtest section documents the shape). Without these
+# in the universe, cells_overlap() fails closed for every gtest glob and two
+# genuinely disjoint entries (asan vs tsan) read as duplicates.
+SYNTHETIC_CELLS += tuple(
+    "glibc-{}-{}".format(config, arch)
+    for config in _SYNTHETIC_CONFIGS
+    for arch in KNOWN_ARCHES
+)
+
 
 def _matches_any_synthetic_cell(globs):
     return any(any(fnmatch.fnmatch(cell, g) for g in globs) for cell in SYNTHETIC_CELLS)
@@ -184,9 +195,31 @@ def covers(entry, test_id):
         # the merge gate for the entire repository from one validate-clean
         # line.
         prefix = pattern[:-1]
-        if not test_id.startswith(prefix):
+        if test_id.startswith(prefix):
+            # The remainder may carry a trailing "/0"-style suffix: Java
+            # writes none, but gtest value-parameterized cases are named
+            # "Case/0", and the Java rule's only real constraint is that the
+            # remainder holds no further class/case separator dot.
+            return "." not in test_id[len(prefix):]
+        # GoogleTest bakes its suite decorations into the XML classname, not
+        # into the entry: value-parameterized suites are "<inst>/<suite>"
+        # (the "/0" lands on the case name), typed suites "<suite>/<typeidx>",
+        # and combinations "<inst>/<suite>/<typeidx>". Reduce the classname to
+        # its bare suite -- drop a trailing all-digits segment, then take the
+        # last "/" segment -- and compare that. Java classnames never contain
+        # "/", so this branch is unreachable for a Java id.
+        cls, _, _ = test_id.rpartition(".")
+        if not cls or "/" not in cls:
             return False
-        return "." not in test_id[len(prefix):]
+        segments = cls.split("/")
+        if len(segments) > 1 and segments[-1].isdigit():
+            segments.pop()
+        if segments[-1] + "." == prefix:
+            return True
+        # A decorated entry ("MyInst/WobblySuite.*") also covers the typed
+        # variants of its own instantiation ("MyInst/WobblySuite/0.case"):
+        # the full undecorated classname must equal the prefix's suite too.
+        return "/".join(segments) + "." == prefix
     return test_id == pattern
 
 
@@ -317,6 +350,12 @@ def complain(line, message):
                 "normalises the report's id to that shape -- drop the '()'"
             ).format(entry["test"]))
 
+        # A decorated gtest suite name ("<inst>/<Suite>.*") in a class-wide
+        # entry is valid and narrower than the bare-suite form: covers()
+        # matches it directly against the decorated classname, muting only
+        # that instantiation. No complaint - just do not claim it matches
+        # nothing.
+
         if _INVOCATION_INDEX_RE.match(entry["test"].rsplit(".", 1)[-1]):
             complain(line, (
                 "test '{}' names an invocation index. @ParameterizedTest and "