maj/StorytellersBestFriend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Documents Abilities.

Browse Source 
Adds full test coverage for Abilities.
This commit is contained in:
Tom Hicks
2023-04-15 16:27:23 -07:00
parent 31a5b60f7f
commit e68973c1b1
3 changed files with 901 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

708
sbf-cpp/Abilities_test.cpp
View File

@@ -1,107 +1,659 @@
#include "Abilities.h"
#include "test.h"
#include <iostream>
#include <sstream>
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<string, AbilityType>(
make_test_suite(
"SBF::AbilityType::operator<<",
[](const AbilityType& ability){
ostringstream os;
os << ability;
return os.str();
},
vector<TestTuple<string, AbilityType>>({
make_test<string, AbilityType>(
"should print talents",
"AbilityGroup: {id: 1, singular: \"Talent\", plural: \"Talents\"}",
make_tuple(kAbilityGroupTalents)),
make_test<string, AbilityType>(
"should print skills",
"AbilityGroup: {id: 2, singular: \"Skill\", plural: \"Skills\"}",
make_tuple(kAbilityGroupSkills)),
make_test<string, AbilityType>(
"should print knowledges",
"AbilityGroup: {id: 3, singular: \"Knowledge\", plural: \"Knowledges\"}",
make_tuple(kAbilityGroupKnowledges)),
make_test<string, AbilityType>(
"should print an unknown ability group",
"AbilityGroup: {id: 0, singular: \"\", plural: \"\"}",
make_tuple(kAbilityGroupUnknown)),
})
));
}
TestResults test_AbilityType_operator_equal_to() {
return execute_suite<bool, AbilityType, AbilityType>(
make_test_suite(
"SBF::AbilityType::operator==",
[](const AbilityType& left, const AbilityType& right) {
return left == right;
},
vector<TestTuple<bool, AbilityType, AbilityType>>({
make_test<bool, AbilityType, AbilityType>(
"should return true when comparing an ability group to itself",
true,
make_tuple(kAbilityGroupTalents, kAbilityGroupTalents)),
make_test<bool, AbilityType, AbilityType>(
"should return true when comparing two different instances created with the same values",
true,
make_tuple(kAbilityGroupSkills, AbilityType({kAbilitySkillsId, kAbilitySkillsSingular, kAbilitySkillsPlural}))),
make_test<bool, AbilityType, AbilityType>(
"should return false when comparing two different ability gropus",
false,
make_tuple(kAbilityGroupKnowledges, kAbilityGroupSkills)),
})
));
}
TestResults test_FillAbilities() {
return execute_suite<string>(
make_test_suite(
"SBF::FillAbilities",
[]() {
ostringstream error_message;
vector<AbilityType> 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<TestTuple<string>>({
make_test<string>(
"should fill abilities",
"",
make_tuple()),
})
));
}
TestResults test_FillAbilitiesForAbilityGroup() {
return execute_suite<vector<string>, int>(
make_test_suite(
"SBF::FillAbilitiesForAbilityGroup",
[](int groupId) {
vector<string> abilities = {"This should be removed"};
FillAbilitiesForAbilityGroup(abilities, groupId);
return abilities;
},
vector<TestTuple<vector<string>, int>>({
make_test<vector<string>, int>(
"should clear the vector for group 0, kAbilityGropuUnknownId",
{},
make_tuple(0)),
make_test<vector<string>, 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<vector<string>, int>(
"should fill skills for group 2 kAbilityGroupSkillsId",
{"", "Animal Ken", "Drive", "Etiquette", "Firearms", "Melee", "Music", "Repair", "Security", "Stealth", "Survival"},
make_tuple(2)),
make_test<vector<string>, int>(
"should fill knowledges for group 3 kAbilityGroupKnowledgesId",
{"", "Bureaucracy", "Computer", "Finance", "Investigation", "Law", "Linguistics", "Medicine", "Occult", "Politics", "Science"},
make_tuple(3)),
make_test<vector<string>, int>(
"should clear the vector for group 4 an invalid id",
{},
make_tuple(4)),
})
));
}
TestResults test_FillAbilityLabels() {
return execute_suite<vector<string>, int>(
make_test_suite(
"SBF::FillAbilityLabels",
[](int groupId) {
vector<string> abilities = {"This should be removed"};
FillAbilityLabels(abilities, groupId);
return abilities;
},
vector<TestTuple<vector<string>, int>>({
make_test<vector<string>, int>(
"should clear the vector for group 0, kAbilityGropuUnknownId",
{},
make_tuple(0)),
make_test<vector<string>, int>(
"should fill talents for group 1 kAbilityGroupTalentsId",
{"", "Acting", "Alertness", "Athletics", "Brawl", "Dodge", "Empathy", "Intimidation", "Leadership", "Streetwise", "Subterfuge"},
make_tuple(1)),
make_test<vector<string>, int>(
"should fill skills for group 2 kAbilityGroupSkillsId",
{"", "Animal Ken", "Drive", "Etiquette", "Firearms", "Melee", "Music", "Repair", "Security", "Stealth", "Survival"},
make_tuple(2)),
make_test<vector<string>, int>(
"should fill knowledges for group 3 kAbilityGroupKnowledgesId",
{"", "Bureaucracy", "Computer", "Finance", "Investigation", "Law", "Linguistics", "Medicine", "Occult", "Politics", "Science"},
make_tuple(3)),
make_test<vector<string>, int>(
"should clear the vector for group 4 an invalid id",
{},
make_tuple(4)),
})
));
}
TestResults test_FillKnowledgeLabels() {
return execute_suite<string>(
make_test_suite(
"SBF::FillKnowlegeLabels",
[]() {
ostringstream error_message;
vector<string> 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<string>({"", "Bureaucracy", "Computer", "Finance", "Investigation", "Law", "Linguistics", "Medicine", "Occult", "Politics", "Science"}))) {
error_message << "group 0 != talents, and was " << actual[0];
}
return error_message.str();
},
vector<TestTuple<string>>({
make_test<string>(
"should fill knowledge labels",
"",
make_tuple()),
})
));
}
TestResults test_FillSkillLabels() {
return execute_suite<string>(
make_test_suite(
"SBF::FillSkillLabels",
[]() {
ostringstream error_message;
vector<string> 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<string>({"", "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<TestTuple<string>>({
make_test<string>(
"should fill skill labels",
"",
make_tuple()),
})
));
}
TestResults test_FillTalentLabels() {
return execute_suite<string>(
make_test_suite(
"SBF::FillTalentLabels",
[]() {
ostringstream error_message;
vector<string> 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<string>({"", "Acting", "Alertness", "Athletics", "Brawl", "Dodge", "Empathy", "Intimidation", "Leadership", "Streetwise", "Subterfuge"}))) {
error_message << "group 0 != talents, and was " << actual[0];
}
return error_message.str();
},
vector<TestTuple<string>>({
make_test<string>(
"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<AbilityType, int>(
make_test_suite(
"SBF::GetAbility",
GetAbility,
vector<TestTuple<AbilityType, int>>({
make_test<AbilityType, int>(
"should get talents",
kAbilityGroupTalents,
make_tuple(kAbilityTalentsId)),
make_test<AbilityType, int>(
"should get skills",
kAbilityGroupSkills,
make_tuple(kAbilitySkillsId)),
make_test<AbilityType, int>(
"should get knowledges",
kAbilityGroupKnowledges,
make_tuple(kAbilityKnowledgesId)),
make_test<AbilityType, int>(
"should get unknown for id 0",
kAbilityGroupUnknown,
make_tuple(0)),
make_test<AbilityType, int>(
"should get unknown for an invalid id",
kAbilityGroupUnknown,
make_tuple(4)),
})
)
);
}
TestResults test_GetAbilityLabel() {
return TestResults();
return execute_suite<string, int, int>(
make_test_suite(
"SBF::GetAbilityLabel",
GetAbilityLabel,
vector<TestTuple<string, int, int>>({
make_test<string, int, int>(
"should get Acting for group 1 and id 1",
"Acting",
make_tuple(1, 1)),
make_test<string, int, int>(
"should get Alertness for group 1 and id 2",
"Alertness",
make_tuple(1, 2)),
make_test<string, int, int>(
"should get Athletics for group 1 and id 3",
"Athletics",
make_tuple(1, 3)),
make_test<string, int, int>(
"should get Brawl for group 1 and id 4",
"Brawl",
make_tuple(1, 4)),
make_test<string, int, int>(
"should get Dodge for group 1 and id 5",
"Dodge",
make_tuple(1, 5)),
make_test<string, int, int>(
"should get Empathy for group 1 and id 6",
"Empathy",
make_tuple(1, 6)),
make_test<string, int, int>(
"should get Intimidation for group 1 and id 7",
"Intimidation",
make_tuple(1, 7)),
make_test<string, int, int>(
"should get Leadership for group 1 and id 8",
"Leadership",
make_tuple(1, 8)),
make_test<string, int, int>(
"should get Streetwise for group 1 and id 9",
"Streetwise",
make_tuple(1, 9)),
make_test<string, int, int>(
"should get Subterfuge for group 1 and id 10",
"Subterfuge",
make_tuple(1, 10)),
make_test<string, int, int>(
"should get Animal Ken for group 2 and id 1",
"Animal Ken",
make_tuple(2, 1)),
make_test<string, int, int>(
"should get Drive for group 2 and id 2",
"Drive",
make_tuple(2, 2)),
make_test<string, int, int>(
"should get Etiquette for group 2 and id 3",
"Etiquette",
make_tuple(2, 3)),
make_test<string, int, int>(
"should get Firearms for group 2 and id 4",
"Firearms",
make_tuple(2, 4)),
make_test<string, int, int>(
"should get Melee for group 2 and id 5",
"Melee",
make_tuple(2, 5)),
make_test<string, int, int>(
"should get Music for group 2 and id 6",
"Music",
make_tuple(2, 6)),
make_test<string, int, int>(
"should get Repair for group 2 and id 7",
"Repair",
make_tuple(2, 7)),
make_test<string, int, int>(
"should get Security for group 2 and id 8",
"Security",
make_tuple(2, 8)),
make_test<string, int, int>(
"should get Stealth for group 2 and id 9",
"Stealth",
make_tuple(2, 9)),
make_test<string, int, int>(
"should get Survival for group 2 and id 10",
"Survival",
make_tuple(2, 10)),
make_test<string, int, int>(
"should get Bureaucracy for group 3 and id 1",
"Bureaucracy",
make_tuple(3, 1)),
make_test<string, int, int>(
"should get Computer for group 3 and id 2",
"Computer",
make_tuple(3, 2)),
make_test<string, int, int>(
"should get Finance for group 3 and id 3",
"Finance",
make_tuple(3, 3)),
make_test<string, int, int>(
"should get Investigation for group 3 and id 4",
"Investigation",
make_tuple(3, 4)),
make_test<string, int, int>(
"should get Law for group 3 and id 5",
"Law",
make_tuple(3, 5)),
make_test<string, int, int>(
"should get Linguistics for group 3 and id 6",
"Linguistics",
make_tuple(3, 6)),
make_test<string, int, int>(
"should get Medicine for group 3 and id 7",
"Medicine",
make_tuple(3, 7)),
make_test<string, int, int>(
"should get Occult for group 3 and id 8",
"Occult",
make_tuple(3, 8)),
make_test<string, int, int>(
"should get Politics for group 3 and id 9",
"Politics",
make_tuple(3, 9)),
make_test<string, int, int>(
"should get Science for group 3 and id 10",
"Science",
make_tuple(3, 10)),
make_test<string, int, int>(
"should get and empty string for group 0 and id 0",
"",
make_tuple(0, 0)),
make_test<string, int, int>(
"should get and empty string for group 1 and id 11",
"",
make_tuple(1, 11)),
make_test<string, int, int>(
"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<string, int>(
make_test_suite(
"SBF::GetKnowledgeLabel",
GetKnowledgeLabel,
vector<TestTuple<string, int>>({
make_test<string, int>(
"should get Bureaucracy for id 1",
"Bureaucracy",
make_tuple(1)),
make_test<string, int>(
"should get Computer for id 2",
"Computer",
make_tuple(2)),
make_test<string, int>(
"should get Finance for id 3",
"Finance",
make_tuple(3)),
make_test<string, int>(
"should get Investigation for id 4",
"Investigation",
make_tuple(4)),
make_test<string, int>(
"should get Law for id 5",
"Law",
make_tuple(5)),
make_test<string, int>(
"should get Linguistics for id 6",
"Linguistics",
make_tuple(6)),
make_test<string, int>(
"should get Medicine for id 7",
"Medicine",
make_tuple(7)),
make_test<string, int>(
"should get Occult for id 8",
"Occult",
make_tuple(8)),
make_test<string, int>(
"should get Politics for id 9",
"Politics",
make_tuple(9)),
make_test<string, int>(
"should get Science for id 10",
"Science",
make_tuple(10)),
make_test<string, int>(
"should get and empty string for id 0",
"",
make_tuple(0)),
make_test<string, int>(
"should get and empty string for id 11",
"",
make_tuple(11)),
})
)
);
return TestResults();
}
TestResults test_GetNumItemsForAbilityGroup() {
return execute_suite<int, int>(
make_test_suite(
"SBF::GetNumItemsForAbilityGroup",
GetNumItemsForAbilityGroup,
vector<TestTuple<int, int>>({
make_test<int, int>(
"should get 10 abilities for talents",
10,
make_tuple(kAbilityTalentsId)),
make_test<int, int>(
"should get 10 abilities for skills",
10,
make_tuple(kAbilitySkillsId)),
make_test<int, int>(
"should get 10 abilities for knowledges",
10,
make_tuple(kAbilityKnowledgesId)),
make_test<int, int>(
"should get 0 abilities for 0",
0,
make_tuple(0)),
make_test<int, int>(
"should get 0 abilities for an invalid id",
0,
make_tuple(4)),
})
)
);
}
TestResults test_GetSkillLabel() {
return execute_suite<string, int>(
make_test_suite(
"SBF::GetSkillLabel",
GetSkillLabel,
vector<TestTuple<string, int>>({
make_test<string, int>(
"should get Animal Ken for id 1",
"Animal Ken",
make_tuple(1)),
make_test<string, int>(
"should get Drive for id 2",
"Drive",
make_tuple(2)),
make_test<string, int>(
"should get Etiquette for id 3",
"Etiquette",
make_tuple(3)),
make_test<string, int>(
"should get Firearms for id 4",
"Firearms",
make_tuple(4)),
make_test<string, int>(
"should get Melee for id 5",
"Melee",
make_tuple(5)),
make_test<string, int>(
"should get Music for id 6",
"Music",
make_tuple(6)),
make_test<string, int>(
"should get Repair for id 7",
"Repair",
make_tuple(7)),
make_test<string, int>(
"should get Security for id 8",
"Security",
make_tuple(8)),
make_test<string, int>(
"should get Stealth for id 9",
"Stealth",
make_tuple(9)),
make_test<string, int>(
"should get Survival for id 10",
"Survival",
make_tuple(10)),
make_test<string, int>(
"should get and empty string for id 0",
"",
make_tuple(0)),
make_test<string, int>(
"should get and empty string for id 11",
"",
make_tuple(11)),
})
)
);
}
TestResults test_GetTalentLabel() {
return execute_suite<string, int>(
make_test_suite(
"SBF::GetTalentLabel",
GetTalentLabel,
vector<TestTuple<string, int>>({
make_test<string, int>(
"should get Acting for id 1",
"Acting",
make_tuple(1)),
make_test<string, int>(
"should get Alertness for id 2",
"Alertness",
make_tuple(2)),
make_test<string, int>(
"should get Athletics for id 3",
"Athletics",
make_tuple(3)),
make_test<string, int>(
"should get Brawl for id 4",
"Brawl",
make_tuple(4)),
make_test<string, int>(
"should get Dodge for id 5",
"Dodge",
make_tuple(5)),
make_test<string, int>(
"should get Empathy for id 6",
"Empathy",
make_tuple(6)),
make_test<string, int>(
"should get Intimidation for id 7",
"Intimidation",
make_tuple(7)),
make_test<string, int>(
"should get Leadership for id 8",
"Leadership",
make_tuple(8)),
make_test<string, int>(
"should get Streetwise for id 9",
"Streetwise",
make_tuple(9)),
make_test<string, int>(
"should get Subterfuge for id 10",
"Subterfuge",
make_tuple(10)),
make_test<string, int>(
"should get and empty string for id 0",
"",
make_tuple(0)),
make_test<string, int>(
"should get and empty string for id 11",
"",
make_tuple(11)),
})
)
);
}
} // End namespace Test::Abilities