660 lines
29 KiB
C++
660 lines
29 KiB
C++
#include "Abilities.h"
|
|
#include "test.h"
|
|
#include <iostream>
|
|
#include <sstream>
|
|
using namespace SBF;
|
|
using namespace Test;
|
|
using namespace std;
|
|
|
|
namespace Test::Abilities {
|
|
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;
|
|
|
|
TestResults main_test_Abilities(int argc, char** argv) {
|
|
TestResults results;
|
|
|
|
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();
|
|
|
|
return results;
|
|
}
|
|
|
|
namespace Test::Abilities {
|
|
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 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 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_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
|