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

Implements derangements and tests.

Browse Source
This commit is contained in:
Tom Hicks
2023-04-16 07:18:00 -07:00
parent 91271f38b0
commit 018cce461d
3 changed files with 270 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
sbf-cpp/Derangements.cpp
View File

@@ -0,0 +1,41 @@
#include "Derangements.h"
#include <ostream>
#include <sstream>
namespace SBF {
using std::ostream;
bool operator==(const DerangementType& left, const DerangementType& right) {
return left.description == right.description &&
left.id == right.id &&
left.label == right.label &&
left.textColor == right.textColor;
}
bool operator!=(const DerangementType& left, const DerangementType& right) {
return !(left == right);
}
ostream& operator<<(ostream& os, const DerangementType& derangement) {
//Derangement: {id: 1, label: \"kDerangementAmnesiaLabel\", description: \"kDerangementAmnesiaDescription\", textColor: kDerangementAmnesiaTextColor}
os << "Derangement: {id: " << derangement.id
<< ", label: \"" << derangement.label
<< "\", description: \"" << derangement.description
<< "\", textColor: " << (int)derangement.textColor << "}";
return os;
}
DerangementType GetDerangement(int derangementId) {
if (derangementId >0 && derangementId <= kDerangementsCount) {
return kDerangements[derangementId];
}
return {};
}
void FillDerangements(std::vector<DerangementType>& derangements) {
derangements.clear();
for (int id = 1; id <= kDerangementsCount; id++) {
derangements.push_back(GetDerangement(id));
}
}
} // End namespace SBF

7
sbf-cpp/Derangements.h
View File

@@ -181,8 +181,11 @@ namespace SBF {
kDerangementRegression, kDerangementRegression,
}; };
const DerangementType& GetDerangement(int derangementId); bool operator==(const DerangementType& left, const DerangementType& right);
void FillDerangements(std::vector<DerangementType> derangements); bool operator!=(const DerangementType& left, const DerangementType& right);
std::ostream& operator<<(std::ostream& os, const DerangementType& derangement);
DerangementType GetDerangement(int derangementId);
void FillDerangements(std::vector<DerangementType>& derangements);
} // End namespace SBF } // End namespace SBF
/** @}*/ /** @}*/
#endif // End !defined DERANGEMENTS_H__ #endif // End !defined DERANGEMENTS_H__

224
sbf-cpp/Derangements_test.cpp
View File

