diff --git a/exercises/practice/tournament/.docs/instructions.md b/exercises/practice/tournament/.docs/instructions.md index 8831dd195..e5ca23738 100644 --- 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 new file mode 100644 index 000000000..e469e04d3 --- /dev/null +++ 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 index 598677086..0e33c87fc 100644 --- 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 index 398e91807..300a5cf28 100644 --- 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); }