Sync tournament with problem-specifications (#1764)

exercism · Nov 14, 2023 · ec0862b · ec0862b
1 parent cbd1748
commit ec0862b
Show file tree

Hide file tree

Showing 4 changed files with 197 additions and 108 deletions.
diff --git a/exercises/practice/tournament/.docs/instructions.md b/exercises/practice/tournament/.docs/instructions.md
@@ -2,8 +2,7 @@
 
 Tally the results of a small football competition.
 
-Based on an input file containing which team played against which and what the
-outcome was, create a file with a table like this:
+Based on an input file containing which team played against which and what the outcome was, create a file with a table like this:
 
 ```text
 Team                           | MP |  W |  D |  L |  P
@@ -21,9 +20,12 @@ What do those abbreviations mean?
 - L: Matches Lost
 - P: Points
 
-A win earns a team 3 points. A draw earns 1. A loss earns 0.
+A win earns a team 3 points.
+A draw earns 1.
+A loss earns 0.
 
-The outcome should be ordered by points, descending. In case of a tie, teams are ordered alphabetically.
+The outcome is ordered by points, descending.
+In case of a tie, teams are ordered alphabetically.
 
 ## Input
 
@@ -38,7 +40,8 @@ Blithering Badgers;Devastating Donkeys;loss
 Allegoric Alaskans;Courageous Californians;win
 ```
 
-The result of the match refers to the first team listed. So this line:
+The result of the match refers to the first team listed.
+So this line:
 
 ```text
 Allegoric Alaskans;Blithering Badgers;win

diff --git a/exercises/practice/tournament/.meta/test_template.tera b/exercises/practice/tournament/.meta/test_template.tera
@@ -0,0 +1,13 @@
+{% for test in cases %}
+#[test]
+{% if loop.index != 1 -%}
+#[ignore]
+{% endif -%}
+fn {{ test.description | slugify | replace(from="-", to="_") }}() {
+    let input: &[&str] = &{{ test.input.rows | json_encode() }};
+    let input = input.join("\n");
+    let output = {{ crate_name }}::{{ fn_names[0] }}(&input);
+    let expected = {{ test.expected | json_encode() }}.join("\n");
+    assert_eq!(output, expected);
+}
+{% endfor -%}
diff --git a/exercises/practice/tournament/.meta/tests.toml b/exercises/practice/tournament/.meta/tests.toml
@@ -1,6 +1,13 @@
-# This is an auto-generated file. Regular comments will be removed when this
-# file is regenerated. Regenerating will not touch any manually added keys,
-# so comments can be added in a "comment" key.
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
 
 [67e9fab1-07c1-49cf-9159-bc8671cc7c9c]
 description = "just the header if no input"
@@ -34,3 +41,6 @@ description = "incomplete competition (not all pairs have played)"
 
 [3aa0386f-150b-4f99-90bb-5195e7b7d3b8]
 description = "ties broken alphabetically"
+
+[f9e20931-8a65-442a-81f6-503c0205b17a]
+description = "ensure points sorted numerically"
diff --git a/exercises/practice/tournament/tests/tournament.rs b/exercises/practice/tournament/tests/tournament.rs
@@ -1,152 +1,215 @@
 #[test]
 fn just_the_header_if_no_input() {
-    let input = "";
-    let expected = "Team                           | MP |  W |  D |  L |  P";
-
-    assert_eq!(tournament::tally(input), expected);
+    let input: &[&str] = &[];
+    let input = input.join("\n");
+    let output = tournament::tally(&input);
+    let expected = ["Team                           | MP |  W |  D |  L |  P"].join("\n");
+    assert_eq!(output, expected);
 }
 
 #[test]
 #[ignore]
 fn a_win_is_three_points_a_loss_is_zero_points() {
-    let input = "Allegoric Alaskans;Blithering Badgers;win";
-    let expected = "".to_string()
-        + "Team                           | MP |  W |  D |  L |  P\n"
-        + "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3\n"
-        + "Blithering Badgers             |  1 |  0 |  0 |  1 |  0";
-
-    assert_eq!(tournament::tally(input), expected);
+    let input: &[&str] = &["Allegoric Alaskans;Blithering Badgers;win"];
+    let input = input.join("\n");
+    let output = tournament::tally(&input);
+    let expected = [
+        "Team                           | MP |  W |  D |  L |  P",
+        "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3",
+        "Blithering Badgers             |  1 |  0 |  0 |  1 |  0",
+    ]
+    .join("\n");
+    assert_eq!(output, expected);
 }
 
 #[test]
 #[ignore]
 fn a_win_can_also_be_expressed_as_a_loss() {
-    let input = "Blithering Badgers;Allegoric Alaskans;loss";
-    let expected = "".to_string()
-        + "Team                           | MP |  W |  D |  L |  P\n"
-        + "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3\n"
-        + "Blithering Badgers             |  1 |  0 |  0 |  1 |  0";
-
-    assert_eq!(tournament::tally(input), expected);
+    let input: &[&str] = &["Blithering Badgers;Allegoric Alaskans;loss"];
+    let input = input.join("\n");
+    let output = tournament::tally(&input);
+    let expected = [
+        "Team                           | MP |  W |  D |  L |  P",
+        "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3",
+        "Blithering Badgers             |  1 |  0 |  0 |  1 |  0",
+    ]
+    .join("\n");
+    assert_eq!(output, expected);
 }
 
 #[test]
 #[ignore]
 fn a_different_team_can_win() {
-    let input = "Blithering Badgers;Allegoric Alaskans;win";
-    let expected = "".to_string()
-        + "Team                           | MP |  W |  D |  L |  P\n"
-        + "Blithering Badgers             |  1 |  1 |  0 |  0 |  3\n"
-        + "Allegoric Alaskans             |  1 |  0 |  0 |  1 |  0";
-
-    assert_eq!(tournament::tally(input), expected);
+    let input: &[&str] = &["Blithering Badgers;Allegoric Alaskans;win"];
+    let input = input.join("\n");
+    let output = tournament::tally(&input);
+    let expected = [
+        "Team                           | MP |  W |  D |  L |  P",
+        "Blithering Badgers             |  1 |  1 |  0 |  0 |  3",
+        "Allegoric Alaskans             |  1 |  0 |  0 |  1 |  0",
+    ]
+    .join("\n");
+    assert_eq!(output, expected);
 }
 
 #[test]
 #[ignore]
-fn there_can_be_more_than_one_match() {
-    let input = "Allegoric Alaskans;Blithering Badgers;win\n".to_string()
-        + "Allegoric Alaskans;Blithering Badgers;win";
-    let expected = "".to_string()
-        + "Team                           | MP |  W |  D |  L |  P\n"
-        + "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6\n"
-        + "Blithering Badgers             |  2 |  0 |  0 |  2 |  0";
-
-    assert_eq!(tournament::tally(&input), expected);
+fn a_draw_is_one_point_each() {
+    let input: &[&str] = &["Allegoric Alaskans;Blithering Badgers;draw"];
+    let input = input.join("\n");
+    let output = tournament::tally(&input);
+    let expected = [
+        "Team                           | MP |  W |  D |  L |  P",
+        "Allegoric Alaskans             |  1 |  0 |  1 |  0 |  1",
+        "Blithering Badgers             |  1 |  0 |  1 |  0 |  1",
+    ]
+    .join("\n");
+    assert_eq!(output, expected);
 }
 
 #[test]
 #[ignore]
-fn a_draw_is_one_point_each() {
-    let input = "Allegoric Alaskans;Blithering Badgers;draw\n".to_string()
-        + "Allegoric Alaskans;Blithering Badgers;win";
-    let expected = "".to_string()
-        + "Team                           | MP |  W |  D |  L |  P\n"
-        + "Allegoric Alaskans             |  2 |  1 |  1 |  0 |  4\n"
-        + "Blithering Badgers             |  2 |  0 |  1 |  1 |  1";
-
-    assert_eq!(tournament::tally(&input), expected);
+fn there_can_be_more_than_one_match() {
+    let input: &[&str] = &[
+        "Allegoric Alaskans;Blithering Badgers;win",
+        "Allegoric Alaskans;Blithering Badgers;win",
+    ];
+    let input = input.join("\n");
+    let output = tournament::tally(&input);
+    let expected = [
+        "Team                           | MP |  W |  D |  L |  P",
+        "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6",
+        "Blithering Badgers             |  2 |  0 |  0 |  2 |  0",
+    ]
+    .join("\n");
+    assert_eq!(output, expected);
 }
 
 #[test]
 #[ignore]
 fn there_can_be_more_than_one_winner() {
-    let input = "Allegoric Alaskans;Blithering Badgers;loss\n".to_string()
-        + "Allegoric Alaskans;Blithering Badgers;win";
-    let expected = "".to_string()
-        + "Team                           | MP |  W |  D |  L |  P\n"
-        + "Allegoric Alaskans             |  2 |  1 |  0 |  1 |  3\n"
-        + "Blithering Badgers             |  2 |  1 |  0 |  1 |  3";
-
-    assert_eq!(tournament::tally(&input), expected);
+    let input: &[&str] = &[
+        "Allegoric Alaskans;Blithering Badgers;loss",
+        "Allegoric Alaskans;Blithering Badgers;win",
+    ];
+    let input = input.join("\n");
+    let output = tournament::tally(&input);
+    let expected = [
+        "Team                           | MP |  W |  D |  L |  P",
+        "Allegoric Alaskans             |  2 |  1 |  0 |  1 |  3",
+        "Blithering Badgers             |  2 |  1 |  0 |  1 |  3",
+    ]
+    .join("\n");
+    assert_eq!(output, expected);
 }
 
 #[test]
 #[ignore]
 fn there_can_be_more_than_two_teams() {
-    let input = "Allegoric Alaskans;Blithering Badgers;win\n".to_string()
-        + "Blithering Badgers;Courageous Californians;win\n"
-        + "Courageous Californians;Allegoric Alaskans;loss";
-    let expected = "".to_string()
-        + "Team                           | MP |  W |  D |  L |  P\n"
-        + "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6\n"
-        + "Blithering Badgers             |  2 |  1 |  0 |  1 |  3\n"
-        + "Courageous Californians        |  2 |  0 |  0 |  2 |  0";
-
-    assert_eq!(tournament::tally(&input), expected);
+    let input: &[&str] = &[
+        "Allegoric Alaskans;Blithering Badgers;win",
+        "Blithering Badgers;Courageous Californians;win",
+        "Courageous Californians;Allegoric Alaskans;loss",
+    ];
+    let input = input.join("\n");
+    let output = tournament::tally(&input);
+    let expected = [
+        "Team                           | MP |  W |  D |  L |  P",
+        "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6",
+        "Blithering Badgers             |  2 |  1 |  0 |  1 |  3",
+        "Courageous Californians        |  2 |  0 |  0 |  2 |  0",
+    ]
+    .join("\n");
+    assert_eq!(output, expected);
 }
 
 #[test]
 #[ignore]
 fn typical_input() {
-    let input = "Allegoric Alaskans;Blithering Badgers;win\n".to_string()
-        + "Devastating Donkeys;Courageous Californians;draw\n"
-        + "Devastating Donkeys;Allegoric Alaskans;win\n"
-        + "Courageous Californians;Blithering Badgers;loss\n"
-        + "Blithering Badgers;Devastating Donkeys;loss\n"
-        + "Allegoric Alaskans;Courageous Californians;win";
-    let expected = "".to_string()
-        + "Team                           | MP |  W |  D |  L |  P\n"
-        + "Devastating Donkeys            |  3 |  2 |  1 |  0 |  7\n"
-        + "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6\n"
-        + "Blithering Badgers             |  3 |  1 |  0 |  2 |  3\n"
-        + "Courageous Californians        |  3 |  0 |  1 |  2 |  1";
-
-    assert_eq!(tournament::tally(&input), expected);
+    let input: &[&str] = &[
+        "Allegoric Alaskans;Blithering Badgers;win",
+        "Devastating Donkeys;Courageous Californians;draw",
+        "Devastating Donkeys;Allegoric Alaskans;win",
+        "Courageous Californians;Blithering Badgers;loss",
+        "Blithering Badgers;Devastating Donkeys;loss",
+        "Allegoric Alaskans;Courageous Californians;win",
+    ];
+    let input = input.join("\n");
+    let output = tournament::tally(&input);
+    let expected = [
+        "Team                           | MP |  W |  D |  L |  P",
+        "Devastating Donkeys            |  3 |  2 |  1 |  0 |  7",
+        "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6",
+        "Blithering Badgers             |  3 |  1 |  0 |  2 |  3",
+        "Courageous Californians        |  3 |  0 |  1 |  2 |  1",
+    ]
+    .join("\n");
+    assert_eq!(output, expected);
 }
 
 #[test]
 #[ignore]
 fn incomplete_competition_not_all_pairs_have_played() {
-    let input = "Allegoric Alaskans;Blithering Badgers;loss\n".to_string()
-        + "Devastating Donkeys;Allegoric Alaskans;loss\n"
-        + "Courageous Californians;Blithering Badgers;draw\n"
-        + "Allegoric Alaskans;Courageous Californians;win";
-    let expected = "".to_string()
-        + "Team                           | MP |  W |  D |  L |  P\n"
-        + "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6\n"
-        + "Blithering Badgers             |  2 |  1 |  1 |  0 |  4\n"
-        + "Courageous Californians        |  2 |  0 |  1 |  1 |  1\n"
-        + "Devastating Donkeys            |  1 |  0 |  0 |  1 |  0";
-
-    assert_eq!(tournament::tally(&input), expected);
+    let input: &[&str] = &[
+        "Allegoric Alaskans;Blithering Badgers;loss",
+        "Devastating Donkeys;Allegoric Alaskans;loss",
+        "Courageous Californians;Blithering Badgers;draw",
+        "Allegoric Alaskans;Courageous Californians;win",
+    ];
+    let input = input.join("\n");
+    let output = tournament::tally(&input);
+    let expected = [
+        "Team                           | MP |  W |  D |  L |  P",
+        "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6",
+        "Blithering Badgers             |  2 |  1 |  1 |  0 |  4",
+        "Courageous Californians        |  2 |  0 |  1 |  1 |  1",
+        "Devastating Donkeys            |  1 |  0 |  0 |  1 |  0",
+    ]
+    .join("\n");
+    assert_eq!(output, expected);
 }
 
 #[test]
 #[ignore]
 fn ties_broken_alphabetically() {
-    let input = "Courageous Californians;Devastating Donkeys;win\n".to_string()
-        + "Allegoric Alaskans;Blithering Badgers;win\n"
-        + "Devastating Donkeys;Allegoric Alaskans;loss\n"
-        + "Courageous Californians;Blithering Badgers;win\n"
-        + "Blithering Badgers;Devastating Donkeys;draw\n"
-        + "Allegoric Alaskans;Courageous Californians;draw";
-    let expected = "".to_string()
-        + "Team                           | MP |  W |  D |  L |  P\n"
-        + "Allegoric Alaskans             |  3 |  2 |  1 |  0 |  7\n"
-        + "Courageous Californians        |  3 |  2 |  1 |  0 |  7\n"
-        + "Blithering Badgers             |  3 |  0 |  1 |  2 |  1\n"
-        + "Devastating Donkeys            |  3 |  0 |  1 |  2 |  1";
+    let input: &[&str] = &[
+        "Courageous Californians;Devastating Donkeys;win",
+        "Allegoric Alaskans;Blithering Badgers;win",
+        "Devastating Donkeys;Allegoric Alaskans;loss",
+        "Courageous Californians;Blithering Badgers;win",
+        "Blithering Badgers;Devastating Donkeys;draw",
+        "Allegoric Alaskans;Courageous Californians;draw",
+    ];
+    let input = input.join("\n");
+    let output = tournament::tally(&input);
+    let expected = [
+        "Team                           | MP |  W |  D |  L |  P",
+        "Allegoric Alaskans             |  3 |  2 |  1 |  0 |  7",
+        "Courageous Californians        |  3 |  2 |  1 |  0 |  7",
+        "Blithering Badgers             |  3 |  0 |  1 |  2 |  1",
+        "Devastating Donkeys            |  3 |  0 |  1 |  2 |  1",
+    ]
+    .join("\n");
+    assert_eq!(output, expected);
+}
 
-    assert_eq!(tournament::tally(&input), expected);
+#[test]
+#[ignore]
+fn ensure_points_sorted_numerically() {
+    let input: &[&str] = &[
+        "Devastating Donkeys;Blithering Badgers;win",
+        "Devastating Donkeys;Blithering Badgers;win",
+        "Devastating Donkeys;Blithering Badgers;win",
+        "Devastating Donkeys;Blithering Badgers;win",
+        "Blithering Badgers;Devastating Donkeys;win",
+    ];
+    let input = input.join("\n");
+    let output = tournament::tally(&input);
+    let expected = [
+        "Team                           | MP |  W |  D |  L |  P",
+        "Devastating Donkeys            |  5 |  4 |  0 |  1 | 12",
+        "Blithering Badgers             |  5 |  1 |  0 |  4 |  3",
+    ]
+    .join("\n");
+    assert_eq!(output, expected);
 }