@@ -1,10 +1,234 @@
#include "Derangements.h" #include "Derangements.h"
#include "test.h" #include "test.h"
#include <string>
#include <vector>
#include <tuple>
#include <sstream>
using namespace SBF; using namespace SBF;
using namespace Test; using namespace Test;
using namespace std;
namespace Test::Derangements {
TestResults test_DerangementType_operator_extract();
TestResults test_DerangementType_operator_equal_to();
TestResults test_DerangementType_operator_not_equal_to();
TestResults test_GetDerangement();
TestResults test_FillDerangements();
} // End Test::Derangements
using namespace Test::Derangements;
TestResults main_test_Derangements(int argc, char** argv) { TestResults main_test_Derangements(int argc, char** argv) {
TestResults results; TestResults results;
results += test_DerangementType_operator_extract();
results += test_DerangementType_operator_equal_to();
results += test_DerangementType_operator_not_equal_to();
results += test_GetDerangement();
results += test_FillDerangements();
return results; return results;
} }
namespace Test::Derangements {
TestResults test_GetDerangement() {
return execute_suite<DerangementType, int>(make_test_suite(
"SBF::GetDerangement",
GetDerangement,
vector<TestTuple<DerangementType, int>>({
make_test<DerangementType, int>(
"should get {0, "", "", 0} for invalid derangement id 0",
{0, "", "", 0},
make_tuple(0)),
make_test<DerangementType, int>(
"should get {kDerangementAmnesiaId, kDerangementAmnesiaLabel, kDerangementAmnesiaDescription, kDerangementAmnesiaTextColor} for derangement id 1",
kDerangementAmnesia,
make_tuple(1)),
make_test<DerangementType, int>(
"should get {kDerangementDelusionsOfGrandeurId, kDerangementDelusionsOfGrandeurLabel, kDerangementDelusionsOfGrandeurDescription, kDerangementDelusionsOfGrandeurTextColor} for derangement id 2",
kDerangementDelusionsOfGrandeur,
make_tuple(2)),
make_test<DerangementType, int>(
"should get {kDerangementFantasyId, kDerangementFantasyLabel, kDerangementFantasyDescription, kDerangementFantasyTextColor} for derangement id 3",
kDerangementFantasy,
make_tuple(3)),
make_test<DerangementType, int>(
"should get {kDerangementManicDepressionId, kDerangementManicDepressionLabel, kDerangementManicDepressionDescription, kDerangementManicDepressionTextColor} for derangement id 4",
kDerangementManicDepression,
make_tuple(4)),
make_test<DerangementType, int>(
"should get {kDerangementMultiplePersonalitiesId, kDerangementMultiplePersonalitiesLabel, kDerangementMultiplePersonalitiesDescription, kDerangementMultiplePersonalitiesTextColor} for derangement id 5",
kDerangementMultiplePersonalities,
make_tuple(5)),
make_test<DerangementType, int>(
"should get {kDerangementObsessionId, kDerangementObsessionLabel, kDerangementObsessionDescription, kDerangementObsessionTextColor} for derangement id 6",
kDerangementObsession,
make_tuple(6)),
make_test<DerangementType, int>(
"should get {kDerangementOvercompensationId, kDerangementOvercompensationLabel, kDerangementOvercompensationDescription, kDerangementOvercompensationTextColor} for derangement id 7",
kDerangementOvercompensation,
make_tuple(7)),
make_test<DerangementType, int>(
"should get {kDerangementParanoiaId, kDerangementParanoiaLabel, kDerangementParanoiaDescription, kDerangementParanoiaTextColor} for derangement id 8",
kDerangementParanoia,
make_tuple(8)),
make_test<DerangementType, int>(
"should get {kDerangementPerfectionId, kDerangementPerfectionLabel, kDerangementPerfectionDescription, kDerangementPerfectionTextColor} for derangement id 9",
kDerangementPerfection,
make_tuple(9)),
make_test<DerangementType, int>(
"should get {kDerangementRegressionId, kDerangementRegressionLabel, kDerangementRegressionDescription, kDerangementRegressionTextColor} for derangement id 10",
kDerangementRegression,
make_tuple(10)),
make_test<DerangementType, int>(
"should get {0, "", "", 0} for invalid derangement id 11",
{0, "", "", 0},
make_tuple(11)),
})
));
}
TestResults test_FillDerangements() {
auto fnToTest = []()->string {
ostringstream error_message;
vector<DerangementType> expected = {
kDerangementAmnesia,
kDerangementDelusionsOfGrandeur,
kDerangementFantasy,
kDerangementManicDepression,
kDerangementMultiplePersonalities,
kDerangementObsession,
kDerangementOvercompensation,
kDerangementParanoia,
kDerangementPerfection,
kDerangementRegression,
};
vector<DerangementType> actual = {
{-1, "This should be removed.", "This should be removed.", 255}
};
FillDerangements(actual);
compare(error_message, expected, actual);
string error = error_message.str();
if (error.size() > 0) {
return error;
}
return "no errors";
};
return execute_suite<string>(make_test_suite(
"SBF::FillDerangements",
fnToTest,
vector<TestTuple<string>>({
make_test<string>(
"should fill derangements",
"no errors",
make_tuple()),
})
));
}
TestResults test_DerangementType_operator_extract() {
return execute_suite<string, DerangementType>(make_test_suite(
"SBF::DerangementType::operator<<",
[](const DerangementType& derangement){
ostringstream os;
os << derangement;
return os.str();
},
vector<TestTuple<string, DerangementType>>({
make_test<string, DerangementType>(
"should print amnesia",
"Derangement: {id: 1, label: \"" + kDerangementAmnesiaLabel + "\", description: \"" + kDerangementAmnesiaDescription + "\", textColor: 4}",
make_tuple(kDerangementAmnesia)),
make_test<string, DerangementType>(
"should print delusions of grandeur",
"Derangement: {id: 2, label: \"" + kDerangementDelusionsOfGrandeurLabel + "\", description: \"" + kDerangementDelusionsOfGrandeurDescription + "\", textColor: 5}",
make_tuple(kDerangementDelusionsOfGrandeur)),
make_test<string, DerangementType>(
"should print fantasy",
"Derangement: {id: 3, label: \"" + kDerangementFantasyLabel + "\", description: \"" + kDerangementFantasyDescription + "\", textColor: 6}",
make_tuple(kDerangementFantasy)),
make_test<string, DerangementType>(
"should print manic depression",
"Derangement: {id: 4, label: \"" + kDerangementManicDepressionLabel + "\", description: \"" + kDerangementManicDepressionDescription + "\", textColor: 7}",
make_tuple(kDerangementManicDepression)),
make_test<string, DerangementType>(
"should print multiple personalities",
"Derangement: {id: 5, label: \"" + kDerangementMultiplePersonalitiesLabel + "\", description: \"" + kDerangementMultiplePersonalitiesDescription + "\", textColor: 1}",
make_tuple(kDerangementMultiplePersonalities)),
make_test<string, DerangementType>(
"should print obsession",
"Derangement: {id: 6, label: \"" + kDerangementObsessionLabel + "\", description: \"" + kDerangementObsessionDescription + "\", textColor: 10}",
make_tuple(kDerangementObsession)),
make_test<string, DerangementType>(
"should print overcompensation",
"Derangement: {id: 7, label: \"" + kDerangementOvercompensationLabel + "\", description: \"" + kDerangementOvercompensationDescription + "\", textColor: 11}",
make_tuple(kDerangementOvercompensation)),
make_test<string, DerangementType>(
"should print paranoia",
"Derangement: {id: 8, label: \"" + kDerangementParanoiaLabel + "\", description: \"" + kDerangementParanoiaDescription + "\", textColor: 12}",
make_tuple(kDerangementParanoia)),
make_test<string, DerangementType>(
"should print perfection",
"Derangement: {id: 9, label: \"" + kDerangementPerfectionLabel + "\", description: \"" + kDerangementPerfectionDescription + "\", textColor: 13}",
make_tuple(kDerangementPerfection)),
make_test<string, DerangementType>(
"should print regression",
"Derangement: {id: 10, label: \"" + kDerangementRegressionLabel + "\", description: \"" + kDerangementRegressionDescription + "\", textColor: 14}",
make_tuple(kDerangementRegression)),
make_test<string, DerangementType>(
"should print an unknown derangement",
"Derangement: {id: 0, label: \"MyLabel\", description: \"My Description\", textColor: 5}",
make_tuple((DerangementType){
0, "MyLabel", "My Description", 5})),
})
));
}
TestResults test_DerangementType_operator_equal_to() {
return execute_suite<bool, DerangementType, DerangementType>(
make_test_suite(
"SBF::DerangementType::operator==",
[](const DerangementType& left, const DerangementType& right) {
return left == right;
},
vector<TestTuple<bool, DerangementType, DerangementType>>({
make_test<bool, DerangementType, DerangementType>(
"should return true when comparing a derangement to itself",
true,
make_tuple(kDerangementDelusionsOfGrandeur, kDerangementDelusionsOfGrandeur)),
make_test<bool, DerangementType, DerangementType>(
"should return true when comparing two different instances created with the same values",
true,
make_tuple(kDerangementFantasy, DerangementType({kDerangementFantasyId, kDerangementFantasyLabel, kDerangementFantasyDescription, kDerangementFantasyTextColor}))),
make_test<bool, DerangementType, DerangementType>(
"should return false when comparing two different derangements",
false,
make_tuple(kDerangementManicDepression, kDerangementParanoia)),
})
));
}
TestResults test_DerangementType_operator_not_equal_to() {
return execute_suite<bool, DerangementType, DerangementType>(
make_test_suite(
"SBF::DerangementType::operator!=",
[](const DerangementType& left, const DerangementType& right) {
return left != right;
},
vector<TestTuple<bool, DerangementType, DerangementType>>({
make_test<bool, DerangementType, DerangementType>(
"should return false when comparing a derangement to itself",
false,
make_tuple(kDerangementDelusionsOfGrandeur, kDerangementDelusionsOfGrandeur)),
make_test<bool, DerangementType, DerangementType>(
"should return false when comparing two different instances created with the same values",
false,
make_tuple(kDerangementFantasy, DerangementType({kDerangementFantasyId, kDerangementFantasyLabel, kDerangementFantasyDescription, kDerangementFantasyTextColor}))),
make_test<bool, DerangementType, DerangementType>(
"should return true when comparing two different derangements",
true,
make_tuple(kDerangementManicDepression, kDerangementParanoia)),
})
));
}
} // End Test::Derangements