[no important files changed] Make sure the tests displays unicode characters properly [no important files changed] (#164)

* Make sure the tests displays unicode characters properly

The generic 'expect_slices_match()' routine use the '%v' format,
when applied to string with unicode, this displays the code
points rather than the unicode characters.

For example, the test 'test_handles_case_of_greek_letters'
display the expected result as
'["\u0392\u0393\u0391", "\u03b3\u03b2\u03b1"].
I modified the 'expect_slices_match()' procedure to use
strings and '%s' instead and now the expected result looks like
'[ΒΓΑ, γβα]'.

* Incorporate comments from the Peer Review

I modified the description in the When Writing Tests How to
Compare Resylt and Expected for Slice FAQ and created
the expect_helpers.odin template to provide an official
version of the comparison function for string slices and
general slices.

Author: rmonnet

dev/docs/faqs/when_writing_tests_how_to_compare_result_and_expected_for_slices.md

@@ -4,27 +4,18 @@ When writing tests, the Odin framework provides useful procedures like `testing.
 Unfortunately, if you want to compare slices, you will get an error stating that `type_is_comparable(T)` evaluates to false.
 
 There are multiple ways to compare slices, including `slice.equal()` but they don't provide good error messages to the student.
-The method that you should use is as follow:
 
-1. Copy this helper function into your test file:
+The functions included in this [file][expect-helpers] will compare slices for you and, in case they don't match, provide informative error messages:
 
-```odin
-expect_slices_match :: proc(t: ^testing.T, actual, expected: []$E, loc := #caller_location) {
-	result := fmt.aprintf("%v", actual)
-	exp_str := fmt.aprintf("%v", expected)
-	defer {
-		delete(result)
-		delete(exp_str)
-	}
-
-	testing.expect_value(t, result, exp_str, loc = loc)
-}
-```
+- `expect_string_slices :: proc(t: ^testing.T, actual, expected: []string, loc := #caller_location)` compares slices of string and displays the unicode strings in result and expected when the test fails.
+- `expect_slices :: proc(t: ^testing.T, actual, expected: []$E, loc := #caller_location)` compares slices of any other type and displays human readable sets for both the result and expected values when the test fails.
 
 2. use the helper function to compare the result and expected values.
 
 ```odin
-expect_slices_match(t, result, []int{1, 2, 3, 4, 5})
+expect_slices(t, result, []int{1, 2, 3, 4, 5})
+
+expect_string_slices(t, result []string{"LISTEN", "Silent"})
 ```
 
 Why are we asking you to use that specific procedure?
@@ -36,7 +27,9 @@ Using the function above, the message looks like:
 [forth_test.odin:24:test_parsing_and_numbers__numbers_just_get_pushed_onto_the_stack()] expected result to be [1, 2, 3, 4], got [1, 2, 3, 4, 5]
 ```
 
-Note how informative the messages is?
+Note how informative the messages is!
 It shows both result and expected values in a human-readable form (while using `slice.equal()` would result in 'expected true, got false').
 In addition it correctly identifies the line where the test fails (not the line of the `expect_value()` in the helper procedure) and properly identify the result as 'result'.
 There are other ways to achieve the same result but this one is battle tested.
+
+[expect-helpers]: https://github.com/exercism/odin/blob/main/dev/templates/expect_helpers.odin

dev/templates/expect_helpers.odin

@@ -0,0 +1,32 @@
+package expect_helpers
+
+import "core:fmt"
+import "core:testing"
+
+// If you need to compare slices of strings, copy this procedure in your
+// `<exercise_slug>_test.odin` and use `expect_strings()` to compare them.
+// This function provides informative error reports.
+expect_string_slices :: proc(t: ^testing.T, actual, expected: []string, loc := #caller_location) {
+	result := fmt.aprintf("%s", actual)
+	exp_str := fmt.aprintf("%s", expected)
+	defer {
+		delete(result)
+		delete(exp_str)
+	}
+
+	testing.expect_value(t, result, exp_str, loc = loc)
+}
+
+// If you need to compare slices of any type but string, copy this procedure in your
+// `<exercise_slug>_test.odin` and use `expect_slices()` to compare them.
+// This function provides informative error reports.
+expect_slices :: proc(t: ^testing.T, actual, expected: []$E, loc := #caller_location) {
+	result := fmt.aprintf("%v", actual)
+	exp_str := fmt.aprintf("%v", expected)
+	defer {
+		delete(result)
+		delete(exp_str)
+	}
+
+	testing.expect_value(t, result, exp_str, loc = loc)
+}

exercises/practice/anagram/anagram_test.odin

@@ -3,9 +3,9 @@ package anagram
 import "core:fmt"
 import "core:testing"
 
-expect_slices_match :: proc(t: ^testing.T, actual, expected: []$E, loc := #caller_location) {
-	result := fmt.aprintf("%v", actual)
-	exp_str := fmt.aprintf("%v", expected)
+expect_slices_match :: proc(t: ^testing.T, actual, expected: []string, loc := #caller_location) {
+	result := fmt.aprintf("%s", actual)
+	exp_str := fmt.aprintf("%s", expected)
 	defer {
 		delete(result)
 		delete(exp_str)