diff --git a/exercises/practice/allergies/.meta/test_template.tera b/exercises/practice/allergies/.meta/test_template.tera
new file mode 100644
index 000000000..986be5782
--- /dev/null
+++ b/exercises/practice/allergies/.meta/test_template.tera
@@ -0,0 +1,43 @@
+use {{ crate_name }}::*;
+
+fn compare_allergy_vectors(expected: &[Allergen], actual: &[Allergen]) {
+    for element in expected {
+        if !actual.contains(element) {
+            panic!("Allergen missing\n  {element:?} should be in {actual:?}");
+        }
+    }
+
+    if actual.len() != expected.len() {
+        panic!(
+            "Allergy vectors are of different lengths\n  expected {expected:?}\n  got {actual:?}"
+        );
+    }
+}
+
+{% for test in cases %}
+#[test]
+{% if loop.index != 1 -%}
+#[ignore]
+{% endif -%}
+{%- if test.property == "allergicTo" %}
+{# canonical data contains multiple cases named "allergic to everything" for different items #}
+fn {{ test.description | slugify | replace(from="-", to="_") }}_{{ test.input.item }}() {
+    let allergies = Allergies::new({{ test.input.score }});
+{%- if test.expected %}
+    assert!(allergies.is_allergic_to(&Allergen::{{ test.input.item | title }}))
+{% else %}
+    assert!(!allergies.is_allergic_to(&Allergen::{{ test.input.item | title }}))
+{% endif -%}
+{% else %}
+fn {{ test.description | slugify | replace(from="-", to="_") }}() {
+    let allergies = Allergies::new({{ test.input.score }}).allergies();
+    let expected = &[
+        {% for allergen in test.expected %}
+            Allergen::{{ allergen | title }},
+        {% endfor %}
+    ];
+
+    compare_allergy_vectors(expected, &allergies);
+{% endif -%}
+}
+{% endfor -%}
diff --git a/exercises/practice/allergies/.meta/tests.toml b/exercises/practice/allergies/.meta/tests.toml
index 63397b988..799ab8563 100644
--- a/exercises/practice/allergies/.meta/tests.toml
+++ b/exercises/practice/allergies/.meta/tests.toml
@@ -1,27 +1,160 @@
-# 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.
+
+[17fc7296-2440-4ac4-ad7b-d07c321bc5a0]
+description = "testing for eggs allergy -> not allergic to anything"
+
+[07ced27b-1da5-4c2e-8ae2-cb2791437546]
+description = "testing for eggs allergy -> allergic only to eggs"
+
+[5035b954-b6fa-4b9b-a487-dae69d8c5f96]
+description = "testing for eggs allergy -> allergic to eggs and something else"
+
+[64a6a83a-5723-4b5b-a896-663307403310]
+description = "testing for eggs allergy -> allergic to something, but not eggs"
 
 [90c8f484-456b-41c4-82ba-2d08d93231c6]
-description = "allergic to everything"
+description = "testing for eggs allergy -> allergic to everything"
+
+[d266a59a-fccc-413b-ac53-d57cb1f0db9d]
+description = "testing for peanuts allergy -> not allergic to anything"
+
+[ea210a98-860d-46b2-a5bf-50d8995b3f2a]
+description = "testing for peanuts allergy -> allergic only to peanuts"
+
+[eac69ae9-8d14-4291-ac4b-7fd2c73d3a5b]
+description = "testing for peanuts allergy -> allergic to peanuts and something else"
+
+[9152058c-ce39-4b16-9b1d-283ec6d25085]
+description = "testing for peanuts allergy -> allergic to something, but not peanuts"
 
 [d2d71fd8-63d5-40f9-a627-fbdaf88caeab]
-description = "allergic to everything"
+description = "testing for peanuts allergy -> allergic to everything"
+
+[b948b0a1-cbf7-4b28-a244-73ff56687c80]
+description = "testing for shellfish allergy -> not allergic to anything"
+
+[9ce9a6f3-53e9-4923-85e0-73019047c567]
+description = "testing for shellfish allergy -> allergic only to shellfish"
+
+[b272fca5-57ba-4b00-bd0c-43a737ab2131]
+description = "testing for shellfish allergy -> allergic to shellfish and something else"
+
+[21ef8e17-c227-494e-8e78-470a1c59c3d8]
+description = "testing for shellfish allergy -> allergic to something, but not shellfish"
 
 [cc789c19-2b5e-4c67-b146-625dc8cfa34e]
-description = "allergic to everything"
+description = "testing for shellfish allergy -> allergic to everything"
+
+[651bde0a-2a74-46c4-ab55-02a0906ca2f5]
+description = "testing for strawberries allergy -> not allergic to anything"
+
+[b649a750-9703-4f5f-b7f7-91da2c160ece]
+description = "testing for strawberries allergy -> allergic only to strawberries"
+
+[50f5f8f3-3bac-47e6-8dba-2d94470a4bc6]
+description = "testing for strawberries allergy -> allergic to strawberries and something else"
+
+[23dd6952-88c9-48d7-a7d5-5d0343deb18d]
+description = "testing for strawberries allergy -> allergic to something, but not strawberries"
 
 [74afaae2-13b6-43a2-837a-286cd42e7d7e]
-description = "allergic to everything"
+description = "testing for strawberries allergy -> allergic to everything"
+
+[c49a91ef-6252-415e-907e-a9d26ef61723]
+description = "testing for tomatoes allergy -> not allergic to anything"
+
+[b69c5131-b7d0-41ad-a32c-e1b2cc632df8]
+description = "testing for tomatoes allergy -> allergic only to tomatoes"
+
+[1ca50eb1-f042-4ccf-9050-341521b929ec]
+description = "testing for tomatoes allergy -> allergic to tomatoes and something else"
+
+[e9846baa-456b-4eff-8025-034b9f77bd8e]
+description = "testing for tomatoes allergy -> allergic to something, but not tomatoes"
 
 [b2414f01-f3ad-4965-8391-e65f54dad35f]
-description = "allergic to everything"
+description = "testing for tomatoes allergy -> allergic to everything"
+
+[978467ab-bda4-49f7-b004-1d011ead947c]
+description = "testing for chocolate allergy -> not allergic to anything"
+
+[59cf4e49-06ea-4139-a2c1-d7aad28f8cbc]
+description = "testing for chocolate allergy -> allergic only to chocolate"
+
+[b0a7c07b-2db7-4f73-a180-565e07040ef1]
+description = "testing for chocolate allergy -> allergic to chocolate and something else"
+
+[f5506893-f1ae-482a-b516-7532ba5ca9d2]
+description = "testing for chocolate allergy -> allergic to something, but not chocolate"
 
 [02debb3d-d7e2-4376-a26b-3c974b6595c6]
-description = "allergic to everything"
+description = "testing for chocolate allergy -> allergic to everything"
+
+[17f4a42b-c91e-41b8-8a76-4797886c2d96]
+description = "testing for pollen allergy -> not allergic to anything"
+
+[7696eba7-1837-4488-882a-14b7b4e3e399]
+description = "testing for pollen allergy -> allergic only to pollen"
+
+[9a49aec5-fa1f-405d-889e-4dfc420db2b6]
+description = "testing for pollen allergy -> allergic to pollen and something else"
+
+[3cb8e79f-d108-4712-b620-aa146b1954a9]
+description = "testing for pollen allergy -> allergic to something, but not pollen"
 
 [1dc3fe57-7c68-4043-9d51-5457128744b2]
-description = "allergic to everything"
+description = "testing for pollen allergy -> allergic to everything"
+
+[d3f523d6-3d50-419b-a222-d4dfd62ce314]
+description = "testing for cats allergy -> not allergic to anything"
+
+[eba541c3-c886-42d3-baef-c048cb7fcd8f]
+description = "testing for cats allergy -> allergic only to cats"
+
+[ba718376-26e0-40b7-bbbe-060287637ea5]
+description = "testing for cats allergy -> allergic to cats and something else"
+
+[3c6dbf4a-5277-436f-8b88-15a206f2d6c4]
+description = "testing for cats allergy -> allergic to something, but not cats"
 
 [1faabb05-2b98-4995-9046-d83e4a48a7c1]
-description = "allergic to everything"
+description = "testing for cats allergy -> allergic to everything"
+
+[f9c1b8e7-7dc5-4887-aa93-cebdcc29dd8f]
+description = "list when: -> no allergies"
+
+[9e1a4364-09a6-4d94-990f-541a94a4c1e8]
+description = "list when: -> just eggs"
+
+[8851c973-805e-4283-9e01-d0c0da0e4695]
+description = "list when: -> just peanuts"
+
+[2c8943cb-005e-435f-ae11-3e8fb558ea98]
+description = "list when: -> just strawberries"
+
+[6fa95d26-044c-48a9-8a7b-9ee46ec32c5c]
+description = "list when: -> eggs and peanuts"
+
+[19890e22-f63f-4c5c-a9fb-fb6eacddfe8e]
+description = "list when: -> more than eggs but not peanuts"
+
+[4b68f470-067c-44e4-889f-c9fe28917d2f]
+description = "list when: -> lots of stuff"
+
+[0881b7c5-9efa-4530-91bd-68370d054bc7]
+description = "list when: -> everything"
+
+[12ce86de-b347-42a0-ab7c-2e0570f0c65b]
+description = "list when: -> no allergen score parts"
+
+[93c2df3e-4f55-4fed-8116-7513092819cd]
+description = "list when: -> no allergen score parts without highest valid score"
diff --git a/exercises/practice/allergies/tests/allergies.rs b/exercises/practice/allergies/tests/allergies.rs
index da57d7c60..ffcae1739 100644
--- a/exercises/practice/allergies/tests/allergies.rs
+++ b/exercises/practice/allergies/tests/allergies.rs
@@ -15,85 +15,389 @@ fn compare_allergy_vectors(expected: &[Allergen], actual: &[Allergen]) {
 }
 
 #[test]
-fn is_not_allergic_to_anything() {
+
+fn not_allergic_to_anything_eggs() {
     let allergies = Allergies::new(0);
-    assert!(!allergies.is_allergic_to(&Allergen::Peanuts));
-    assert!(!allergies.is_allergic_to(&Allergen::Cats));
-    assert!(!allergies.is_allergic_to(&Allergen::Strawberries));
+    assert!(!allergies.is_allergic_to(&Allergen::Eggs))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_only_to_eggs_eggs() {
+    let allergies = Allergies::new(1);
+    assert!(allergies.is_allergic_to(&Allergen::Eggs))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_eggs_and_something_else_eggs() {
+    let allergies = Allergies::new(3);
+    assert!(allergies.is_allergic_to(&Allergen::Eggs))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_something_but_not_eggs_eggs() {
+    let allergies = Allergies::new(2);
+    assert!(!allergies.is_allergic_to(&Allergen::Eggs))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_everything_eggs() {
+    let allergies = Allergies::new(255);
+    assert!(allergies.is_allergic_to(&Allergen::Eggs))
+}
+
+#[test]
+#[ignore]
+
+fn not_allergic_to_anything_peanuts() {
+    let allergies = Allergies::new(0);
+    assert!(!allergies.is_allergic_to(&Allergen::Peanuts))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_only_to_peanuts_peanuts() {
+    let allergies = Allergies::new(2);
+    assert!(allergies.is_allergic_to(&Allergen::Peanuts))
 }
 
 #[test]
 #[ignore]
-fn is_allergic_to_eggs() {
-    assert!(Allergies::new(1).is_allergic_to(&Allergen::Eggs));
+
+fn allergic_to_peanuts_and_something_else_peanuts() {
+    let allergies = Allergies::new(7);
+    assert!(allergies.is_allergic_to(&Allergen::Peanuts))
 }
 
 #[test]
 #[ignore]
-fn is_allergic_to_eggs_and_shellfish_but_not_strawberries() {
+
+fn allergic_to_something_but_not_peanuts_peanuts() {
     let allergies = Allergies::new(5);
-    assert!(allergies.is_allergic_to(&Allergen::Eggs));
-    assert!(allergies.is_allergic_to(&Allergen::Shellfish));
-    assert!(!allergies.is_allergic_to(&Allergen::Strawberries));
+    assert!(!allergies.is_allergic_to(&Allergen::Peanuts))
 }
 
 #[test]
 #[ignore]
-fn no_allergies_at_all() {
-    let expected = &[];
+
+fn allergic_to_everything_peanuts() {
+    let allergies = Allergies::new(255);
+    assert!(allergies.is_allergic_to(&Allergen::Peanuts))
+}
+
+#[test]
+#[ignore]
+
+fn not_allergic_to_anything_shellfish() {
+    let allergies = Allergies::new(0);
+    assert!(!allergies.is_allergic_to(&Allergen::Shellfish))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_only_to_shellfish_shellfish() {
+    let allergies = Allergies::new(4);
+    assert!(allergies.is_allergic_to(&Allergen::Shellfish))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_shellfish_and_something_else_shellfish() {
+    let allergies = Allergies::new(14);
+    assert!(allergies.is_allergic_to(&Allergen::Shellfish))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_something_but_not_shellfish_shellfish() {
+    let allergies = Allergies::new(10);
+    assert!(!allergies.is_allergic_to(&Allergen::Shellfish))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_everything_shellfish() {
+    let allergies = Allergies::new(255);
+    assert!(allergies.is_allergic_to(&Allergen::Shellfish))
+}
+
+#[test]
+#[ignore]
+
+fn not_allergic_to_anything_strawberries() {
+    let allergies = Allergies::new(0);
+    assert!(!allergies.is_allergic_to(&Allergen::Strawberries))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_only_to_strawberries_strawberries() {
+    let allergies = Allergies::new(8);
+    assert!(allergies.is_allergic_to(&Allergen::Strawberries))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_strawberries_and_something_else_strawberries() {
+    let allergies = Allergies::new(28);
+    assert!(allergies.is_allergic_to(&Allergen::Strawberries))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_something_but_not_strawberries_strawberries() {
+    let allergies = Allergies::new(20);
+    assert!(!allergies.is_allergic_to(&Allergen::Strawberries))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_everything_strawberries() {
+    let allergies = Allergies::new(255);
+    assert!(allergies.is_allergic_to(&Allergen::Strawberries))
+}
+
+#[test]
+#[ignore]
+
+fn not_allergic_to_anything_tomatoes() {
+    let allergies = Allergies::new(0);
+    assert!(!allergies.is_allergic_to(&Allergen::Tomatoes))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_only_to_tomatoes_tomatoes() {
+    let allergies = Allergies::new(16);
+    assert!(allergies.is_allergic_to(&Allergen::Tomatoes))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_tomatoes_and_something_else_tomatoes() {
+    let allergies = Allergies::new(56);
+    assert!(allergies.is_allergic_to(&Allergen::Tomatoes))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_something_but_not_tomatoes_tomatoes() {
+    let allergies = Allergies::new(40);
+    assert!(!allergies.is_allergic_to(&Allergen::Tomatoes))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_everything_tomatoes() {
+    let allergies = Allergies::new(255);
+    assert!(allergies.is_allergic_to(&Allergen::Tomatoes))
+}
+
+#[test]
+#[ignore]
+
+fn not_allergic_to_anything_chocolate() {
+    let allergies = Allergies::new(0);
+    assert!(!allergies.is_allergic_to(&Allergen::Chocolate))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_only_to_chocolate_chocolate() {
+    let allergies = Allergies::new(32);
+    assert!(allergies.is_allergic_to(&Allergen::Chocolate))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_chocolate_and_something_else_chocolate() {
+    let allergies = Allergies::new(112);
+    assert!(allergies.is_allergic_to(&Allergen::Chocolate))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_something_but_not_chocolate_chocolate() {
+    let allergies = Allergies::new(80);
+    assert!(!allergies.is_allergic_to(&Allergen::Chocolate))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_everything_chocolate() {
+    let allergies = Allergies::new(255);
+    assert!(allergies.is_allergic_to(&Allergen::Chocolate))
+}
+
+#[test]
+#[ignore]
+
+fn not_allergic_to_anything_pollen() {
+    let allergies = Allergies::new(0);
+    assert!(!allergies.is_allergic_to(&Allergen::Pollen))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_only_to_pollen_pollen() {
+    let allergies = Allergies::new(64);
+    assert!(allergies.is_allergic_to(&Allergen::Pollen))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_pollen_and_something_else_pollen() {
+    let allergies = Allergies::new(224);
+    assert!(allergies.is_allergic_to(&Allergen::Pollen))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_something_but_not_pollen_pollen() {
+    let allergies = Allergies::new(160);
+    assert!(!allergies.is_allergic_to(&Allergen::Pollen))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_everything_pollen() {
+    let allergies = Allergies::new(255);
+    assert!(allergies.is_allergic_to(&Allergen::Pollen))
+}
+
+#[test]
+#[ignore]
+
+fn not_allergic_to_anything_cats() {
+    let allergies = Allergies::new(0);
+    assert!(!allergies.is_allergic_to(&Allergen::Cats))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_only_to_cats_cats() {
+    let allergies = Allergies::new(128);
+    assert!(allergies.is_allergic_to(&Allergen::Cats))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_cats_and_something_else_cats() {
+    let allergies = Allergies::new(192);
+    assert!(allergies.is_allergic_to(&Allergen::Cats))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_something_but_not_cats_cats() {
+    let allergies = Allergies::new(64);
+    assert!(!allergies.is_allergic_to(&Allergen::Cats))
+}
+
+#[test]
+#[ignore]
+
+fn allergic_to_everything_cats() {
+    let allergies = Allergies::new(255);
+    assert!(allergies.is_allergic_to(&Allergen::Cats))
+}
+
+#[test]
+#[ignore]
+
+fn no_allergies() {
     let allergies = Allergies::new(0).allergies();
+    let expected = &[];
 
     compare_allergy_vectors(expected, &allergies);
 }
 
 #[test]
 #[ignore]
-fn allergic_to_just_eggs() {
-    let expected = &[Allergen::Eggs];
+
+fn just_eggs() {
     let allergies = Allergies::new(1).allergies();
+    let expected = &[Allergen::Eggs];
 
     compare_allergy_vectors(expected, &allergies);
 }
 
 #[test]
 #[ignore]
-fn allergic_to_just_peanuts() {
-    let expected = &[Allergen::Peanuts];
+
+fn just_peanuts() {
     let allergies = Allergies::new(2).allergies();
+    let expected = &[Allergen::Peanuts];
 
     compare_allergy_vectors(expected, &allergies);
 }
 
 #[test]
 #[ignore]
-fn allergic_to_just_strawberries() {
-    let expected = &[Allergen::Strawberries];
+
+fn just_strawberries() {
     let allergies = Allergies::new(8).allergies();
+    let expected = &[Allergen::Strawberries];
 
     compare_allergy_vectors(expected, &allergies);
 }
 
 #[test]
 #[ignore]
-fn allergic_to_eggs_and_peanuts() {
-    let expected = &[Allergen::Eggs, Allergen::Peanuts];
+
+fn eggs_and_peanuts() {
     let allergies = Allergies::new(3).allergies();
+    let expected = &[Allergen::Eggs, Allergen::Peanuts];
 
     compare_allergy_vectors(expected, &allergies);
 }
 
 #[test]
 #[ignore]
-fn allergic_to_eggs_and_shellfish() {
-    let expected = &[Allergen::Eggs, Allergen::Shellfish];
+
+fn more_than_eggs_but_not_peanuts() {
     let allergies = Allergies::new(5).allergies();
+    let expected = &[Allergen::Eggs, Allergen::Shellfish];
 
     compare_allergy_vectors(expected, &allergies);
 }
 
 #[test]
 #[ignore]
-fn allergic_to_many_things() {
+
+fn lots_of_stuff() {
+    let allergies = Allergies::new(248).allergies();
     let expected = &[
         Allergen::Strawberries,
         Allergen::Tomatoes,
@@ -101,14 +405,15 @@ fn allergic_to_many_things() {
         Allergen::Pollen,
         Allergen::Cats,
     ];
-    let allergies = Allergies::new(248).allergies();
 
     compare_allergy_vectors(expected, &allergies);
 }
 
 #[test]
 #[ignore]
-fn allergic_to_everything() {
+
+fn everything() {
+    let allergies = Allergies::new(255).allergies();
     let expected = &[
         Allergen::Eggs,
         Allergen::Peanuts,
@@ -119,14 +424,15 @@ fn allergic_to_everything() {
         Allergen::Pollen,
         Allergen::Cats,
     ];
-    let allergies = Allergies::new(255).allergies();
 
     compare_allergy_vectors(expected, &allergies);
 }
 
 #[test]
 #[ignore]
-fn scores_over_255_do_not_trigger_false_positives() {
+
+fn no_allergen_score_parts() {
+    let allergies = Allergies::new(509).allergies();
     let expected = &[
         Allergen::Eggs,
         Allergen::Shellfish,
@@ -136,7 +442,16 @@ fn scores_over_255_do_not_trigger_false_positives() {
         Allergen::Pollen,
         Allergen::Cats,
     ];
-    let allergies = Allergies::new(509).allergies();
+
+    compare_allergy_vectors(expected, &allergies);
+}
+
+#[test]
+#[ignore]
+
+fn no_allergen_score_parts_without_highest_valid_score() {
+    let allergies = Allergies::new(257).allergies();
+    let expected = &[Allergen::Eggs];
 
     compare_allergy_vectors(expected, &allergies);
 }