From e68973c1b17854e138bc84c81cd0c750d0a388f7 Mon Sep 17 00:00:00 2001 From: Tom Hicks Date: Sat, 15 Apr 2023 16:27:23 -0700 Subject: [PATCH] Documents Abilities. Adds full test coverage for Abilities. --- sbf-cpp/Abilities.cpp | 168 +++++++-- sbf-cpp/Abilities.h | 181 +++++++--- sbf-cpp/Abilities_test.cpp | 708 +++++++++++++++++++++++++++++++++---- 3 files changed, 901 insertions(+), 156 deletions(-) diff --git a/sbf-cpp/Abilities.cpp b/sbf-cpp/Abilities.cpp index a216b3f..cb6485f 100644 --- a/sbf-cpp/Abilities.cpp +++ b/sbf-cpp/Abilities.cpp @@ -3,32 +3,158 @@ #include namespace SBF { - using std::wstring; + using std::string; + using std::ostream; + using std::vector; - - // template - // T r(int a, int b) { - // auto s = [](int a, int b){return (T)nullptr;} - // auto t = wstring(L"asdf"); - // return s(a,b); - // } - - void testMe() { - auto l = [](int a, int b){return;}; - l(1,2); - // std::cout << "l: " << l(1,2) << std::endl; - // auto q = r(1, 2); - // std::cout << "q: " << q(1,2) << std::endl; + ostream& operator<<(ostream& os, const AbilityType& abilityGroup) { + os << "AbilityGroup: {id: " << abilityGroup.id + << ", singular: \"" << abilityGroup.singular + << "\", plural: \"" << abilityGroup.plural << "\"}"; + return os; } - const wstring GetAbilityLabel(int abilityGroupId, int abilityId) { + + bool operator==(const AbilityType& left, const AbilityType& right) { + return left.id == right.id && + left.singular == right.singular && + left.plural == right.plural; + } + + void FillAbilities(vector& abilities) { + abilities.clear(); + abilities.push_back(kAbilityGroupTalents); + abilities.push_back(kAbilityGroupSkills); + abilities.push_back(kAbilityGroupKnowledges); + } + + void FillAbilitiesForAbilityGroup(vector& abilities, int abilityGroupId) { + abilities.clear(); + int numAbilities = GetNumItemsForAbilityGroup(abilityGroupId); switch (abilityGroupId) { case kAbilityTalentsId: - return kTalents[abilityId]; + for (int talentId = 0; talentId <= numAbilities; talentId++) { + if (talentId >= 0 && talentId <= kTalentsCount) { + abilities.push_back(kTalents[talentId]); + } + } + break; case kAbilitySkillsId: - return kSkills[abilityId]; + for (int skillId = 0; skillId <= numAbilities; skillId++) { + if (skillId >= 0 && skillId <= kSkillsCount) { + abilities.push_back(kSkills[skillId]); + } + } + break; case kAbilityKnowledgesId: - return kKnowledges[abilityId]; - }; - return wstring() + L""; + for (int knowledgeId = 0; knowledgeId <= numAbilities; knowledgeId++) { + if (knowledgeId >= 0 && knowledgeId <= kKnowledgesCount) { + abilities.push_back(kKnowledges[knowledgeId]); + } + } + break; + } } + + void FillAbilityLabels(vector& labels, int abilityGroupId) { + labels.clear(); + switch (abilityGroupId) { + case kAbilityTalentsId: + FillTalentLabels(labels); + break; + case kAbilitySkillsId: + FillSkillLabels(labels); + break; + case kAbilityKnowledgesId: + FillKnowledgeLabels(labels); + break; + } + } + + void FillKnowledgeLabels(vector& labels) { + labels.clear(); + int numAbilities = GetNumItemsForAbilityGroup(kAbilityKnowledgesId); + for (int knowledgeId = 0; knowledgeId <= numAbilities; knowledgeId++) { + if (knowledgeId >= 0 && knowledgeId <= kKnowledgesCount) { + labels.push_back(kKnowledges[knowledgeId]); + } + } + } + + void FillSkillLabels(vector& labels) { + labels.clear(); + int numAbilities = GetNumItemsForAbilityGroup(kAbilitySkillsId); + for (int skillId = 0; skillId <= numAbilities; skillId++) { + if (skillId >= 0 && skillId <= kSkillsCount) { + labels.push_back(kSkills[skillId]); + } + } + } + + void FillTalentLabels(vector& labels) { + labels.clear(); + int numAbilities = GetNumItemsForAbilityGroup(kAbilityTalentsId); + for (int talentId = 0; talentId <= numAbilities; talentId++) { + if (talentId >= 0 && talentId <= kTalentsCount) { + labels.push_back(kTalents[talentId]); + } + } + } + + const AbilityType& GetAbility(int abilityGroupId) { + switch(abilityGroupId) { + case kAbilityTalentsId: + return kAbilityGroupTalents; + case kAbilitySkillsId: + return kAbilityGroupSkills; + case kAbilityKnowledgesId: + return kAbilityGroupKnowledges; + }; + return kAbilityGroupUnknown; + } + + const string GetAbilityLabel(int abilityGroupId, int abilityId) { + switch (abilityGroupId) { + case kAbilityTalentsId: + return GetTalentLabel(abilityId); + case kAbilitySkillsId: + return GetSkillLabel(abilityId); + case kAbilityKnowledgesId: + return GetKnowledgeLabel(abilityId); + }; + return ""; + } + + const std::string GetKnowledgeLabel(int talentId){ + if (talentId > 0 && talentId <= kKnowledgesCount) { + return kKnowledges[talentId]; + } + return ""; + } + + int GetNumItemsForAbilityGroup(int abilityGroupId) { + switch (abilityGroupId) { + case kAbilityTalentsId: + return kTalentsCount; + case kAbilitySkillsId: + return kSkillsCount; + case kAbilityKnowledgesId: + return kKnowledgesCount; + } + return 0; + } + + const std::string GetSkillLabel(int skillId) { + if (skillId > 0 && skillId <= kSkillsCount) { + return kSkills[skillId]; + } + return ""; + } + + const std::string GetTalentLabel(int talentId) { + if (talentId > 0 && talentId <= kTalentsCount) { + return kTalents[talentId]; + } + return ""; + } + } // End namespace SBF diff --git a/sbf-cpp/Abilities.h b/sbf-cpp/Abilities.h index 5b25bc0..6be9e31 100644 --- a/sbf-cpp/Abilities.h +++ b/sbf-cpp/Abilities.h @@ -5,50 +5,59 @@ namespace SBF { const int kAbilityTalentsId = 1; - const std::wstring kAbilityTalentsSingular = L"Talent"; - const std::wstring kAbilityTalentsPlural = L"Talents"; + const std::string kAbilityTalentsSingular = "Talent"; + const std::string kAbilityTalentsPlural = "Talents"; const int kAbilitySkillsId = 2; - const std::wstring kAbilitySkillsSingular = L"Skill"; - const std::wstring kAbilitySkillsPlural = L"Skills"; + const std::string kAbilitySkillsSingular = "Skill"; + const std::string kAbilitySkillsPlural = "Skills"; const int kAbilityKnowledgesId = 3; - const std::wstring kAbilityKnowledgesSingular = L"Skill"; - const std::wstring kAbilityKnowledgesPlural = L"Skills"; + const std::string kAbilityKnowledgesSingular = "Knowledge"; + const std::string kAbilityKnowledgesPlural = "Knowledges"; const int kAbilitiesCount = 3; + + /// @brief This type represents an ability group such as Talents, Skills or Knowledges. struct AbilityType { + /// @brief The id of this ability group int id; - std::wstring singular; - std::wstring plural; + /// @brief The singular form of this group i.e. Talent. + std::string singular; + /// @brief The plural form of this group i.e. Talents. + std::string plural; }; + const AbilityType kAbilityGroupUnknown = {0, "", ""}; + const AbilityType kAbilityGroupTalents = {kAbilityTalentsId, kAbilityTalentsSingular, kAbilityTalentsPlural}; + const AbilityType kAbilityGroupSkills = {kAbilitySkillsId, kAbilitySkillsSingular, kAbilitySkillsPlural}; + const AbilityType kAbilityGroupKnowledges = {kAbilityKnowledgesId, kAbilityKnowledgesSingular, kAbilityKnowledgesPlural}; const AbilityType kAbilities[] { - {0, L"", L""}, - {kAbilityTalentsId, kAbilityTalentsSingular, kAbilityTalentsPlural}, - {kAbilitySkillsId, kAbilitySkillsSingular, kAbilitySkillsPlural}, - {kAbilityKnowledgesId, kAbilityKnowledgesSingular, kAbilityKnowledgesPlural}, + kAbilityGroupUnknown, + kAbilityGroupTalents, + kAbilityGroupSkills, + kAbilityGroupKnowledges, }; const int kTalentActingId = 1; - const std::wstring kTalentActingLabel = L"Acting"; + const std::string kTalentActingLabel = "Acting"; const int kTalentAlertnessId = 2; - const std::wstring kTalentAlertnessLabel = L"Alertness"; + const std::string kTalentAlertnessLabel = "Alertness"; const int kTalentAthleticsId = 3; - const std::wstring kTalentAthleticsLabel = L"Athletics"; + const std::string kTalentAthleticsLabel = "Athletics"; const int kTalentBrawlId = 4; - const std::wstring kTalentBrawlLabel = L"Brawl"; + const std::string kTalentBrawlLabel = "Brawl"; const int kTalentDodgeId = 5; - const std::wstring kTalentDodgeLabel = L"Dodge"; + const std::string kTalentDodgeLabel = "Dodge"; const int kTalentEmpathyId = 6; - const std::wstring kTalentEmpathyLabel = L"Empathty"; + const std::string kTalentEmpathyLabel = "Empathy"; const int kTalentIntimidationId = 7; - const std::wstring kTalentIntimidationLabel = L"Intimidation"; + const std::string kTalentIntimidationLabel = "Intimidation"; const int kTalentLeadershipId = 8; - const std::wstring kTalentLeadershipLabel = L"Leadership"; + const std::string kTalentLeadershipLabel = "Leadership"; const int kTalentStreetwiseId = 9; - const std::wstring kTalentStreetwiseLabel = L"Streetwise"; + const std::string kTalentStreetwiseLabel = "Streetwise"; const int kTalentSubterfugeId = 10; - const std::wstring kTalentSubterfugeLabel = L"Subterfuge"; + const std::string kTalentSubterfugeLabel = "Subterfuge"; const int kTalentsCount = 10; - const std::wstring kTalents[] = { - L"", + const std::string kTalents[] = { + "", kTalentActingLabel, kTalentAlertnessLabel, kTalentAthleticsLabel, @@ -62,28 +71,28 @@ namespace SBF { }; const int kSkillAnimalKenId = 1; - const std::wstring kSkillAnimalKenLabel = L"AnimalKen"; + const std::string kSkillAnimalKenLabel = "Animal Ken"; const int kSkillDriveId = 2; - const std::wstring kSkillDriveLabel = L"Drive"; + const std::string kSkillDriveLabel = "Drive"; const int kSkillEtiquetteId = 3; - const std::wstring kSkillEtiquetteLabel = L"Etiquette"; + const std::string kSkillEtiquetteLabel = "Etiquette"; const int kSkillFirearmsId = 4; - const std::wstring kSkillFirearmsLabel = L"Firearms"; + const std::string kSkillFirearmsLabel = "Firearms"; const int kSkillMeleeId = 5; - const std::wstring kSkillMeleeLabel = L"Melee"; + const std::string kSkillMeleeLabel = "Melee"; const int kSkillMusicId = 6; - const std::wstring kSkillMusicLabel = L"Music"; + const std::string kSkillMusicLabel = "Music"; const int kSkillRepairId = 7; - const std::wstring kSkillRepairLabel = L"Repair"; + const std::string kSkillRepairLabel = "Repair"; const int kSkillSecurityId = 8; - const std::wstring kSkillSecurityLabel = L"Security"; + const std::string kSkillSecurityLabel = "Security"; const int kSkillStealthId = 9; - const std::wstring kSkillStealthLabel = L"Stealth"; + const std::string kSkillStealthLabel = "Stealth"; const int kSkillSurvivalId = 10; - const std::wstring kSkillSurvivalLabel = L"Survival"; + const std::string kSkillSurvivalLabel = "Survival"; const int kSkillsCount = 10; - const std::wstring kSkills[] = { - L"", + const std::string kSkills[] = { + "", kSkillAnimalKenLabel, kSkillDriveLabel, kSkillEtiquetteLabel, @@ -97,28 +106,28 @@ namespace SBF { }; const int kKnowledgeBureaucracyId = 1; - const std::wstring kKnowledgeBureaucracyLabel = L"Bureaucracy"; + const std::string kKnowledgeBureaucracyLabel = "Bureaucracy"; const int kKnowledgeComputerId = 2; - const std::wstring kKnowledgeComputerLabel = L"Computer"; + const std::string kKnowledgeComputerLabel = "Computer"; const int kKnowledgeFinanceId = 3; - const std::wstring kKnowledgeFinanceLabel = L"Finance"; + const std::string kKnowledgeFinanceLabel = "Finance"; const int kKnowledgeInvestigationId = 4; - const std::wstring kKnowledgeInvestigationLabel = L"Investigation"; + const std::string kKnowledgeInvestigationLabel = "Investigation"; const int kKnowledgeLawId = 5; - const std::wstring kKnowledgeLawLabel = L"Law"; + const std::string kKnowledgeLawLabel = "Law"; const int kKnowledgeLinguisticsId = 6; - const std::wstring kKnowledgeLinguisticsLabel = L"Linguistics"; + const std::string kKnowledgeLinguisticsLabel = "Linguistics"; const int kKnowledgeMedicineId = 7; - const std::wstring kKnowledgeMedicineLabel = L"Medicine"; + const std::string kKnowledgeMedicineLabel = "Medicine"; const int kKnowledgeOccultId = 8; - const std::wstring kKnowledgeOccultLabel = L"Occult"; + const std::string kKnowledgeOccultLabel = "Occult"; const int kKnowledgePoliticsId = 9; - const std::wstring kKnowledgePoliticsLabel = L"Politics"; + const std::string kKnowledgePoliticsLabel = "Politics"; const int kKnowledgeScienceId = 10; - const std::wstring kKnowledgeScienceLabel = L"Science"; + const std::string kKnowledgeScienceLabel = "Science"; const int kKnowledgesCount = 10; - const std::wstring kKnowledges[] = { - L"", + const std::string kKnowledges[] = { + "", kKnowledgeBureaucracyLabel, kKnowledgeComputerLabel, kKnowledgeFinanceLabel, @@ -131,15 +140,73 @@ namespace SBF { kKnowledgeScienceLabel, }; + /// @brief This function writes an AbilityType value to an output stream; + /// @param os The output stream to write to. + /// @param abilityGroup The AbilityType to write. + /// @return Thw output stream for chaining. + std::ostream& operator<<(std::ostream& os, const AbilityType& abilityGroup); + + /// @brief This function compares two AbilityType values for equality. + /// @param left The first AbilityType. + /// @param right The second AbilityType. + /// @return True if left is equal to right and false otherwise. + bool operator==(const AbilityType& left, const AbilityType& right); + + /// @brief Fills the provided vector with all of the available ability groups. + /// @param abilities The vector to fill. It will be cleared before filling. + void FillAbilities(std::vector& abilities); + + /// @brief Fills the provided vector with all of the ability labels in the specified group. + /// @param abilities The vector to fill. It will be cleared before filling. + /// @param abilityGroupId The id of the ability group to fill for. + void FillAbilitiesForAbilityGroup(std::vector& abilities, int abilityGroupId); + + /// @brief Fills the provided vector with all of the ability labels in the specified group. + /// @param labels The vector to fill. It will be cleared before filling. + /// @param abilityGroupId The id of the ability group to fill for. + void FillAbilityLabels(std::vector& labels, int abilityGroupId); + + /// @brief Fills the provided vector with all of the knowledge labels. + /// @param knowledgeLabels The vector to fill. It will be cleared before filling. + void FillKnowledgeLabels(std::vector& knowledgeLabels); + + /// @brief Fills the provided vector with all of the skill labels. + /// @param skillLabels The vector to fill. It will be cleared before filling. + void FillSkillLabels(std::vector& skillLabels); + + /// @brief Fills the provided vector with all of the talent labels. + /// @param talentLabels The vector to fill. It will be cleared before filling. + void FillTalentLabels(std::vector& talentLabels); + + /// @brief Gets an ability group for a given id. + /// @param abilityGroupId The id of the ability group to return. + /// @return The ability group with an id of abilityGroupId. + const AbilityType& GetAbility(int abilityGroupId); + + /// @brief Gets the label for an ability given its ability group (talents/skills/knowledges) and its id (acting, brawl, dodge, ...). + /// @param abilityGroupId The id for the ability group (talents/skills/knowledges). + /// @param abilityId The id for the ability within the ability group (acting, dodge, brawl, ...). + /// @return The label for the specific ability ("Acting"). + const std::string GetAbilityLabel(int abilityGroupId, int abilityId); + + /// @brief Gets the label for a knowledge ability given its id. + /// @param knowledgeId The id of the ability to return the label for. + /// @return The label for the specific ability. + const std::string GetKnowledgeLabel(int talentId); + + /// @brief Gets the number of abilities in an ability group. + /// @param abilityGroupId The id of the ability group to return the number of abilities for. + /// @return The number of abilities in the specific ability group. int GetNumItemsForAbilityGroup(int abilityGroupId); - const AbilityType GetAbility(int abilityId); - void FillAbilities(std::vector abilities); - const std::wstring GetTalentLabel(int talentId); - const std::wstring GetSkillLabel(int talentId); - const std::wstring GetKnowledgeLabel(int talentId); - const std::wstring GetAbilityLabel(int abilityGroupId, int abilityId); - void FillTalentLabels(std::vector talentLabels); - void FillSkillLabels(std::vector skillLabels); - void FillKnowledgeLabels(std::vector knowledgeLabels); + + /// @brief Gets the label for a skill ability given its id. + /// @param talentId The id of the ability to return the label for. + /// @return The label of the specific ability. + const std::string GetSkillLabel(int talentId); + + /// @brief Gets the label for a talent ability given its id. + /// @param talentId The id of the ability to return. + /// @return The label for the specific ability. + const std::string GetTalentLabel(int talentId); } // End namespace SBF #endif // End !defined ABILITIES_H__ diff --git a/sbf-cpp/Abilities_test.cpp b/sbf-cpp/Abilities_test.cpp index 2fd162d..6c3058e 100644 --- a/sbf-cpp/Abilities_test.cpp +++ b/sbf-cpp/Abilities_test.cpp @@ -1,107 +1,659 @@ #include "Abilities.h" #include "test.h" #include +#include using namespace SBF; using namespace Test; using namespace std; namespace Test::Abilities { - TestResults test_GetNumItemsForAbilityGroup(); - TestResults test_GetAbility(); - TestResults test_FillAbilities(); - TestResults test_GetTalentLabel(); - TestResults test_GetSkillLabel(); - TestResults test_GetKnowledgeLabel(); - TestResults test_GetAbilityLabel(); - TestResults test_FillTalentLabels(); - TestResults test_FillSkillLabels(); - TestResults test_FkilKnowledgeLabels(); - + TestResults test_AbilityType_operator_extract(); + TestResults test_AbilityType_operator_equal_to(); + TestResults test_FillAbilities(); + TestResults test_FillAbilitiesForAbilityGroup(); + TestResults test_FillAbilityLabels(); + TestResults test_FillKnowledgeLabels(); + TestResults test_FillSkillLabels(); + TestResults test_FillTalentLabels(); + TestResults test_GetAbility(); + TestResults test_GetAbilityLabel(); + TestResults test_GetKnowledgeLabel(); + TestResults test_GetNumItemsForAbilityGroup(); + TestResults test_GetSkillLabel(); + TestResults test_GetTalentLabel(); } // End namespace Test::Abilities using namespace Test::Abilities; -namespace Test { - extern TestResults do_the_other_thing(); -} - -// TODO: Find a way to put this in Test::Abilities or at least Test. TestResults main_test_Abilities(int argc, char** argv) { TestResults results; - // results = results + test_GetNumItemsForAbilityGroup(); - // results = results + test_GetAbility(); - // results = results + test_FillAbilities(); - // results = results + test_GetTalentLabel(); - // results = results + test_GetSkillLabel(); - // results = results + test_GetKnowledgeLabel(); - // results = results + test_GetAbilityLabel(); - // results = results + test_FillTalentLabels(); - // results = results + test_FillSkillLabels(); - // results = results + test_FkilKnowledgeLabels(); + results += test_AbilityType_operator_extract(); + results += test_AbilityType_operator_equal_to(); + results += test_FillAbilities(); + results += test_FillAbilitiesForAbilityGroup(); + results += test_FillAbilityLabels(); + results += test_FillKnowledgeLabels(); + results += test_FillSkillLabels(); + results += test_FillTalentLabels(); + results += test_GetAbility(); + results += test_GetAbilityLabel(); + results += test_GetKnowledgeLabel(); + results += test_GetNumItemsForAbilityGroup(); + results += test_GetSkillLabel(); + results += test_GetTalentLabel(); - results = do_the_other_thing(); - return results; } namespace Test::Abilities { - TestResults test_GetNumItemsForAbilityGroup() { - // return test_fn( - // L"/SBF/Abilities/GetNumItemsForAbilityGroup", - // GetNumItemsForAbilityGroup, - // vector({ - // pair(kTalentsCount, make_tuple(kAbilityTalentsId)), - // pair(kSkillsCount, make_tuple(kAbilitySkillsId)), - // pair(kKnowledgesCount, make_tuple(kAbilityKnowledgesId)), - // pair(0, make_tuple(0)), - // pair(0, make_tuple(99)), - // })); - return TestResults(); + TestResults test_AbilityType_operator_extract() { + return execute_suite( + make_test_suite( + "SBF::AbilityType::operator<<", + [](const AbilityType& ability){ + ostringstream os; + os << ability; + return os.str(); + }, + vector>({ + make_test( + "should print talents", + "AbilityGroup: {id: 1, singular: \"Talent\", plural: \"Talents\"}", + make_tuple(kAbilityGroupTalents)), + make_test( + "should print skills", + "AbilityGroup: {id: 2, singular: \"Skill\", plural: \"Skills\"}", + make_tuple(kAbilityGroupSkills)), + make_test( + "should print knowledges", + "AbilityGroup: {id: 3, singular: \"Knowledge\", plural: \"Knowledges\"}", + make_tuple(kAbilityGroupKnowledges)), + make_test( + "should print an unknown ability group", + "AbilityGroup: {id: 0, singular: \"\", plural: \"\"}", + make_tuple(kAbilityGroupUnknown)), + }) + )); + } + + TestResults test_AbilityType_operator_equal_to() { + return execute_suite( + make_test_suite( + "SBF::AbilityType::operator==", + [](const AbilityType& left, const AbilityType& right) { + return left == right; + }, + vector>({ + make_test( + "should return true when comparing an ability group to itself", + true, + make_tuple(kAbilityGroupTalents, kAbilityGroupTalents)), + make_test( + "should return true when comparing two different instances created with the same values", + true, + make_tuple(kAbilityGroupSkills, AbilityType({kAbilitySkillsId, kAbilitySkillsSingular, kAbilitySkillsPlural}))), + make_test( + "should return false when comparing two different ability gropus", + false, + make_tuple(kAbilityGroupKnowledges, kAbilityGroupSkills)), + }) + )); + } + + TestResults test_FillAbilities() { + return execute_suite( + make_test_suite( + "SBF::FillAbilities", + []() { + ostringstream error_message; + vector actual; + FillAbilities(actual); + if (actual.size() != 3) { + error_message << "size != 3 actually, and was " << actual.size(); + } + if (!error_message.str().size() && !(actual[0] == kAbilityGroupTalents)) { + error_message << "group 0 != talents, and was " << actual[0]; + } + if (!error_message.str().size() && !(actual[1] == kAbilityGroupSkills)) { + error_message << "group 1 != skills, and was " << actual[1]; + } + if (!error_message.str().size() && !(actual[2] == kAbilityGroupKnowledges)) { + error_message << "group 2 != knowledges, and was " << actual[2]; + } + return error_message.str(); + }, + vector>({ + make_test( + "should fill abilities", + "", + make_tuple()), + }) + )); + } + + TestResults test_FillAbilitiesForAbilityGroup() { + return execute_suite, int>( + make_test_suite( + "SBF::FillAbilitiesForAbilityGroup", + [](int groupId) { + vector abilities = {"This should be removed"}; + FillAbilitiesForAbilityGroup(abilities, groupId); + return abilities; + }, + vector, int>>({ + make_test, int>( + "should clear the vector for group 0, kAbilityGropuUnknownId", + {}, + make_tuple(0)), + make_test, int>( + "should fill talents for group 1 kAbilityGroupTalentsId", + {"", "Acting", "Alertness", "Athletics", "Brawl", "Dodge", "Empathy", "Intimidation", "Leadership", "Streetwise", "Subterfuge"},//, "Alertness", "Athletics", "Brawl", "Dodge", "Empathy", "Intimidation", "Leadership", "Streetwise", "Subterfuge" + make_tuple(1)), + make_test, int>( + "should fill skills for group 2 kAbilityGroupSkillsId", + {"", "Animal Ken", "Drive", "Etiquette", "Firearms", "Melee", "Music", "Repair", "Security", "Stealth", "Survival"}, + make_tuple(2)), + make_test, int>( + "should fill knowledges for group 3 kAbilityGroupKnowledgesId", + {"", "Bureaucracy", "Computer", "Finance", "Investigation", "Law", "Linguistics", "Medicine", "Occult", "Politics", "Science"}, + make_tuple(3)), + make_test, int>( + "should clear the vector for group 4 an invalid id", + {}, + make_tuple(4)), + }) + )); + } + + TestResults test_FillAbilityLabels() { + return execute_suite, int>( + make_test_suite( + "SBF::FillAbilityLabels", + [](int groupId) { + vector abilities = {"This should be removed"}; + FillAbilityLabels(abilities, groupId); + return abilities; + }, + vector, int>>({ + make_test, int>( + "should clear the vector for group 0, kAbilityGropuUnknownId", + {}, + make_tuple(0)), + make_test, int>( + "should fill talents for group 1 kAbilityGroupTalentsId", + {"", "Acting", "Alertness", "Athletics", "Brawl", "Dodge", "Empathy", "Intimidation", "Leadership", "Streetwise", "Subterfuge"}, + make_tuple(1)), + make_test, int>( + "should fill skills for group 2 kAbilityGroupSkillsId", + {"", "Animal Ken", "Drive", "Etiquette", "Firearms", "Melee", "Music", "Repair", "Security", "Stealth", "Survival"}, + make_tuple(2)), + make_test, int>( + "should fill knowledges for group 3 kAbilityGroupKnowledgesId", + {"", "Bureaucracy", "Computer", "Finance", "Investigation", "Law", "Linguistics", "Medicine", "Occult", "Politics", "Science"}, + make_tuple(3)), + make_test, int>( + "should clear the vector for group 4 an invalid id", + {}, + make_tuple(4)), + }) + )); + } + + TestResults test_FillKnowledgeLabels() { + return execute_suite( + make_test_suite( + "SBF::FillKnowlegeLabels", + []() { + ostringstream error_message; + vector actual = {"This should be removed"}; + FillKnowledgeLabels(actual); + if (actual.size() != 11) { + error_message << "size != 11 actually, and was " << actual.size(); + } + if (!error_message.str().size() && !(actual == vector({"", "Bureaucracy", "Computer", "Finance", "Investigation", "Law", "Linguistics", "Medicine", "Occult", "Politics", "Science"}))) { + error_message << "group 0 != talents, and was " << actual[0]; + } + return error_message.str(); + }, + vector>({ + make_test( + "should fill knowledge labels", + "", + make_tuple()), + }) + )); + } + + TestResults test_FillSkillLabels() { + return execute_suite( + make_test_suite( + "SBF::FillSkillLabels", + []() { + ostringstream error_message; + vector actual = {"This should be removed"}; + FillSkillLabels(actual); + if (actual.size() != 11) { + error_message << "size != 11 actually, and was " << actual.size(); + } + if (!error_message.str().size() && !(actual == vector({"", "Animal Ken", "Drive", "Etiquette", "Firearms", "Melee", "Music", "Repair", "Security", "Stealth", "Survival"}))) { + error_message << "group 0 != talents, and was " << actual[0]; + } + return error_message.str(); + }, + vector>({ + make_test( + "should fill skill labels", + "", + make_tuple()), + }) + )); + } + + TestResults test_FillTalentLabels() { + return execute_suite( + make_test_suite( + "SBF::FillTalentLabels", + []() { + ostringstream error_message; + vector actual = {"This should be removed"}; + FillTalentLabels(actual); + if (actual.size() != 11) { + error_message << "size != 11 actually, and was " << actual.size(); + } + if (!error_message.str().size() && !(actual == vector({"", "Acting", "Alertness", "Athletics", "Brawl", "Dodge", "Empathy", "Intimidation", "Leadership", "Streetwise", "Subterfuge"}))) { + error_message << "group 0 != talents, and was " << actual[0]; + } + return error_message.str(); + }, + vector>({ + make_test( + "should fill knowledge labels", + "", + make_tuple()), + }) + )); } TestResults test_GetAbility() { - // return test_fn( - // L"/SBF/Abilities/GetAbility", - // GetAbility, - // vector({ - // pair(kAbilityKnowledges, make_tuple(kAbilityKnowledgesId)), - // })); - return TestResults(); - } - TestResults test_FillAbilities() { - return TestResults(); - } - TestResults test_GetTalentLabel() { - return TestResults(); - } - TestResults test_GetSkillLabel() { - return TestResults(); - } - TestResults test_GetKnowledgeLabel() { - return TestResults(); + return execute_suite( + make_test_suite( + "SBF::GetAbility", + GetAbility, + vector>({ + make_test( + "should get talents", + kAbilityGroupTalents, + make_tuple(kAbilityTalentsId)), + make_test( + "should get skills", + kAbilityGroupSkills, + make_tuple(kAbilitySkillsId)), + make_test( + "should get knowledges", + kAbilityGroupKnowledges, + make_tuple(kAbilityKnowledgesId)), + make_test( + "should get unknown for id 0", + kAbilityGroupUnknown, + make_tuple(0)), + make_test( + "should get unknown for an invalid id", + kAbilityGroupUnknown, + make_tuple(4)), + }) + ) + ); } + TestResults test_GetAbilityLabel() { - return TestResults(); + return execute_suite( + make_test_suite( + "SBF::GetAbilityLabel", + GetAbilityLabel, + vector>({ + make_test( + "should get Acting for group 1 and id 1", + "Acting", + make_tuple(1, 1)), + make_test( + "should get Alertness for group 1 and id 2", + "Alertness", + make_tuple(1, 2)), + make_test( + "should get Athletics for group 1 and id 3", + "Athletics", + make_tuple(1, 3)), + make_test( + "should get Brawl for group 1 and id 4", + "Brawl", + make_tuple(1, 4)), + make_test( + "should get Dodge for group 1 and id 5", + "Dodge", + make_tuple(1, 5)), + make_test( + "should get Empathy for group 1 and id 6", + "Empathy", + make_tuple(1, 6)), + make_test( + "should get Intimidation for group 1 and id 7", + "Intimidation", + make_tuple(1, 7)), + make_test( + "should get Leadership for group 1 and id 8", + "Leadership", + make_tuple(1, 8)), + make_test( + "should get Streetwise for group 1 and id 9", + "Streetwise", + make_tuple(1, 9)), + make_test( + "should get Subterfuge for group 1 and id 10", + "Subterfuge", + make_tuple(1, 10)), + make_test( + "should get Animal Ken for group 2 and id 1", + "Animal Ken", + make_tuple(2, 1)), + make_test( + "should get Drive for group 2 and id 2", + "Drive", + make_tuple(2, 2)), + make_test( + "should get Etiquette for group 2 and id 3", + "Etiquette", + make_tuple(2, 3)), + make_test( + "should get Firearms for group 2 and id 4", + "Firearms", + make_tuple(2, 4)), + make_test( + "should get Melee for group 2 and id 5", + "Melee", + make_tuple(2, 5)), + make_test( + "should get Music for group 2 and id 6", + "Music", + make_tuple(2, 6)), + make_test( + "should get Repair for group 2 and id 7", + "Repair", + make_tuple(2, 7)), + make_test( + "should get Security for group 2 and id 8", + "Security", + make_tuple(2, 8)), + make_test( + "should get Stealth for group 2 and id 9", + "Stealth", + make_tuple(2, 9)), + make_test( + "should get Survival for group 2 and id 10", + "Survival", + make_tuple(2, 10)), + make_test( + "should get Bureaucracy for group 3 and id 1", + "Bureaucracy", + make_tuple(3, 1)), + make_test( + "should get Computer for group 3 and id 2", + "Computer", + make_tuple(3, 2)), + make_test( + "should get Finance for group 3 and id 3", + "Finance", + make_tuple(3, 3)), + make_test( + "should get Investigation for group 3 and id 4", + "Investigation", + make_tuple(3, 4)), + make_test( + "should get Law for group 3 and id 5", + "Law", + make_tuple(3, 5)), + make_test( + "should get Linguistics for group 3 and id 6", + "Linguistics", + make_tuple(3, 6)), + make_test( + "should get Medicine for group 3 and id 7", + "Medicine", + make_tuple(3, 7)), + make_test( + "should get Occult for group 3 and id 8", + "Occult", + make_tuple(3, 8)), + make_test( + "should get Politics for group 3 and id 9", + "Politics", + make_tuple(3, 9)), + make_test( + "should get Science for group 3 and id 10", + "Science", + make_tuple(3, 10)), + make_test( + "should get and empty string for group 0 and id 0", + "", + make_tuple(0, 0)), + make_test( + "should get and empty string for group 1 and id 11", + "", + make_tuple(1, 11)), + make_test( + "should get and empty string for group 4 and id 1", + "", + make_tuple(4, 1)), + }) + ) + ); } - TestResults test_FillTalentLabels() { - return TestResults(); - } - TestResults test_FillSkillLabels() { - return TestResults(); - } - TestResults test_FkilKnowledgeLabels() { - return TestResults(); - } - - - // TestResults test_GetNumItemsForAbilityGroup() { - // return std::make_tuple(1, 0); - // } - // results = results + test_fn(L"get_substring", get_substring, vector({ - // pair(L"234", make_tuple(L"1234567890", 1, 3)), - // pair(L"Paris", make_tuple(L"Where is Paris?", 10-1, 5)), - // })); + TestResults test_GetKnowledgeLabel() { + return execute_suite( + make_test_suite( + "SBF::GetKnowledgeLabel", + GetKnowledgeLabel, + vector>({ + make_test( + "should get Bureaucracy for id 1", + "Bureaucracy", + make_tuple(1)), + make_test( + "should get Computer for id 2", + "Computer", + make_tuple(2)), + make_test( + "should get Finance for id 3", + "Finance", + make_tuple(3)), + make_test( + "should get Investigation for id 4", + "Investigation", + make_tuple(4)), + make_test( + "should get Law for id 5", + "Law", + make_tuple(5)), + make_test( + "should get Linguistics for id 6", + "Linguistics", + make_tuple(6)), + make_test( + "should get Medicine for id 7", + "Medicine", + make_tuple(7)), + make_test( + "should get Occult for id 8", + "Occult", + make_tuple(8)), + make_test( + "should get Politics for id 9", + "Politics", + make_tuple(9)), + make_test( + "should get Science for id 10", + "Science", + make_tuple(10)), + make_test( + "should get and empty string for id 0", + "", + make_tuple(0)), + make_test( + "should get and empty string for id 11", + "", + make_tuple(11)), + }) + ) + ); + return TestResults(); + } + TestResults test_GetNumItemsForAbilityGroup() { + return execute_suite( + make_test_suite( + "SBF::GetNumItemsForAbilityGroup", + GetNumItemsForAbilityGroup, + vector>({ + make_test( + "should get 10 abilities for talents", + 10, + make_tuple(kAbilityTalentsId)), + make_test( + "should get 10 abilities for skills", + 10, + make_tuple(kAbilitySkillsId)), + make_test( + "should get 10 abilities for knowledges", + 10, + make_tuple(kAbilityKnowledgesId)), + make_test( + "should get 0 abilities for 0", + 0, + make_tuple(0)), + make_test( + "should get 0 abilities for an invalid id", + 0, + make_tuple(4)), + }) + ) + ); + } + TestResults test_GetSkillLabel() { + return execute_suite( + make_test_suite( + "SBF::GetSkillLabel", + GetSkillLabel, + vector>({ + make_test( + "should get Animal Ken for id 1", + "Animal Ken", + make_tuple(1)), + make_test( + "should get Drive for id 2", + "Drive", + make_tuple(2)), + make_test( + "should get Etiquette for id 3", + "Etiquette", + make_tuple(3)), + make_test( + "should get Firearms for id 4", + "Firearms", + make_tuple(4)), + make_test( + "should get Melee for id 5", + "Melee", + make_tuple(5)), + make_test( + "should get Music for id 6", + "Music", + make_tuple(6)), + make_test( + "should get Repair for id 7", + "Repair", + make_tuple(7)), + make_test( + "should get Security for id 8", + "Security", + make_tuple(8)), + make_test( + "should get Stealth for id 9", + "Stealth", + make_tuple(9)), + make_test( + "should get Survival for id 10", + "Survival", + make_tuple(10)), + make_test( + "should get and empty string for id 0", + "", + make_tuple(0)), + make_test( + "should get and empty string for id 11", + "", + make_tuple(11)), + }) + ) + ); + } + + TestResults test_GetTalentLabel() { + return execute_suite( + make_test_suite( + "SBF::GetTalentLabel", + GetTalentLabel, + vector>({ + make_test( + "should get Acting for id 1", + "Acting", + make_tuple(1)), + make_test( + "should get Alertness for id 2", + "Alertness", + make_tuple(2)), + make_test( + "should get Athletics for id 3", + "Athletics", + make_tuple(3)), + make_test( + "should get Brawl for id 4", + "Brawl", + make_tuple(4)), + make_test( + "should get Dodge for id 5", + "Dodge", + make_tuple(5)), + make_test( + "should get Empathy for id 6", + "Empathy", + make_tuple(6)), + make_test( + "should get Intimidation for id 7", + "Intimidation", + make_tuple(7)), + make_test( + "should get Leadership for id 8", + "Leadership", + make_tuple(8)), + make_test( + "should get Streetwise for id 9", + "Streetwise", + make_tuple(9)), + make_test( + "should get Subterfuge for id 10", + "Subterfuge", + make_tuple(10)), + make_test( + "should get and empty string for id 0", + "", + make_tuple(0)), + make_test( + "should get and empty string for id 11", + "", + make_tuple(11)), + }) + ) + ); + } } // End namespace Test::Abilities