diff --git a/sbf-cpp/Derangements.cpp b/sbf-cpp/Derangements.cpp index e69de29..f8c08c7 100644 --- a/sbf-cpp/Derangements.cpp +++ b/sbf-cpp/Derangements.cpp @@ -0,0 +1,41 @@ +#include "Derangements.h" +#include +#include + +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& derangements) { + derangements.clear(); + for (int id = 1; id <= kDerangementsCount; id++) { + derangements.push_back(GetDerangement(id)); + } +} +} // End namespace SBF diff --git a/sbf-cpp/Derangements.h b/sbf-cpp/Derangements.h index 5189956..48acef6 100644 --- a/sbf-cpp/Derangements.h +++ b/sbf-cpp/Derangements.h @@ -181,8 +181,11 @@ namespace SBF { kDerangementRegression, }; - const DerangementType& GetDerangement(int derangementId); - void FillDerangements(std::vector derangements); + bool operator==(const DerangementType& left, const DerangementType& right); + 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& derangements); } // End namespace SBF /** @}*/ #endif // End !defined DERANGEMENTS_H__ diff --git a/sbf-cpp/Derangements_test.cpp b/sbf-cpp/Derangements_test.cpp index 45235a7..fe47af7 100644 --- a/sbf-cpp/Derangements_test.cpp +++ b/sbf-cpp/Derangements_test.cpp @@ -1,10 +1,234 @@ #include "Derangements.h" #include "test.h" +#include +#include +#include +#include + using namespace SBF; 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 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; } +namespace Test::Derangements { +TestResults test_GetDerangement() { + return execute_suite(make_test_suite( + "SBF::GetDerangement", + GetDerangement, + vector>({ + make_test( + "should get {0, "", "", 0} for invalid derangement id 0", + {0, "", "", 0}, + make_tuple(0)), + make_test( + "should get {kDerangementAmnesiaId, kDerangementAmnesiaLabel, kDerangementAmnesiaDescription, kDerangementAmnesiaTextColor} for derangement id 1", + kDerangementAmnesia, + make_tuple(1)), + make_test( + "should get {kDerangementDelusionsOfGrandeurId, kDerangementDelusionsOfGrandeurLabel, kDerangementDelusionsOfGrandeurDescription, kDerangementDelusionsOfGrandeurTextColor} for derangement id 2", + kDerangementDelusionsOfGrandeur, + make_tuple(2)), + make_test( + "should get {kDerangementFantasyId, kDerangementFantasyLabel, kDerangementFantasyDescription, kDerangementFantasyTextColor} for derangement id 3", + kDerangementFantasy, + make_tuple(3)), + make_test( + "should get {kDerangementManicDepressionId, kDerangementManicDepressionLabel, kDerangementManicDepressionDescription, kDerangementManicDepressionTextColor} for derangement id 4", + kDerangementManicDepression, + make_tuple(4)), + make_test( + "should get {kDerangementMultiplePersonalitiesId, kDerangementMultiplePersonalitiesLabel, kDerangementMultiplePersonalitiesDescription, kDerangementMultiplePersonalitiesTextColor} for derangement id 5", + kDerangementMultiplePersonalities, + make_tuple(5)), + make_test( + "should get {kDerangementObsessionId, kDerangementObsessionLabel, kDerangementObsessionDescription, kDerangementObsessionTextColor} for derangement id 6", + kDerangementObsession, + make_tuple(6)), + make_test( + "should get {kDerangementOvercompensationId, kDerangementOvercompensationLabel, kDerangementOvercompensationDescription, kDerangementOvercompensationTextColor} for derangement id 7", + kDerangementOvercompensation, + make_tuple(7)), + make_test( + "should get {kDerangementParanoiaId, kDerangementParanoiaLabel, kDerangementParanoiaDescription, kDerangementParanoiaTextColor} for derangement id 8", + kDerangementParanoia, + make_tuple(8)), + make_test( + "should get {kDerangementPerfectionId, kDerangementPerfectionLabel, kDerangementPerfectionDescription, kDerangementPerfectionTextColor} for derangement id 9", + kDerangementPerfection, + make_tuple(9)), + make_test( + "should get {kDerangementRegressionId, kDerangementRegressionLabel, kDerangementRegressionDescription, kDerangementRegressionTextColor} for derangement id 10", + kDerangementRegression, + make_tuple(10)), + make_test( + "should get {0, "", "", 0} for invalid derangement id 11", + {0, "", "", 0}, + make_tuple(11)), + }) + )); +} + +TestResults test_FillDerangements() { + auto fnToTest = []()->string { + ostringstream error_message; + vector expected = { + kDerangementAmnesia, + kDerangementDelusionsOfGrandeur, + kDerangementFantasy, + kDerangementManicDepression, + kDerangementMultiplePersonalities, + kDerangementObsession, + kDerangementOvercompensation, + kDerangementParanoia, + kDerangementPerfection, + kDerangementRegression, + }; + vector 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(make_test_suite( + "SBF::FillDerangements", + fnToTest, + vector>({ + make_test( + "should fill derangements", + "no errors", + make_tuple()), + }) + )); +} + +TestResults test_DerangementType_operator_extract() { + return execute_suite(make_test_suite( + "SBF::DerangementType::operator<<", + [](const DerangementType& derangement){ + ostringstream os; + os << derangement; + return os.str(); + }, + vector>({ + make_test( + "should print amnesia", + "Derangement: {id: 1, label: \"" + kDerangementAmnesiaLabel + "\", description: \"" + kDerangementAmnesiaDescription + "\", textColor: 4}", + make_tuple(kDerangementAmnesia)), + make_test( + "should print delusions of grandeur", + "Derangement: {id: 2, label: \"" + kDerangementDelusionsOfGrandeurLabel + "\", description: \"" + kDerangementDelusionsOfGrandeurDescription + "\", textColor: 5}", + make_tuple(kDerangementDelusionsOfGrandeur)), + make_test( + "should print fantasy", + "Derangement: {id: 3, label: \"" + kDerangementFantasyLabel + "\", description: \"" + kDerangementFantasyDescription + "\", textColor: 6}", + make_tuple(kDerangementFantasy)), + make_test( + "should print manic depression", + "Derangement: {id: 4, label: \"" + kDerangementManicDepressionLabel + "\", description: \"" + kDerangementManicDepressionDescription + "\", textColor: 7}", + make_tuple(kDerangementManicDepression)), + make_test( + "should print multiple personalities", + "Derangement: {id: 5, label: \"" + kDerangementMultiplePersonalitiesLabel + "\", description: \"" + kDerangementMultiplePersonalitiesDescription + "\", textColor: 1}", + make_tuple(kDerangementMultiplePersonalities)), + make_test( + "should print obsession", + "Derangement: {id: 6, label: \"" + kDerangementObsessionLabel + "\", description: \"" + kDerangementObsessionDescription + "\", textColor: 10}", + make_tuple(kDerangementObsession)), + make_test( + "should print overcompensation", + "Derangement: {id: 7, label: \"" + kDerangementOvercompensationLabel + "\", description: \"" + kDerangementOvercompensationDescription + "\", textColor: 11}", + make_tuple(kDerangementOvercompensation)), + make_test( + "should print paranoia", + "Derangement: {id: 8, label: \"" + kDerangementParanoiaLabel + "\", description: \"" + kDerangementParanoiaDescription + "\", textColor: 12}", + make_tuple(kDerangementParanoia)), + make_test( + "should print perfection", + "Derangement: {id: 9, label: \"" + kDerangementPerfectionLabel + "\", description: \"" + kDerangementPerfectionDescription + "\", textColor: 13}", + make_tuple(kDerangementPerfection)), + make_test( + "should print regression", + "Derangement: {id: 10, label: \"" + kDerangementRegressionLabel + "\", description: \"" + kDerangementRegressionDescription + "\", textColor: 14}", + make_tuple(kDerangementRegression)), + make_test( + "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( + make_test_suite( + "SBF::DerangementType::operator==", + [](const DerangementType& left, const DerangementType& right) { + return left == right; + }, + vector>({ + make_test( + "should return true when comparing a derangement to itself", + true, + make_tuple(kDerangementDelusionsOfGrandeur, kDerangementDelusionsOfGrandeur)), + make_test( + "should return true when comparing two different instances created with the same values", + true, + make_tuple(kDerangementFantasy, DerangementType({kDerangementFantasyId, kDerangementFantasyLabel, kDerangementFantasyDescription, kDerangementFantasyTextColor}))), + make_test( + "should return false when comparing two different derangements", + false, + make_tuple(kDerangementManicDepression, kDerangementParanoia)), + }) + )); +} + +TestResults test_DerangementType_operator_not_equal_to() { + return execute_suite( + make_test_suite( + "SBF::DerangementType::operator!=", + [](const DerangementType& left, const DerangementType& right) { + return left != right; + }, + vector>({ + make_test( + "should return false when comparing a derangement to itself", + false, + make_tuple(kDerangementDelusionsOfGrandeur, kDerangementDelusionsOfGrandeur)), + make_test( + "should return false when comparing two different instances created with the same values", + false, + make_tuple(kDerangementFantasy, DerangementType({kDerangementFantasyId, kDerangementFantasyLabel, kDerangementFantasyDescription, kDerangementFantasyTextColor}))), + make_test( + "should return true when comparing two different derangements", + true, + make_tuple(kDerangementManicDepression, kDerangementParanoia)), + }) + )); +} + +} // End Test::Derangements