macros: simplify compile-fail tests

exercises/practice/macros/.meta/config.json

@@ -25,7 +25,8 @@
       "Cargo.toml"
     ],
     "test": [
-      "tests/macros.rs"
+      "tests/macros.rs",
+      "src/compile_fail_tests.rs"
     ],
     "example": [
       ".meta/example.rs"

exercises/practice/macros/.meta/example.rs

@@ -14,3 +14,8 @@ macro_rules! hashmap {
         }
     };
 }
+
+/// This module contains doctests, which allows writing tests where a code
+/// snippet is supposed to fail to compile. These tests also have "ignore"
+/// attributes, makes sure to remove them when solving this exercise locally.
+pub mod compile_fail_tests;

exercises/practice/macros/src/compile_fail_tests.rs

@@ -0,0 +1,103 @@
+/// To activate a doctest locally, remove ",ignore" from the code block.
+///
+/// # Comma separator
+///
+/// ```compile_fail,ignore
+/// use macros::hashmap;
+/// use std::collections::HashMap;
+///
+/// // using only commas is invalid
+/// let _hm: HashMap<_, _> = hashmap!('a', 1);
+/// ```
+///
+/// # Double trailing commas
+///
+/// ```compile_fail,ignore
+/// use macros::hashmap;
+/// use std::collections::HashMap;
+///
+/// // a single trailing comma is okay, but two is not
+/// let _hm: HashMap<_, _> = hashmap!('a' => 2, ,);
+/// ```
+///
+/// # Only comma
+///
+/// ```compile_fail,ignore
+/// use macros::hashmap;
+/// use std::collections::HashMap;
+///
+/// // a single random comma is not valid
+/// let _hm: HashMap<(), ()> = hashmap!(,);
+/// ```
+///
+/// # Single argument
+///
+/// ```compile_fail,ignore
+/// use macros::hashmap;
+/// use std::collections::HashMap;
+///
+/// // a single argument is invalid
+/// let _hm: HashMap<_, _> = hashmap!('a');
+/// ```
+///
+/// # Triple arguments
+///
+/// ```compile_fail,ignore
+/// use macros::hashmap;
+/// use std::collections::HashMap;
+///
+/// // three arguments are invalid
+/// hashmap!('a' => 1, 'b');
+/// ```
+///
+/// # Only arrow
+///
+/// ```compile_fail,ignore
+/// use macros::hashmap;
+/// use std::collections::HashMap;
+///
+/// // a single random arrow is not valid
+/// let _hm: HashMap<(), ()> = hashmap!(=>);
+/// ```
+///
+/// # Trailing arrow
+///
+/// ```compile_fail,ignore
+/// use macros::hashmap;
+/// use std::collections::HashMap;
+///
+/// // a trailing => isn't valid either
+/// hashmap!('a' => 2, =>);
+/// ```
+///
+/// # Leading comma
+///
+/// ```compile_fail,ignore
+/// use macros::hashmap;
+/// use std::collections::HashMap;
+///
+/// // leading commas are not valid
+/// let _hm: HashMap<_, _> = hashmap!(, 'a' => 2);
+/// ```
+///
+/// # Missing comma
+///
+/// ```compile_fail,ignore
+/// use macros::hashmap;
+/// use std::collections::HashMap;
+///
+/// // Key value pairs must be separated by commas
+/// let _hm: HashMap<_, _> = hashmap!('a' => 1 'b' => 2);
+/// ```
+///
+/// # Missing argument
+///
+/// ```compile_fail,ignore
+/// use macros::hashmap;
+/// use std::collections::HashMap;
+///
+/// // an argument should come between each pair of commas
+/// let _hm: HashMap<_, _> = hashmap!('a' => 1, , 'b' => 2);
+/// ```
+///
+const _TESTS: () = ();

exercises/practice/macros/src/lib.rs

@@ -4,3 +4,8 @@ macro_rules! hashmap {
         todo!()
     };
 }
+
+/// This module contains doctests, which allows writing tests where a code
+/// snippet is supposed to fail to compile. These tests also have "ignore"
+/// attributes, makes sure to remove them when solving this exercise locally.
+pub mod compile_fail_tests;

exercises/practice/macros/tests/macros.rs

@@ -114,103 +114,9 @@ fn type_override() {
     let _with_trailing = hashmap!(1 => 2, 3 => 4,);
 }
 
-#[test]
-#[ignore]
-fn compile_fails_comma_sep() {
-    simple_trybuild::compile_fail("comma_sep.rs");
-}
-
-#[test]
-#[ignore]
-fn compile_fails_double_commas() {
-    simple_trybuild::compile_fail("double_commas.rs");
-}
-
-#[test]
-#[ignore]
-fn compile_fails_only_comma() {
-    simple_trybuild::compile_fail("only_comma.rs");
-}
-
-#[test]
-#[ignore]
-fn compile_fails_single_argument() {
-    simple_trybuild::compile_fail("single_argument.rs");
-}
-
-#[test]
-#[ignore]
-fn compile_fails_triple_arguments() {
-    simple_trybuild::compile_fail("triple_arguments.rs");
-}
-
-#[test]
-#[ignore]
-fn compile_fails_only_arrow() {
-    simple_trybuild::compile_fail("only_arrow.rs");
-}
-
-#[test]
-#[ignore]
-fn compile_fails_two_arrows() {
-    simple_trybuild::compile_fail("two_arrows.rs");
-}
-
-#[test]
-#[ignore]
-fn compile_fails_leading_comma() {
-    simple_trybuild::compile_fail("leading_comma.rs");
-}
-
-#[test]
-#[ignore]
-fn compile_fails_no_comma() {
-    simple_trybuild::compile_fail("no_comma.rs");
-}
-
-#[test]
-#[ignore]
-fn compile_fails_missing_argument() {
-    simple_trybuild::compile_fail("missing_argument.rs");
-}
-
-mod simple_trybuild {
-    use std::path::PathBuf;
-    use std::process::Command;
-
-    pub fn compile_fail(file_name: &str) {
-        let invalid_path: PathBuf = ["tests", "invalid"].iter().collect::<PathBuf>();
-
-        let mut file_path = invalid_path.clone();
-        file_path.push(file_name);
-        assert!(
-            file_path.exists(),
-            "{:?} does not exist.",
-            file_path.into_os_string()
-        );
-
-        let test_name = file_name.strip_suffix(".rs").unwrap();
-        let macros_dir = ["..", "..", "target", "tests", "macros"]
-            .iter()
-            .collect::<PathBuf>();
-
-        let result = Command::new("cargo")
-            .current_dir(invalid_path)
-            .arg("build")
-            .arg("--offline")
-            .arg("--target-dir")
-            .arg(macros_dir)
-            .arg("--bin")
-            .arg(test_name)
-            .output();
-
-        if let Ok(result) = result {
-            assert!(
-                !result.status.success(),
-                "Expected {file_path:?} to fail to compile, but it succeeded."
-            );
-        } else {
-            panic!("Running subprocess failed.");
-        }
-    }
-}
+// Don't forget that there are also tests in `src/compile_fail_tests.rs` !
+#[expect(
+    unused_imports,
+    reason = "prevent user from deleting the mod declaration"
+)]
+use macros::compile_fail_tests;