From 14f31d776772614f1924b399aa2bf41dafb3f667 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Nenad=20Misi=C4=87?= Date: Fri, 28 Jun 2024 18:04:47 +0200 Subject: [PATCH] Add allergies exercise (#48) * fix bin/verify-exercises to work for all files as well * add allergies exercise * refactor tests --- bin/verify-exercises | 2 +- config.json | 12 + .../practice/allergies/.docs/instructions.md | 27 ++ .../practice/allergies/.meta/config.json | 20 + .../practice/allergies/.meta/example.cairo | 66 +++ exercises/practice/allergies/.meta/tests.toml | 160 +++++++ exercises/practice/allergies/Scarb.toml | 7 + exercises/practice/allergies/src/lib.cairo | 34 ++ exercises/practice/allergies/src/tests.cairo | 406 ++++++++++++++++++ 9 files changed, 733 insertions(+), 1 deletion(-) create mode 100644 exercises/practice/allergies/.docs/instructions.md create mode 100644 exercises/practice/allergies/.meta/config.json create mode 100644 exercises/practice/allergies/.meta/example.cairo create mode 100644 exercises/practice/allergies/.meta/tests.toml create mode 100644 exercises/practice/allergies/Scarb.toml create mode 100644 exercises/practice/allergies/src/lib.cairo create mode 100644 exercises/practice/allergies/src/tests.cairo diff --git a/bin/verify-exercises b/bin/verify-exercises index 89239d47..01e54f79 100755 --- a/bin/verify-exercises +++ b/bin/verify-exercises @@ -17,7 +17,7 @@ slug="${1:-*}" verify_exercise() { exercises_path="$repo/exercises/$1/$slug" - if ! test -d "$exercises_path"; then + if ! [[ "$slug" == "*" || -d "$exercises_path" ]]; then return fi source_file_name="$2" diff --git a/config.json b/config.json index eab90ceb..757e7942 100644 --- a/config.json +++ b/config.json @@ -159,6 +159,18 @@ ], "prerequisites": [], "difficulty": 4 + }, + { + "slug": "allergies", + "name": "Allergies", + "uuid": "ef701095-b324-49f0-913e-2fb2e1f5f27a", + "practices": [ + "enums", + "structs", + "traits" + ], + "prerequisites": [], + "difficulty": 4 } ], "foregone": [ diff --git a/exercises/practice/allergies/.docs/instructions.md b/exercises/practice/allergies/.docs/instructions.md new file mode 100644 index 00000000..daf8cfde --- /dev/null +++ b/exercises/practice/allergies/.docs/instructions.md @@ -0,0 +1,27 @@ +# Instructions + +Given a person's allergy score, determine whether or not they're allergic to a given item, and their full list of allergies. + +An allergy test produces a single numeric score which contains the information about all the allergies the person has (that they were tested for). + +The list of items (and their value) that were tested are: + +- eggs (1) +- peanuts (2) +- shellfish (4) +- strawberries (8) +- tomatoes (16) +- chocolate (32) +- pollen (64) +- cats (128) + +So if Tom is allergic to peanuts and chocolate, he gets a score of 34. + +Now, given just that score of 34, your program should be able to say: + +- Whether Tom is allergic to any one of those allergens listed above. +- All the allergens Tom is allergic to. + +Note: a given score may include allergens **not** listed above (i.e. allergens that score 256, 512, 1024, etc.). +Your program should ignore those components of the score. +For example, if the allergy score is 257, your program should only report the eggs (1) allergy. diff --git a/exercises/practice/allergies/.meta/config.json b/exercises/practice/allergies/.meta/config.json new file mode 100644 index 00000000..9e1c5bbc --- /dev/null +++ b/exercises/practice/allergies/.meta/config.json @@ -0,0 +1,20 @@ +{ + "authors": [ + "misicnenad" + ], + "files": { + "solution": [ + "src/lib.cairo", + "Scarb.toml" + ], + "test": [ + "src/tests.cairo" + ], + "example": [ + ".meta/example.cairo" + ] + }, + "blurb": "Given a person's allergy score, determine whether or not they're allergic to a given item, and their full list of allergies.", + "source": "Exercise by the JumpstartLab team for students at The Turing School of Software and Design.", + "source_url": "https://turing.edu" +} diff --git a/exercises/practice/allergies/.meta/example.cairo b/exercises/practice/allergies/.meta/example.cairo new file mode 100644 index 00000000..f85c9801 --- /dev/null +++ b/exercises/practice/allergies/.meta/example.cairo @@ -0,0 +1,66 @@ +use alexandria_math::pow; + +#[derive(Drop)] +pub struct Allergies { + pub score: u32, +} + +#[derive(Drop, Debug, PartialEq)] +pub enum Allergen { + Eggs, + Peanuts, + Shellfish, + Strawberries, + Tomatoes, + Chocolate, + Pollen, + Cats, +} + +#[generate_trait] +pub impl AllergiesImpl of AllergiesTrait { + fn new(score: u32) -> Allergies { + Allergies { score } + } + + fn is_allergic_to(self: @Allergies, allergen: @Allergen) -> bool { + let allergens = AllergiesImpl::allergens().span(); + let mut index = 0; + while let Option::Some(next_allergen) = allergens + .get(index) { + if next_allergen.unbox() == allergen { + break; + } + index += 1; + }; + index != allergens.len() && (*self.score & pow(2, index)) != 0 + } + + fn allergies(self: @Allergies) -> Array { + let mut allergens = AllergiesImpl::allergens(); + let mut result: Array = array![]; + while let Option::Some(allergen) = allergens + .pop_front() { + if self.is_allergic_to(@allergen) { + result.append(allergen); + } + }; + result + } + + fn allergens() -> Array { + array![ + Allergen::Eggs, + Allergen::Peanuts, + Allergen::Shellfish, + Allergen::Strawberries, + Allergen::Tomatoes, + Allergen::Chocolate, + Allergen::Pollen, + Allergen::Cats, + ] + } +} + +#[cfg(test)] +mod tests; diff --git a/exercises/practice/allergies/.meta/tests.toml b/exercises/practice/allergies/.meta/tests.toml new file mode 100644 index 00000000..799ab856 --- /dev/null +++ b/exercises/practice/allergies/.meta/tests.toml @@ -0,0 +1,160 @@ +# 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 = "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 = "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 = "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 = "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 = "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 = "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 = "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 = "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/Scarb.toml b/exercises/practice/allergies/Scarb.toml new file mode 100644 index 00000000..13348cec --- /dev/null +++ b/exercises/practice/allergies/Scarb.toml @@ -0,0 +1,7 @@ +[package] +name = "allergies" +version = "0.1.0" +edition = "2023_11" + +[dependencies] +alexandria_math = { git = "https://github.com/keep-starknet-strange/alexandria.git" } diff --git a/exercises/practice/allergies/src/lib.cairo b/exercises/practice/allergies/src/lib.cairo new file mode 100644 index 00000000..cf1dfa8b --- /dev/null +++ b/exercises/practice/allergies/src/lib.cairo @@ -0,0 +1,34 @@ +#[derive(Drop)] +pub struct Allergies {} + +#[derive(Drop, Debug, PartialEq)] +pub enum Allergen { + Eggs, + Peanuts, + Shellfish, + Strawberries, + Tomatoes, + Chocolate, + Pollen, + Cats, +} + +#[generate_trait] +pub impl AllergiesImpl of AllergiesTrait { + fn new(score: u32) -> Allergies { + panic!("Given the '{score}' score, construct a new Allergies struct.") + } + + fn is_allergic_to(self: @Allergies, allergen: @Allergen) -> bool { + panic!("Determine if the patient is allergic to the '{allergen:?}' allergen.") + } + + fn allergies(self: @Allergies) -> Array { + panic!( + "Return the list of allergens contained within the score with which the Allergies struct was made." + ) + } +} + +#[cfg(test)] +mod tests; diff --git a/exercises/practice/allergies/src/tests.cairo b/exercises/practice/allergies/src/tests.cairo new file mode 100644 index 00000000..f88445ee --- /dev/null +++ b/exercises/practice/allergies/src/tests.cairo @@ -0,0 +1,406 @@ +mod testing_for_eggs_allergy { + use allergies::{Allergen, AllergiesTrait}; + + #[test] + fn not_allergic_to_anything() { + let allergies = AllergiesTrait::new(0); + assert!(!allergies.is_allergic_to(@Allergen::Eggs)) + } + + #[test] + fn allergic_only_to_eggs() { + let allergies = AllergiesTrait::new(1); + assert!(allergies.is_allergic_to(@Allergen::Eggs)) + } + + #[test] + fn allergic_to_eggs_and_something_else() { + let allergies = AllergiesTrait::new(3); + assert!(allergies.is_allergic_to(@Allergen::Eggs)) + } + + #[test] + fn allergic_to_something_but_not_eggs() { + let allergies = AllergiesTrait::new(2); + assert!(!allergies.is_allergic_to(@Allergen::Eggs)) + } + + #[test] + fn allergic_to_everything() { + let allergies = AllergiesTrait::new(255); + assert!(allergies.is_allergic_to(@Allergen::Eggs)) + } +} + +mod testing_for_peanuts_allergy { + use allergies::{Allergen, AllergiesTrait}; + + #[test] + fn not_allergic_to_anything() { + let allergies = AllergiesTrait::new(0); + assert!(!allergies.is_allergic_to(@Allergen::Peanuts)) + } + + #[test] + fn allergic_only_to_peanuts() { + let allergies = AllergiesTrait::new(2); + assert!(allergies.is_allergic_to(@Allergen::Peanuts)) + } + + #[test] + fn allergic_to_peanuts_and_something_else() { + let allergies = AllergiesTrait::new(7); + assert!(allergies.is_allergic_to(@Allergen::Peanuts)) + } + + #[test] + fn allergic_to_something_but_not_peanuts() { + let allergies = AllergiesTrait::new(5); + assert!(!allergies.is_allergic_to(@Allergen::Peanuts)) + } + + #[test] + fn allergic_to_everything() { + let allergies = AllergiesTrait::new(255); + assert!(allergies.is_allergic_to(@Allergen::Peanuts)) + } +} + +mod testing_for_shellfish_allergy { + use allergies::{Allergen, AllergiesTrait}; + + #[test] + fn not_allergic_to_anything() { + let allergies = AllergiesTrait::new(0); + assert!(!allergies.is_allergic_to(@Allergen::Shellfish)) + } + + #[test] + fn allergic_only_to_shellfish() { + let allergies = AllergiesTrait::new(4); + assert!(allergies.is_allergic_to(@Allergen::Shellfish)) + } + + #[test] + fn allergic_to_shellfish_and_something_else() { + let allergies = AllergiesTrait::new(14); + assert!(allergies.is_allergic_to(@Allergen::Shellfish)) + } + + #[test] + fn allergic_to_something_but_not_shellfish() { + let allergies = AllergiesTrait::new(10); + assert!(!allergies.is_allergic_to(@Allergen::Shellfish)) + } + + #[test] + fn allergic_to_everything() { + let allergies = AllergiesTrait::new(255); + assert!(allergies.is_allergic_to(@Allergen::Shellfish)) + } +} + +mod testing_for_strawberries_allergy { + use allergies::{Allergen, AllergiesTrait}; + + #[test] + fn not_allergic_to_anything() { + let allergies = AllergiesTrait::new(0); + assert!(!allergies.is_allergic_to(@Allergen::Strawberries)) + } + + #[test] + fn allergic_only_to_strawberries() { + let allergies = AllergiesTrait::new(8); + assert!(allergies.is_allergic_to(@Allergen::Strawberries)) + } + + #[test] + fn allergic_to_strawberries_and_something_else() { + let allergies = AllergiesTrait::new(28); + assert!(allergies.is_allergic_to(@Allergen::Strawberries)) + } + + #[test] + fn allergic_to_something_but_not_strawberries() { + let allergies = AllergiesTrait::new(20); + assert!(!allergies.is_allergic_to(@Allergen::Strawberries)) + } + + #[test] + fn allergic_to_everything() { + let allergies = AllergiesTrait::new(255); + assert!(allergies.is_allergic_to(@Allergen::Strawberries)) + } +} + +mod testing_for_tomatoes_allergy { + use allergies::{Allergen, AllergiesTrait}; + + #[test] + fn not_allergic_to_anything() { + let allergies = AllergiesTrait::new(0); + assert!(!allergies.is_allergic_to(@Allergen::Tomatoes)) + } + + #[test] + fn allergic_only_to_tomatoes() { + let allergies = AllergiesTrait::new(16); + assert!(allergies.is_allergic_to(@Allergen::Tomatoes)) + } + + #[test] + fn allergic_to_tomatoes_and_something_else() { + let allergies = AllergiesTrait::new(56); + assert!(allergies.is_allergic_to(@Allergen::Tomatoes)) + } + + #[test] + fn allergic_to_something_but_not_tomatoes() { + let allergies = AllergiesTrait::new(40); + assert!(!allergies.is_allergic_to(@Allergen::Tomatoes)) + } + + #[test] + fn allergic_to_everything() { + let allergies = AllergiesTrait::new(255); + assert!(allergies.is_allergic_to(@Allergen::Tomatoes)) + } +} + +mod testing_for_chocolate_allergy { + use allergies::{Allergen, AllergiesTrait}; + + #[test] + fn not_allergic_to_anything() { + let allergies = AllergiesTrait::new(0); + assert!(!allergies.is_allergic_to(@Allergen::Chocolate)) + } + + #[test] + fn allergic_only_to_chocolate() { + let allergies = AllergiesTrait::new(32); + assert!(allergies.is_allergic_to(@Allergen::Chocolate)) + } + + #[test] + fn allergic_to_chocolate_and_something_else() { + let allergies = AllergiesTrait::new(112); + assert!(allergies.is_allergic_to(@Allergen::Chocolate)) + } + + #[test] + fn allergic_to_something_but_not_chocolate() { + let allergies = AllergiesTrait::new(80); + assert!(!allergies.is_allergic_to(@Allergen::Chocolate)) + } + + #[test] + fn allergic_to_everything() { + let allergies = AllergiesTrait::new(255); + assert!(allergies.is_allergic_to(@Allergen::Chocolate)) + } +} + +mod testing_for_pollen_allergy { + use allergies::{Allergen, AllergiesTrait}; + + #[test] + fn not_allergic_to_anything() { + let allergies = AllergiesTrait::new(0); + assert!(!allergies.is_allergic_to(@Allergen::Pollen)) + } + + #[test] + fn allergic_only_to_pollen() { + let allergies = AllergiesTrait::new(64); + assert!(allergies.is_allergic_to(@Allergen::Pollen)) + } + + #[test] + fn allergic_to_pollen_and_something_else() { + let allergies = AllergiesTrait::new(224); + assert!(allergies.is_allergic_to(@Allergen::Pollen)) + } + + #[test] + fn allergic_to_something_but_not_pollen() { + let allergies = AllergiesTrait::new(160); + assert!(!allergies.is_allergic_to(@Allergen::Pollen)) + } + + #[test] + fn allergic_to_everything() { + let allergies = AllergiesTrait::new(255); + assert!(allergies.is_allergic_to(@Allergen::Pollen)) + } +} + +mod testing_for_cats_allergy { + use allergies::{Allergen, AllergiesTrait}; + + #[test] + fn not_allergic_to_anything() { + let allergies = AllergiesTrait::new(0); + assert!(!allergies.is_allergic_to(@Allergen::Cats)) + } + + #[test] + fn allergic_only_to_cats() { + let allergies = AllergiesTrait::new(128); + assert!(allergies.is_allergic_to(@Allergen::Cats)) + } + + #[test] + fn allergic_to_cats_and_something_else() { + let allergies = AllergiesTrait::new(192); + assert!(allergies.is_allergic_to(@Allergen::Cats)) + } + + #[test] + fn allergic_to_something_but_not_cats() { + let allergies = AllergiesTrait::new(64); + assert!(!allergies.is_allergic_to(@Allergen::Cats)) + } + + #[test] + fn allergic_to_everything() { + let allergies = AllergiesTrait::new(255); + assert!(allergies.is_allergic_to(@Allergen::Cats)) + } +} + +mod list_when { + use allergies::{Allergen, AllergiesTrait}; + + fn compare_allergy_vectors(expected: @Array, actual: @Array) { + if actual.len() != expected.len() { + panic!( + "Allergy vectors are of different lengths\n expected {expected:?}\n got {actual:?}" + ); + } + + let mut i = 0; + while let Option::Some(expected_elem) = expected + .get(i) { + let mut contains = false; + let mut j = 0; + while let Option::Some(actual_elem) = actual + .get(j) { + if actual_elem.unbox() == expected_elem.unbox() { + contains = true; + break; + } + j += 1; + }; + if !contains { + panic!("Allergen missing\n {expected_elem:?} should be in {actual:?}"); + } + i += 1; + }; + } + + + #[test] + fn no_allergies() { + let allergies = AllergiesTrait::new(0).allergies(); + let expected = @array![]; + + compare_allergy_vectors(expected, @allergies); + } + + #[test] + fn just_eggs() { + let allergies = AllergiesTrait::new(1).allergies(); + let expected = @array![Allergen::Eggs]; + + compare_allergy_vectors(expected, @allergies); + } + + #[test] + fn just_peanuts() { + let allergies = AllergiesTrait::new(2).allergies(); + let expected = @array![Allergen::Peanuts]; + + compare_allergy_vectors(expected, @allergies); + } + + #[test] + fn just_strawberries() { + let allergies = AllergiesTrait::new(8).allergies(); + let expected = @array![Allergen::Strawberries]; + + compare_allergy_vectors(expected, @allergies); + } + + #[test] + fn eggs_and_peanuts() { + let allergies = AllergiesTrait::new(3).allergies(); + let expected = @array![Allergen::Eggs, Allergen::Peanuts]; + + compare_allergy_vectors(expected, @allergies); + } + + #[test] + fn more_than_eggs_but_not_peanuts() { + let allergies = AllergiesTrait::new(5).allergies(); + let expected = @array![Allergen::Eggs, Allergen::Shellfish]; + + compare_allergy_vectors(expected, @allergies); + } + + #[test] + fn lots_of_stuff() { + let allergies = AllergiesTrait::new(248).allergies(); + let expected = @array![ + Allergen::Strawberries, + Allergen::Tomatoes, + Allergen::Chocolate, + Allergen::Pollen, + Allergen::Cats, + ]; + + compare_allergy_vectors(expected, @allergies); + } + + #[test] + fn everything() { + let allergies = AllergiesTrait::new(255).allergies(); + let expected = @array![ + Allergen::Eggs, + Allergen::Peanuts, + Allergen::Shellfish, + Allergen::Strawberries, + Allergen::Tomatoes, + Allergen::Chocolate, + Allergen::Pollen, + Allergen::Cats, + ]; + + compare_allergy_vectors(expected, @allergies); + } + + #[test] + fn no_allergen_score_parts() { + let allergies = AllergiesTrait::new(509).allergies(); + let expected = @array![ + Allergen::Eggs, + Allergen::Shellfish, + Allergen::Strawberries, + Allergen::Tomatoes, + Allergen::Chocolate, + Allergen::Pollen, + Allergen::Cats, + ]; + + compare_allergy_vectors(expected, @allergies); + } + + #[test] + fn no_allergen_score_parts_without_highest_valid_score() { + let allergies = AllergiesTrait::new(257).allergies(); + let expected = @array![Allergen::Eggs]; + + compare_allergy_vectors(expected, @allergies); + } +}