macros: simplify compile-fail tests

I was experimenting with my solution locally and it didn't work. My
solution was wrong, but the compile-fail tests didn't actually fail.
I'm not 100% sure why that was the case, but I assume it's because
I've set up a cargo workspace for my own exercise solutions. This moves
the target folder somewhere else, but the compile-fail tests assume a
specific target directory location.

Using doctests should be much more reliable, since it's using a built-in
way of Rust to do this. It's a little unconventional compared to the
other exercises, but so were the previous compile-fail tests.

One downside to this is that users who solve the exercise locally
will have to learn a new way of un-ignoring a test. I've tried to make
this smooth with appropriate comments. The test-runner should have no
problems with this, since it uses `cargo test -- --include-ignored`
to run all tests. This works for these new doctests just like for the
normal ones.

Author: senekor

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/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.
+mod compile_fail_tests;