@@ -123,15 +123,18 @@ without instrumentation are listed explicitly, never assumed covered. These diag
 introduce a fabricated baseline, change the raw denominator, or replace regression protection.
 
 Classification excludes integration-test/benchmark directories and Rust items explicitly marked
-`#[cfg(test)]` or `#[test]`, including inline modules and test-only helper functions. It masks
+`#[cfg(test)]` or `#[test]`, including inline modules and test-only helper functions. Nested
+`all`/`any` predicates are also excluded when they require `test`: `all(test, unix)` is test-only,
+but `any(test, unix)` is not. It masks
 strings, raw/byte strings, characters, and nested comments before matching item boundaries.
-Helpers outside those boundaries and complex conditional attributes remain conservatively in the
+Helpers outside those boundaries and unsupported conditional predicates remain conservatively in the
 production category; this is a source-focused diagnostic, not full Rust conditional-compilation
 analysis. Invalid/missing LCOV, missing source, inconsistent hit summaries, and source-line
 mismatches fail the reporting step. LLVM summaries can include more entries in `LF`/`LH`
 than the unique `DA` source lines (observed in real Windows exports). That deficit is reported
-per file (including unmatched summary hits) and conservatively retained as uncovered production,
-never dropped from the denominator or silently assigned coverage.
+per file (including unmatched summary hits) and conservatively retained as uncovered production
+in mixed source files, or uncovered tests in integration-test/benchmark files. It is never dropped
+from the denominator or silently assigned coverage.
 Changed lines without `DA` records are listed separately in JSON, including non-executable syntax;
 they are not silently considered covered.
 Native macOS also demonstrates `LH` below the number of positive unique `DA` entries. Reports
 
@@ -149,10 +149,37 @@ def code_mask(source: str) -> str:
     return ''.join(chars)
 
 
+def cfg_requires_test(expression: str) -> bool:
+    expression = expression.strip()
+    if expression == 'test':
+        return True
+    group = re.fullmatch(r'(all|any)\s*\((.*)\)', expression, re.DOTALL)
+    if not group:
+        return False
+    arguments = []
+    depth = start = 0
+    for index, char in enumerate(group[2]):
+        depth += (char == '(') - (char == ')')
+        if depth < 0:
+            raise SnapshotError('Unbalanced Rust cfg predicate')
+        if char == ',' and depth == 0:
+            arguments.append(group[2][start:index])
+            start = index + 1
+    if depth:
+        raise SnapshotError('Unbalanced Rust cfg predicate')
+    final = group[2][start:]
+    if final.strip():
+        arguments.append(final)
+    required = [cfg_requires_test(argument) for argument in arguments]
+    return any(required) if group[1] == 'all' else bool(required) and all(required)
+
+
 def test_lines(source: str) -> set[int]:
     masked = code_mask(source)
     excluded: set[int] = set()
-    for match in re.finditer(r'#\s*\[\s*(?:cfg\s*\(\s*test\s*\)|test)\s*\]', masked):
+    for match in re.finditer(r'#\s*\[\s*(?:cfg\s*\((?P<cfg>[^]]*)\)|test)\s*\]', masked):
+        if match['cfg'] is not None and not cfg_requires_test(match['cfg']):
+            continue
         start = match.start()
         end = match.end()
         # Other attributes belong to this same item, not its body.
@@ -226,20 +253,21 @@ def summarize(root: Path, records: dict[str, SourceCoverage], changed: dict[str,
         if any(n > len(source.splitlines()) for n in lines):
             raise SnapshotError(f'LCOV source revision mismatch: {name}')
         parts = Path(name).parts
-        excluded = set(lines) if 'tests' in parts or 'benches' in parts else test_lines(source)
+        test_only = 'tests' in parts or 'benches' in parts
+        excluded = set(lines) if test_only else test_lines(source)
         production = {n: count for n, count in lines.items() if n not in excluded}
         tests = {n: count for n, count in lines.items() if n in excluded}
         edits = production.keys() & changed.get(name, set())
         uncertainty = record.unmapped + record.summary_hit_shortfall - record.unmapped_hits
         files.append({
-            'path': name, 'production_found': len(production) + record.unmapped,
+            'path': name, 'production_found': len(production) + (0 if test_only else record.unmapped),
             'unmapped_summary_lines': record.unmapped,
             'unmapped_summary_hits': record.unmapped_hits,
             'summary_hit_shortfall': record.summary_hit_shortfall,
             'mapped_hit_uncertainty': uncertainty,
             'changed_lines_without_line_records': sorted(changed.get(name, set()) - lines.keys() - excluded),
             'production_hit': max(0, sum(n > 0 for n in production.values()) - uncertainty),
-            'test_found': len(tests),
+            'test_found': len(tests) + (record.unmapped if test_only else 0),
             'test_hit': max(0, sum(n > 0 for n in tests.values()) - uncertainty),
             'uncovered_production': sorted(n for n, hits in production.items() if not hits),
             'changed_production_found': len(edits),
 
@@ -123,6 +123,37 @@ def test_unmapped_hits_cannot_inflate_any_subset_lower_bound(self):
         self.assertEqual(row['test_hit'], 0)
         self.assertEqual(row['changed_production_hit'], 0)
 
+    def test_conditional_attributes_exclude_only_items_requiring_test(self):
+        required = [
+            'all(test, unix)', 'all(windows, test,)', 'all(test, feature = "flag")',
+            'all(any(unix, windows), all(feature = "flag", test))',
+            'any(all(test, unix), all(windows, test))',
+        ]
+        optional = [
+            'any(test, unix)', 'any(windows, test)', 'not(test)', 'all(unix, feature = "test")',
+            'any(all(test, unix), windows)', 'all(any(test, unix), windows)', 'any()', 'all()',
+        ]
+        for condition in required + optional:
+            source = f'#[cfg({condition})]\nmod scoped {{\n fn helper() {{}}\n}}\nfn real() {{}}\n'
+            with self.subTest(condition=condition):
+                self.assertEqual(detail.test_lines(source), {1, 2, 3, 4} if condition in required else set())
+
+    def test_unmapped_test_file_entries_stay_in_the_test_denominator(self):
+        for folder in ['tests', 'benches']:
+            name = f'crates/pet/{folder}/fixture.rs'
+            path = self.root / name
+            path.parent.mkdir(parents=True)
+            path.write_text('fn helper() {}\nfn check() {}\n')
+            records = detail.line_records(self.lcov(self.record(name).replace('LF:2', 'LF:3')))
+            row = detail.summarize(self.root, records, {name: {1, 2}})['files'][0]
+            with self.subTest(folder=folder):
+                self.assertEqual(row['production_found'], 0)
+                self.assertEqual(row['production_hit'], 0)
+                self.assertEqual(row['changed_production_found'], 0)
+                self.assertEqual(row['test_found'], 3)
+                self.assertEqual(row['test_hit'], 0)
+                self.assertEqual(row['unmapped_summary_lines'], 1)
+
     def test_inline_tests_do_not_hide_later_production_items(self):
         source = 'fn before() {}\n#[cfg(test)]\nmod tests {\n fn check() {}\n}\nfn after() {}\n'
         self.assertEqual(detail.test_lines(source), {2, 3, 4, 5})