WIP: 59q8 red tests

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VdfEGXA7aJ6ftMsCc9PJze
2026-09-22 21:52:01 -07:00
parent 800348ad11
commit 54d9cc85de
1 changed files with 98 additions and 0 deletions
@@ -322,6 +322,104 @@ mod tests {
        ));
    }

+    /// improvise-59q8, the shapes that HID production code: a test-only item
+    /// whose end the line scan could not find. Evidence: test-evidence/protocol.md.
+    #[test]
+    fn a_test_only_item_hides_nothing_after_it() {
+        let cases = [
+            (
+                "a multi-line item ending in `];`",
+                concat!(
+                    "impl X {\n",
+                    "    #[cfg(test)]\n",
+                    "    const NAMES: &[&str] = &[\n",
+                    "        \"a\",\n",
+                    "    ];\n",
+                    "    fn prod() { let c = Command::Hidden1(1); }\n",
+                    "}\n",
+                    "fn after() { Command::Visible(2) }\n",
+                ),
+            ),
+            (
+                "a multi-line statement ending in `);`",
+                concat!(
+                    "fn f() {\n",
+                    "    #[cfg(test)]\n",
+                    "    let x = foo(\n",
+                    "        1,\n",
+                    "    );\n",
+                    "    let c = Command::Hidden1(1);\n",
+                    "}\n",
+                    "fn after() { Command::Visible(2) }\n",
+                ),
+            ),
+            (
+                "a one-line `#[cfg(test)] use`",
+                concat!(
+                    "#[cfg(test)] use foo::bar;\n",
+                    "fn prod() { Command::Hidden1(1) }\n",
+                    "fn after() { Command::Visible(2) }\n",
+                ),
+            ),
+        ];
+        for (what, text) in cases {
+            let kept = production_text(text);
+            for name in ["Hidden1", "Visible"] {
+                assert!(kept.contains(name), "{what}: {name} was hidden: {kept:?}");
+            }
+        }
+    }
+
+    /// improvise-59q8, the shapes that COUNTED test code as production.
+    #[test]
+    fn a_test_only_cfg_is_recognised_whatever_its_spelling() {
+        let cases = [
+            (
+                "`all(test, not(..))`",
+                "#[cfg(all(test, not(target_arch = \"wasm32\")))]\nfn t() { Command::TestOnly(1) }\n",
+            ),
+            (
+                "an inner `#![cfg(test)]` heading the file",
+                "#![cfg(test)]\nfn t() { Command::TestOnly(1) }\n",
+            ),
+            (
+                "an attribute split across lines",
+                "#[cfg(\n    test\n)]\nfn t() { Command::TestOnly(1) }\n",
+            ),
+        ];
+        for (what, text) in cases {
+            let kept = production_text(text);
+            assert!(!kept.contains("TestOnly"), "{what} was read as production: {kept:?}");
+        }
+        // The controls: a predicate a shipped build can satisfy is production.
+        for text in [
+            "#[cfg(not(test))]\nfn p() { Command::Shipped(1) }\n",
+            "#[cfg(any(test, feature = \"serde\"))]\nfn p() { Command::Shipped(1) }\n",
+            "#[cfg(target_arch = \"wasm32\")]\nfn p() { Command::Shipped(1) }\n",
+        ] {
+            assert!(production_text(text).contains("Shipped"), "{text:?} was dropped");
+        }
+    }
+
+    /// improvise-59q8's minor case: a C string literal leaked its contents.
+    #[test]
+    fn a_c_string_literal_is_blanked() {
+        // The raw one quotes inside itself, so lexing it as ordinary strings
+        // leaves the text BETWEEN the inner quotes in the open.
+        let kept = code_only("let a = c\"Command::InC(1)\"; let b = cr#\"x\" Command::InRawC(2) \"y\"#;\n");
+        for gone in ["InC", "InRawC"] {
+            assert!(!kept.contains(gone), "{gone} survived: {kept}");
+        }
+    }
+
+    /// A test-only item the scan cannot bound is REFUSED, never read to the
+    /// end of the file, which is what silently hid every shape above.
+    #[test]
+    #[should_panic(expected = "could not be bounded")]
+    fn an_unbounded_test_only_item_is_refused_not_swallowed() {
+        let _ = production_text("#[cfg(test)]\nfn broken() {\n    Command::X(1)\n");
+    }
+
    #[test]
    fn comments_and_literals_are_blanked_and_code_is_kept() {
        let text = concat!(