diff --git a/Hazelnupp/Hazelnupp.cpp b/Hazelnupp/CmdArgsInterface.cpp similarity index 80% rename from Hazelnupp/Hazelnupp.cpp rename to Hazelnupp/CmdArgsInterface.cpp index 8d5d829..531ca2b 100644 --- a/Hazelnupp/Hazelnupp.cpp +++ b/Hazelnupp/CmdArgsInterface.cpp @@ -1,4 +1,4 @@ -#include "Hazelnupp.h" +#include "CmdArgsInterface.h" #include "VoidValue.h" #include "IntValue.h" #include "FloatValue.h" @@ -12,18 +12,18 @@ using namespace Hazelnp; -Hazelnupp::Hazelnupp() +CmdArgsInterface::CmdArgsInterface() { return; } -Hazelnupp::Hazelnupp(const int argc, const char* const* argv) +CmdArgsInterface::CmdArgsInterface(const int argc, const char* const* argv) { Parse(argc, argv); return; } -Hazelnupp::~Hazelnupp() +CmdArgsInterface::~CmdArgsInterface() { for (auto& it : parameters) delete it.second; @@ -33,7 +33,7 @@ Hazelnupp::~Hazelnupp() return; } -void Hazelnupp::Parse(const int argc, const char* const* argv) +void CmdArgsInterface::Parse(const int argc, const char* const* argv) { try { @@ -98,7 +98,7 @@ void Hazelnupp::Parse(const int argc, const char* const* argv) return; } -std::size_t Hazelnupp::ParseNextParameter(const std::size_t parIndex, Parameter*& out_Par) +std::size_t CmdArgsInterface::ParseNextParameter(const std::size_t parIndex, Parameter*& out_Par) { std::size_t i = parIndex; const std::string key = rawArgs[parIndex]; @@ -131,7 +131,7 @@ std::size_t Hazelnupp::ParseNextParameter(const std::size_t parIndex, Parameter* return i; } -void Hazelnupp::PopulateRawArgs(const int argc, const char* const* argv) +void CmdArgsInterface::PopulateRawArgs(const int argc, const char* const* argv) { rawArgs.clear(); rawArgs.reserve(argc); @@ -142,7 +142,7 @@ void Hazelnupp::PopulateRawArgs(const int argc, const char* const* argv) return; } -void Hazelnupp::ExpandAbbreviations() +void CmdArgsInterface::ExpandAbbreviations() { // Abort if no abbreviations if (parameterAbreviations.size() == 0) @@ -162,12 +162,12 @@ void Hazelnupp::ExpandAbbreviations() return; } -bool Hazelnupp::HasParam(const std::string& key) const +bool CmdArgsInterface::HasParam(const std::string& key) const { return parameters.find(key) != parameters.end(); } -Value* Hazelnupp::ParseValue(const std::vector& values, const ParamConstraint* constraint) +Value* CmdArgsInterface::ParseValue(const std::vector& values, const ParamConstraint* constraint) { // This is the raw (unconverted) data type the user provided DATA_TYPE rawInputType; @@ -326,40 +326,40 @@ Value* Hazelnupp::ParseValue(const std::vector& values, const Param return nullptr; } -bool Hazelnupp::GetCrashOnFail() const +bool CmdArgsInterface::GetCrashOnFail() const { return crashOnFail; } -void Hazelnupp::SetCatchHelp(bool catchHelp) +void CmdArgsInterface::SetCatchHelp(bool catchHelp) { this->catchHelp = catchHelp; return; } -bool Hazelnupp::GetCatchHelp() const +bool CmdArgsInterface::GetCatchHelp() const { return catchHelp; } -void Hazelnupp::SetBriefDescription(const std::string& description) +void CmdArgsInterface::SetBriefDescription(const std::string& description) { briefDescription = description; return; } -const std::string& Hazelnupp::GetBriefDescription() +const std::string& CmdArgsInterface::GetBriefDescription() { return briefDescription; } -void Hazelnp::Hazelnupp::RegisterDescription(const std::string& parameter, const std::string& description) +void Hazelnp::CmdArgsInterface::RegisterDescription(const std::string& parameter, const std::string& description) { parameterDescriptions[parameter] = description; return; } -const std::string& Hazelnp::Hazelnupp::GetDescription(const std::string& parameter) const +const std::string& Hazelnp::CmdArgsInterface::GetDescription(const std::string& parameter) const { // Do we already have a description for this parameter? if (!HasDescription(parameter)) @@ -370,25 +370,25 @@ const std::string& Hazelnp::Hazelnupp::GetDescription(const std::string& paramet return parameterDescriptions.find(parameter)->second; } -bool Hazelnupp::HasDescription(const std::string& parameter) const +bool CmdArgsInterface::HasDescription(const std::string& parameter) const { return parameterDescriptions.find(parameter) != parameterDescriptions.end(); } -void Hazelnupp::ClearDescription(const std::string& parameter) +void CmdArgsInterface::ClearDescription(const std::string& parameter) { // This will just do nothing if the entry does not exist parameterDescriptions.erase(parameter); return; } -void Hazelnp::Hazelnupp::ClearDescriptions() +void Hazelnp::CmdArgsInterface::ClearDescriptions() { parameterDescriptions.clear(); return; } -std::string Hazelnupp::GenerateDocumentation() const +std::string CmdArgsInterface::GenerateDocumentation() const { std::stringstream ss; @@ -502,7 +502,7 @@ std::string Hazelnupp::GenerateDocumentation() const return ss.str(); } -void Hazelnupp::ApplyConstraints() +void CmdArgsInterface::ApplyConstraints() { // Enforce required parameters / default values for (const auto& pc : parameterConstraints) @@ -539,23 +539,23 @@ void Hazelnupp::ApplyConstraints() return; } -ParamConstraint Hazelnupp::GetConstraint(const std::string& parameter) const +ParamConstraint CmdArgsInterface::GetConstraint(const std::string& parameter) const { return parameterConstraints.find(parameter)->second; } -void Hazelnupp::ClearConstraint(const std::string& parameter) +void CmdArgsInterface::ClearConstraint(const std::string& parameter) { parameterConstraints.erase(parameter); return; } -const std::string& Hazelnupp::GetExecutableName() const +const std::string& CmdArgsInterface::GetExecutableName() const { return executableName; } -const Value& Hazelnupp::operator[](const std::string& key) const +const Value& CmdArgsInterface::operator[](const std::string& key) const { // Throw exception if param is unknown if (!HasParam(key)) @@ -564,13 +564,13 @@ const Value& Hazelnupp::operator[](const std::string& key) const return *parameters.find(key)->second->GetValue(); } -void Hazelnupp::RegisterAbbreviation(const std::string& abbrev, const std::string& target) +void CmdArgsInterface::RegisterAbbreviation(const std::string& abbrev, const std::string& target) { parameterAbreviations.insert(std::pair(abbrev, target)); return; } -const std::string& Hazelnupp::GetAbbreviation(const std::string& abbrev) const +const std::string& CmdArgsInterface::GetAbbreviation(const std::string& abbrev) const { if (!HasAbbreviation(abbrev)) return Placeholders::g_emptyString; @@ -578,43 +578,43 @@ const std::string& Hazelnupp::GetAbbreviation(const std::string& abbrev) const return parameterAbreviations.find(abbrev)->second; } -bool Hazelnupp::HasAbbreviation(const std::string& abbrev) const +bool CmdArgsInterface::HasAbbreviation(const std::string& abbrev) const { return parameterAbreviations.find(abbrev) != parameterAbreviations.end(); } -void Hazelnupp::ClearAbbreviation(const std::string& abbrevation) +void CmdArgsInterface::ClearAbbreviation(const std::string& abbrevation) { parameterAbreviations.erase(abbrevation); return; } -void Hazelnupp::ClearAbbreviations() +void CmdArgsInterface::ClearAbbreviations() { parameterAbreviations.clear(); return; } -void Hazelnupp::RegisterConstraint(const std::string& key, const ParamConstraint& constraint) +void CmdArgsInterface::RegisterConstraint(const std::string& key, const ParamConstraint& constraint) { // Magic syntax, wooo (parameterConstraints[key] = constraint).key = key; return; } -void Hazelnupp::ClearConstraints() +void CmdArgsInterface::ClearConstraints() { parameterConstraints.clear(); return; } -void Hazelnupp::SetCrashOnFail(bool crashOnFail) +void CmdArgsInterface::SetCrashOnFail(bool crashOnFail) { this->crashOnFail = crashOnFail; return; } -const ParamConstraint* Hazelnupp::GetConstraintForKey(const std::string& key) const +const ParamConstraint* CmdArgsInterface::GetConstraintForKey(const std::string& key) const { const auto constraint = parameterConstraints.find(key); diff --git a/Hazelnupp/Hazelnupp.h b/Hazelnupp/CmdArgsInterface.h similarity index 85% rename from Hazelnupp/Hazelnupp.h rename to Hazelnupp/CmdArgsInterface.h index a775219..ccd4d01 100644 --- a/Hazelnupp/Hazelnupp.h +++ b/Hazelnupp/CmdArgsInterface.h @@ -8,13 +8,13 @@ namespace Hazelnp { /** The main class to interface with */ - class Hazelnupp + class CmdArgsInterface { public: - Hazelnupp(); - Hazelnupp(const int argc, const char* const* argv); + CmdArgsInterface(); + CmdArgsInterface(const int argc, const char* const* argv); - ~Hazelnupp(); + ~CmdArgsInterface(); //! Will parse command line arguments void Parse(const int argc, const char* const* argv); @@ -67,10 +67,10 @@ namespace Hazelnp //! Gets whether the application crashes on an exception whilst parsing, and prints to stderr. bool GetCrashOnFail() const; - //! Sets whether the Hazelnupp should automatically catch the --help parameter, print the parameter documentation to stdout, and exit or not. + //! Sets whether the CmdArgsInterface should automatically catch the --help parameter, print the parameter documentation to stdout, and exit or not. void SetCatchHelp(bool catchHelp); - //! Retruns whether the Hazelnupp should automatically catch the --help parameter, print the parameter documentation to stdout, and exit or not. + //! Retruns whether the CmdArgsInterface should automatically catch the --help parameter, print the parameter documentation to stdout, and exit or not. bool GetCatchHelp() const; //! Sets a brief description of the application to be automatically added to the documentation. @@ -137,10 +137,10 @@ namespace Hazelnp //! A brief description of the application to be added to the generated documentation. Optional. std::string briefDescription; - //! If set to true, Hazelnupp will automatically catch the --help parameter, print the parameter documentation to stdout and exit. + //! If set to true, CmdArgsInterface will automatically catch the --help parameter, print the parameter documentation to stdout and exit. bool catchHelp = true; - //! If set to true, Hazelnupp will crash the application with output to stderr when an exception is thrown whilst parsing. + //! If set to true, CmdArgsInterface will crash the application with output to stderr when an exception is thrown whilst parsing. bool crashOnFail = true; }; } diff --git a/Hazelnupp/Hazelnupp.vcxproj b/Hazelnupp/Hazelnupp.vcxproj index 4590f97..8c6cbe2 100644 --- a/Hazelnupp/Hazelnupp.vcxproj +++ b/Hazelnupp/Hazelnupp.vcxproj @@ -140,7 +140,7 @@ - + @@ -151,7 +151,7 @@ - + diff --git a/Hazelnupp/Hazelnupp.vcxproj.filters b/Hazelnupp/Hazelnupp.vcxproj.filters index 9bf5e80..b6a229d 100644 --- a/Hazelnupp/Hazelnupp.vcxproj.filters +++ b/Hazelnupp/Hazelnupp.vcxproj.filters @@ -15,9 +15,6 @@ - - Quelldateien - Quelldateien @@ -42,11 +39,11 @@ Quelldateien + + Quelldateien + - - Headerdateien - Headerdateien @@ -83,5 +80,8 @@ Headerdateien + + Headerdateien + \ No newline at end of file diff --git a/Hazelnupp/ParamConstraint.h b/Hazelnupp/ParamConstraint.h index 3d4ce7e..2820336 100644 --- a/Hazelnupp/ParamConstraint.h +++ b/Hazelnupp/ParamConstraint.h @@ -64,6 +64,6 @@ namespace Hazelnp //! This value is automatically set by Hazelnupp. std::string key; - friend class Hazelnupp; + friend class CmdArgsInterface; }; } diff --git a/StaticTestProject/main.cpp b/StaticTestProject/main.cpp index 912ef0a..c769ddd 100644 --- a/StaticTestProject/main.cpp +++ b/StaticTestProject/main.cpp @@ -1,31 +1,31 @@ #include -#include "../Hazelnupp/Hazelnupp.h" +#include "../Hazelnupp/CmdArgsInterface.h" using namespace Hazelnp; int main(int argc, char** argv) { - Hazelnupp nupp; + CmdArgsInterface args; - nupp.SetBriefDescription("This is the testing application for Hazelnupp."); + args.SetBriefDescription("This is the testing application for Hazelnupp."); - nupp.RegisterDescription("--help", "This will display the parameter documentation."); - nupp.RegisterDescription("--force", "Just forces it."); - nupp.RegisterDescription("--width", "The width of something..."); - nupp.RegisterDescription("--name", "The names to target"); - nupp.RegisterDescription("--fruit", "The fruit to use"); + args.RegisterDescription("--help", "This will display the parameter documentation."); + args.RegisterDescription("--force", "Just forces it."); + args.RegisterDescription("--width", "The width of something..."); + args.RegisterDescription("--name", "The names to target"); + args.RegisterDescription("--fruit", "The fruit to use"); - nupp.RegisterAbbreviation("-f", "--force"); - nupp.RegisterAbbreviation("-w", "--width"); - nupp.RegisterAbbreviation("-h", "--height"); - nupp.RegisterAbbreviation("-d", "--depth"); + args.RegisterAbbreviation("-f", "--force"); + args.RegisterAbbreviation("-w", "--width"); + args.RegisterAbbreviation("-h", "--height"); + args.RegisterAbbreviation("-d", "--depth"); - nupp.RegisterConstraint("--width", ParamConstraint::TypeSafety(DATA_TYPE::FLOAT)); - nupp.RegisterConstraint("--depth", ParamConstraint::TypeSafety(DATA_TYPE::FLOAT)); - nupp.RegisterConstraint("--name", ParamConstraint(true, DATA_TYPE::LIST, { "peter", "hannes" }, true)); - nupp.RegisterConstraint("--fruit", ParamConstraint(true, DATA_TYPE::STRING, {}, true)); + args.RegisterConstraint("--width", ParamConstraint::TypeSafety(DATA_TYPE::FLOAT)); + args.RegisterConstraint("--depth", ParamConstraint::TypeSafety(DATA_TYPE::FLOAT)); + args.RegisterConstraint("--name", ParamConstraint(true, DATA_TYPE::LIST, { "peter", "hannes" }, true)); + args.RegisterConstraint("--fruit", ParamConstraint(true, DATA_TYPE::STRING, {}, true)); - nupp.Parse(argc, argv); + args.Parse(argc, argv); return 0; } diff --git a/Test_Hazelnupp/Abbreviations.cpp b/Test_Hazelnupp/Abbreviations.cpp index e4e7b2e..572e284 100644 --- a/Test_Hazelnupp/Abbreviations.cpp +++ b/Test_Hazelnupp/Abbreviations.cpp @@ -1,6 +1,6 @@ #include "CppUnitTest.h" #include "helper.h" -#include "../Hazelnupp/Hazelnupp.h" +#include "../Hazelnupp/CmdArgsInterface.h" using namespace Microsoft::VisualStudio::CppUnitTestFramework; using namespace Hazelnp; @@ -36,25 +36,25 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterAbbreviation("-ms", "--my_string"); - nupp.RegisterAbbreviation("-mv", "--my_void"); - nupp.RegisterAbbreviation("-mi", "--my_int"); - nupp.RegisterAbbreviation("-mf", "--my_float"); - nupp.RegisterAbbreviation("-mnl", "--my_num_list"); - nupp.RegisterAbbreviation("-msl", "--my_str_list"); + cmdArgsI.RegisterAbbreviation("-ms", "--my_string"); + cmdArgsI.RegisterAbbreviation("-mv", "--my_void"); + cmdArgsI.RegisterAbbreviation("-mi", "--my_int"); + cmdArgsI.RegisterAbbreviation("-mf", "--my_float"); + cmdArgsI.RegisterAbbreviation("-mnl", "--my_num_list"); + cmdArgsI.RegisterAbbreviation("-msl", "--my_str_list"); - nupp.Parse(C_Ify(args)); + cmdArgsI.Parse(C_Ify(args)); // Verify - Assert::IsTrue(nupp.HasParam("--my_string")); - Assert::IsTrue(nupp.HasParam("--my_void")); - Assert::IsTrue(nupp.HasParam("--my_float")); - Assert::IsTrue(nupp.HasParam("--my_int")); - Assert::IsTrue(nupp.HasParam("--my_num_list")); - Assert::IsTrue(nupp.HasParam("--my_str_list")); + Assert::IsTrue(cmdArgsI.HasParam("--my_string")); + Assert::IsTrue(cmdArgsI.HasParam("--my_void")); + Assert::IsTrue(cmdArgsI.HasParam("--my_float")); + Assert::IsTrue(cmdArgsI.HasParam("--my_int")); + Assert::IsTrue(cmdArgsI.HasParam("--my_num_list")); + Assert::IsTrue(cmdArgsI.HasParam("--my_str_list")); return; } @@ -84,25 +84,25 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterAbbreviation("-ms", "--my_string"); - nupp.RegisterAbbreviation("-mv", "--my_void"); - nupp.RegisterAbbreviation("-mi", "--my_int"); - nupp.RegisterAbbreviation("-mf", "--my_float"); - nupp.RegisterAbbreviation("-mnl", "--my_num_list"); - nupp.RegisterAbbreviation("-msl", "--my_str_list"); + cmdArgsI.RegisterAbbreviation("-ms", "--my_string"); + cmdArgsI.RegisterAbbreviation("-mv", "--my_void"); + cmdArgsI.RegisterAbbreviation("-mi", "--my_int"); + cmdArgsI.RegisterAbbreviation("-mf", "--my_float"); + cmdArgsI.RegisterAbbreviation("-mnl", "--my_num_list"); + cmdArgsI.RegisterAbbreviation("-msl", "--my_str_list"); - nupp.Parse(C_Ify(args)); + cmdArgsI.Parse(C_Ify(args)); // Verify - Assert::IsTrue(nupp["--my_string"].GetDataType() == DATA_TYPE::STRING); - Assert::IsTrue(nupp["--my_void"].GetDataType() == DATA_TYPE::VOID); - Assert::IsTrue(nupp["--my_float"].GetDataType() == DATA_TYPE::FLOAT); - Assert::IsTrue(nupp["--my_int"].GetDataType() == DATA_TYPE::INT); - Assert::IsTrue(nupp["--my_num_list"].GetDataType() == DATA_TYPE::LIST); - Assert::IsTrue(nupp["--my_str_list"].GetDataType() == DATA_TYPE::LIST); + Assert::IsTrue(cmdArgsI["--my_string"].GetDataType() == DATA_TYPE::STRING); + Assert::IsTrue(cmdArgsI["--my_void"].GetDataType() == DATA_TYPE::VOID); + Assert::IsTrue(cmdArgsI["--my_float"].GetDataType() == DATA_TYPE::FLOAT); + Assert::IsTrue(cmdArgsI["--my_int"].GetDataType() == DATA_TYPE::INT); + Assert::IsTrue(cmdArgsI["--my_num_list"].GetDataType() == DATA_TYPE::LIST); + Assert::IsTrue(cmdArgsI["--my_str_list"].GetDataType() == DATA_TYPE::LIST); return; } @@ -132,29 +132,29 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterAbbreviation("-ms", "--my_string"); - nupp.RegisterAbbreviation("-mv", "--my_void"); - nupp.RegisterAbbreviation("-mi", "--my_int"); - nupp.RegisterAbbreviation("-mf", "--my_float"); - nupp.RegisterAbbreviation("-mnl", "--my_num_list"); - nupp.RegisterAbbreviation("-msl", "--my_str_list"); + cmdArgsI.RegisterAbbreviation("-ms", "--my_string"); + cmdArgsI.RegisterAbbreviation("-mv", "--my_void"); + cmdArgsI.RegisterAbbreviation("-mi", "--my_int"); + cmdArgsI.RegisterAbbreviation("-mf", "--my_float"); + cmdArgsI.RegisterAbbreviation("-mnl", "--my_num_list"); + cmdArgsI.RegisterAbbreviation("-msl", "--my_str_list"); - nupp.Parse(C_Ify(args)); + cmdArgsI.Parse(C_Ify(args)); // Verify - Assert::AreEqual(nupp["--my_string"].GetString(), std::string("billybob")); - Assert::AreEqual(nupp["--my_float"].GetFloat32(), -23.199); - Assert::AreEqual(nupp["--my_int"].GetInt32(), 199); - Assert::AreEqual(nupp["--my_num_list"].GetList()[0]->GetInt32(), 1); - Assert::AreEqual(nupp["--my_num_list"].GetList()[1]->GetInt32(), 2); - Assert::AreEqual(nupp["--my_num_list"].GetList()[2]->GetInt32(), 3); - Assert::AreEqual(nupp["--my_num_list"].GetList()[3]->GetInt32(), 4); - Assert::AreEqual(nupp["--my_str_list"].GetList()[0]->GetString(), std::string("apple")); - Assert::AreEqual(nupp["--my_str_list"].GetList()[1]->GetString(), std::string("banana")); - Assert::AreEqual(nupp["--my_str_list"].GetList()[2]->GetString(), std::string("pumpkin")); + Assert::AreEqual(cmdArgsI["--my_string"].GetString(), std::string("billybob")); + Assert::AreEqual(cmdArgsI["--my_float"].GetFloat32(), -23.199); + Assert::AreEqual(cmdArgsI["--my_int"].GetInt32(), 199); + Assert::AreEqual(cmdArgsI["--my_num_list"].GetList()[0]->GetInt32(), 1); + Assert::AreEqual(cmdArgsI["--my_num_list"].GetList()[1]->GetInt32(), 2); + Assert::AreEqual(cmdArgsI["--my_num_list"].GetList()[2]->GetInt32(), 3); + Assert::AreEqual(cmdArgsI["--my_num_list"].GetList()[3]->GetInt32(), 4); + Assert::AreEqual(cmdArgsI["--my_str_list"].GetList()[0]->GetString(), std::string("apple")); + Assert::AreEqual(cmdArgsI["--my_str_list"].GetList()[1]->GetString(), std::string("banana")); + Assert::AreEqual(cmdArgsI["--my_str_list"].GetList()[2]->GetString(), std::string("pumpkin")); return; } @@ -163,19 +163,19 @@ namespace TestHazelnupp TEST_METHOD(Get_Abbreviation) { // Setup - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterAbbreviation("-ms", "--my_string"); - nupp.RegisterAbbreviation("-mv", "--my_void"); - nupp.RegisterAbbreviation("-mi", "--my_int"); - nupp.RegisterAbbreviation("-mf", "--my_float"); - nupp.RegisterAbbreviation("-mnl", "--my_num_list"); - nupp.RegisterAbbreviation("-msl", "--my_str_list"); + cmdArgsI.RegisterAbbreviation("-ms", "--my_string"); + cmdArgsI.RegisterAbbreviation("-mv", "--my_void"); + cmdArgsI.RegisterAbbreviation("-mi", "--my_int"); + cmdArgsI.RegisterAbbreviation("-mf", "--my_float"); + cmdArgsI.RegisterAbbreviation("-mnl", "--my_num_list"); + cmdArgsI.RegisterAbbreviation("-msl", "--my_str_list"); // Exercise, verify - Assert::AreEqual(std::string("--my_num_list"), nupp.GetAbbreviation("-mnl")); - Assert::AreEqual(std::string("--my_void"), nupp.GetAbbreviation("-mv")); + Assert::AreEqual(std::string("--my_num_list"), cmdArgsI.GetAbbreviation("-mnl")); + Assert::AreEqual(std::string("--my_void"), cmdArgsI.GetAbbreviation("-mv")); return; } @@ -184,21 +184,21 @@ namespace TestHazelnupp TEST_METHOD(Unknown_Abbrevation_Is_Empty_String) { // Setup - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterAbbreviation("-ms", "--my_string"); - nupp.RegisterAbbreviation("-mv", "--my_void"); - nupp.RegisterAbbreviation("-mi", "--my_int"); - nupp.RegisterAbbreviation("-mf", "--my_float"); - nupp.RegisterAbbreviation("-mnl", "--my_num_list"); - nupp.RegisterAbbreviation("-msl", "--my_str_list"); + cmdArgsI.RegisterAbbreviation("-ms", "--my_string"); + cmdArgsI.RegisterAbbreviation("-mv", "--my_void"); + cmdArgsI.RegisterAbbreviation("-mi", "--my_int"); + cmdArgsI.RegisterAbbreviation("-mf", "--my_float"); + cmdArgsI.RegisterAbbreviation("-mnl", "--my_num_list"); + cmdArgsI.RegisterAbbreviation("-msl", "--my_str_list"); // Exercise - nupp.ClearAbbreviations(); + cmdArgsI.ClearAbbreviations(); // Verify - Assert::AreEqual(std::string(), nupp.GetAbbreviation("-t")); + Assert::AreEqual(std::string(), cmdArgsI.GetAbbreviation("-t")); return; } @@ -207,17 +207,17 @@ namespace TestHazelnupp TEST_METHOD(Has_Abbreviation) { // Setup - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); // Exercise, verify - Assert::IsFalse(nupp.HasAbbreviation("-f")); - Assert::IsFalse(nupp.HasAbbreviation("-m")); + Assert::IsFalse(cmdArgsI.HasAbbreviation("-f")); + Assert::IsFalse(cmdArgsI.HasAbbreviation("-m")); - nupp.RegisterAbbreviation("-f", "--force"); + cmdArgsI.RegisterAbbreviation("-f", "--force"); - Assert::IsTrue(nupp.HasAbbreviation("-f")); - Assert::IsFalse(nupp.HasAbbreviation("-m")); + Assert::IsTrue(cmdArgsI.HasAbbreviation("-f")); + Assert::IsFalse(cmdArgsI.HasAbbreviation("-m")); return; } @@ -226,28 +226,28 @@ namespace TestHazelnupp TEST_METHOD(Clear_Abbreviation) { // Setup - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterAbbreviation("-ms", "--my_string"); - nupp.RegisterAbbreviation("-mv", "--my_void"); - nupp.RegisterAbbreviation("-mi", "--my_int"); - nupp.RegisterAbbreviation("-mf", "--my_float"); - nupp.RegisterAbbreviation("-mnl", "--my_num_list"); - nupp.RegisterAbbreviation("-msl", "--my_str_list"); + cmdArgsI.RegisterAbbreviation("-ms", "--my_string"); + cmdArgsI.RegisterAbbreviation("-mv", "--my_void"); + cmdArgsI.RegisterAbbreviation("-mi", "--my_int"); + cmdArgsI.RegisterAbbreviation("-mf", "--my_float"); + cmdArgsI.RegisterAbbreviation("-mnl", "--my_num_list"); + cmdArgsI.RegisterAbbreviation("-msl", "--my_str_list"); // Exercise - nupp.ClearAbbreviation("-mv"); - nupp.ClearAbbreviation("-mf"); - nupp.ClearAbbreviation("-msl"); + cmdArgsI.ClearAbbreviation("-mv"); + cmdArgsI.ClearAbbreviation("-mf"); + cmdArgsI.ClearAbbreviation("-msl"); // Verify - Assert::IsTrue(nupp.HasAbbreviation("-ms")); - Assert::IsFalse(nupp.HasAbbreviation("-mv")); - Assert::IsTrue(nupp.HasAbbreviation("-mi")); - Assert::IsFalse(nupp.HasAbbreviation("-mf")); - Assert::IsTrue(nupp.HasAbbreviation("-mnl")); - Assert::IsFalse(nupp.HasAbbreviation("-msl")); + Assert::IsTrue(cmdArgsI.HasAbbreviation("-ms")); + Assert::IsFalse(cmdArgsI.HasAbbreviation("-mv")); + Assert::IsTrue(cmdArgsI.HasAbbreviation("-mi")); + Assert::IsFalse(cmdArgsI.HasAbbreviation("-mf")); + Assert::IsTrue(cmdArgsI.HasAbbreviation("-mnl")); + Assert::IsFalse(cmdArgsI.HasAbbreviation("-msl")); return; } @@ -256,26 +256,26 @@ namespace TestHazelnupp TEST_METHOD(Clear_Abbreviations) { // Setup - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterAbbreviation("-ms" , "--my_string"); - nupp.RegisterAbbreviation("-mv" , "--my_void"); - nupp.RegisterAbbreviation("-mi" , "--my_int"); - nupp.RegisterAbbreviation("-mf" , "--my_float"); - nupp.RegisterAbbreviation("-mnl", "--my_num_list"); - nupp.RegisterAbbreviation("-msl", "--my_str_list"); + cmdArgsI.RegisterAbbreviation("-ms" , "--my_string"); + cmdArgsI.RegisterAbbreviation("-mv" , "--my_void"); + cmdArgsI.RegisterAbbreviation("-mi" , "--my_int"); + cmdArgsI.RegisterAbbreviation("-mf" , "--my_float"); + cmdArgsI.RegisterAbbreviation("-mnl", "--my_num_list"); + cmdArgsI.RegisterAbbreviation("-msl", "--my_str_list"); // Exercise - nupp.ClearAbbreviations(); + cmdArgsI.ClearAbbreviations(); // Verify - Assert::IsFalse(nupp.HasAbbreviation("-ms" )); - Assert::IsFalse(nupp.HasAbbreviation("-mv" )); - Assert::IsFalse(nupp.HasAbbreviation("-mi" )); - Assert::IsFalse(nupp.HasAbbreviation("-mf" )); - Assert::IsFalse(nupp.HasAbbreviation("-mnl")); - Assert::IsFalse(nupp.HasAbbreviation("-msl")); + Assert::IsFalse(cmdArgsI.HasAbbreviation("-ms" )); + Assert::IsFalse(cmdArgsI.HasAbbreviation("-mv" )); + Assert::IsFalse(cmdArgsI.HasAbbreviation("-mi" )); + Assert::IsFalse(cmdArgsI.HasAbbreviation("-mf" )); + Assert::IsFalse(cmdArgsI.HasAbbreviation("-mnl")); + Assert::IsFalse(cmdArgsI.HasAbbreviation("-msl")); return; } diff --git a/Test_Hazelnupp/Basics.cpp b/Test_Hazelnupp/Basics.cpp index 84aafde..43f682b 100644 --- a/Test_Hazelnupp/Basics.cpp +++ b/Test_Hazelnupp/Basics.cpp @@ -1,6 +1,6 @@ #include "CppUnitTest.h" #include "helper.h" -#include "../Hazelnupp/Hazelnupp.h" +#include "../Hazelnupp/CmdArgsInterface.h" #include "../Hazelnupp/HazelnuppException.h" using namespace Microsoft::VisualStudio::CppUnitTestFramework; @@ -21,11 +21,11 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp(C_Ify(args)); - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI(C_Ify(args)); + cmdArgsI.SetCrashOnFail(false); // Verify - Assert::AreEqual(std::string("/my/fake/path/wahoo.out"), nupp.GetExecutableName()); + Assert::AreEqual(std::string("/my/fake/path/wahoo.out"), cmdArgsI.GetExecutableName()); return; } @@ -40,11 +40,11 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp(C_Ify(args)); - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI(C_Ify(args)); + cmdArgsI.SetCrashOnFail(false); // Verify - Assert::IsTrue(nupp.HasParam("--dummy")); + Assert::IsTrue(cmdArgsI.HasParam("--dummy")); return; } @@ -59,8 +59,8 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp(C_Ify(args)); - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI(C_Ify(args)); + cmdArgsI.SetCrashOnFail(false); // Verify (no exception) @@ -78,12 +78,12 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp(C_Ify(args)); - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI(C_Ify(args)); + cmdArgsI.SetCrashOnFail(false); // Verify - Assert::IsTrue(nupp.HasParam("--dummy"), L"Failed has-param"); - Assert::IsTrue(nupp["--dummy"].GetDataType() == DATA_TYPE::VOID, L"Failed type"); + Assert::IsTrue(cmdArgsI.HasParam("--dummy"), L"Failed has-param"); + Assert::IsTrue(cmdArgsI["--dummy"].GetDataType() == DATA_TYPE::VOID, L"Failed type"); return; } @@ -113,16 +113,16 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp(C_Ify(args)); - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI(C_Ify(args)); + cmdArgsI.SetCrashOnFail(false); // Verify - Assert::IsTrue(nupp.HasParam("--my_string")); - Assert::IsTrue(nupp.HasParam("--my_void")); - Assert::IsTrue(nupp.HasParam("--my_float")); - Assert::IsTrue(nupp.HasParam("--my_int")); - Assert::IsTrue(nupp.HasParam("--my_num_list")); - Assert::IsTrue(nupp.HasParam("--my_str_list")); + Assert::IsTrue(cmdArgsI.HasParam("--my_string")); + Assert::IsTrue(cmdArgsI.HasParam("--my_void")); + Assert::IsTrue(cmdArgsI.HasParam("--my_float")); + Assert::IsTrue(cmdArgsI.HasParam("--my_int")); + Assert::IsTrue(cmdArgsI.HasParam("--my_num_list")); + Assert::IsTrue(cmdArgsI.HasParam("--my_str_list")); return; } @@ -152,16 +152,16 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp(C_Ify(args)); - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI(C_Ify(args)); + cmdArgsI.SetCrashOnFail(false); // Verify - Assert::IsTrue(nupp["--my_string"].GetDataType() == DATA_TYPE::STRING); - Assert::IsTrue(nupp["--my_void"].GetDataType() == DATA_TYPE::VOID); - Assert::IsTrue(nupp["--my_float"].GetDataType() == DATA_TYPE::FLOAT); - Assert::IsTrue(nupp["--my_int"].GetDataType() == DATA_TYPE::INT); - Assert::IsTrue(nupp["--my_num_list"].GetDataType() == DATA_TYPE::LIST); - Assert::IsTrue(nupp["--my_str_list"].GetDataType() == DATA_TYPE::LIST); + Assert::IsTrue(cmdArgsI["--my_string"].GetDataType() == DATA_TYPE::STRING); + Assert::IsTrue(cmdArgsI["--my_void"].GetDataType() == DATA_TYPE::VOID); + Assert::IsTrue(cmdArgsI["--my_float"].GetDataType() == DATA_TYPE::FLOAT); + Assert::IsTrue(cmdArgsI["--my_int"].GetDataType() == DATA_TYPE::INT); + Assert::IsTrue(cmdArgsI["--my_num_list"].GetDataType() == DATA_TYPE::LIST); + Assert::IsTrue(cmdArgsI["--my_str_list"].GetDataType() == DATA_TYPE::LIST); return; } @@ -191,20 +191,20 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp(C_Ify(args)); - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI(C_Ify(args)); + cmdArgsI.SetCrashOnFail(false); // Verify - Assert::AreEqual(nupp["--my_string"].GetString(), std::string("billybob")); - Assert::AreEqual(nupp["--my_float"].GetFloat32(), -23.199); - Assert::AreEqual(nupp["--my_int"].GetInt32(), 199); - Assert::AreEqual(nupp["--my_num_list"].GetList()[0]->GetInt32(), 1); - Assert::AreEqual(nupp["--my_num_list"].GetList()[1]->GetInt32(), 2); - Assert::AreEqual(nupp["--my_num_list"].GetList()[2]->GetInt32(), 3); - Assert::AreEqual(nupp["--my_num_list"].GetList()[3]->GetInt32(), 4); - Assert::AreEqual(nupp["--my_str_list"].GetList()[0]->GetString(), std::string("apple")); - Assert::AreEqual(nupp["--my_str_list"].GetList()[1]->GetString(), std::string("banana")); - Assert::AreEqual(nupp["--my_str_list"].GetList()[2]->GetString(), std::string("pumpkin")); + Assert::AreEqual(cmdArgsI["--my_string"].GetString(), std::string("billybob")); + Assert::AreEqual(cmdArgsI["--my_float"].GetFloat32(), -23.199); + Assert::AreEqual(cmdArgsI["--my_int"].GetInt32(), 199); + Assert::AreEqual(cmdArgsI["--my_num_list"].GetList()[0]->GetInt32(), 1); + Assert::AreEqual(cmdArgsI["--my_num_list"].GetList()[1]->GetInt32(), 2); + Assert::AreEqual(cmdArgsI["--my_num_list"].GetList()[2]->GetInt32(), 3); + Assert::AreEqual(cmdArgsI["--my_num_list"].GetList()[3]->GetInt32(), 4); + Assert::AreEqual(cmdArgsI["--my_str_list"].GetList()[0]->GetString(), std::string("apple")); + Assert::AreEqual(cmdArgsI["--my_str_list"].GetList()[1]->GetString(), std::string("banana")); + Assert::AreEqual(cmdArgsI["--my_str_list"].GetList()[2]->GetString(), std::string("pumpkin")); return; } @@ -233,15 +233,15 @@ namespace TestHazelnupp "pumpkin", }); - Hazelnupp nupp(C_Ify(args)); - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI(C_Ify(args)); + cmdArgsI.SetCrashOnFail(false); // Exercise, Verify Assert::ExpectException( [args] { - Hazelnupp nupp(C_Ify(args)); - nupp["--borrnana"]; + CmdArgsInterface cmdArgsI(C_Ify(args)); + cmdArgsI["--borrnana"]; } ); diff --git a/Test_Hazelnupp/Constraints.cpp b/Test_Hazelnupp/Constraints.cpp index 31eca99..f55013e 100644 --- a/Test_Hazelnupp/Constraints.cpp +++ b/Test_Hazelnupp/Constraints.cpp @@ -1,6 +1,6 @@ #include "CppUnitTest.h" #include "helper.h" -#include "../Hazelnupp/Hazelnupp.h" +#include "../Hazelnupp/CmdArgsInterface.h" #include "../Hazelnupp/HazelnuppException.h" using namespace Microsoft::VisualStudio::CppUnitTestFramework; @@ -23,34 +23,34 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterConstraint("--elenor-int", ParamConstraint::Require({ "5994" })); - nupp.RegisterConstraint("--federich-float", ParamConstraint::Require({ "420.69" })); - nupp.RegisterConstraint("--siegbert-string", ParamConstraint::Require({ "banana" })); - nupp.RegisterConstraint("--lieber-liste", ParamConstraint::Require({ "banana", "apple", "59" })); + cmdArgsI.RegisterConstraint("--elenor-int", ParamConstraint::Require({ "5994" })); + cmdArgsI.RegisterConstraint("--federich-float", ParamConstraint::Require({ "420.69" })); + cmdArgsI.RegisterConstraint("--siegbert-string", ParamConstraint::Require({ "banana" })); + cmdArgsI.RegisterConstraint("--lieber-liste", ParamConstraint::Require({ "banana", "apple", "59" })); - nupp.Parse(C_Ify(args)); + cmdArgsI.Parse(C_Ify(args)); // Verify - Assert::IsTrue(nupp.HasParam("--elenor-int")); - Assert::IsTrue(nupp["--elenor-int"].GetDataType() == DATA_TYPE::INT); - Assert::AreEqual(nupp["--elenor-int"].GetInt32(), 5994); + Assert::IsTrue(cmdArgsI.HasParam("--elenor-int")); + Assert::IsTrue(cmdArgsI["--elenor-int"].GetDataType() == DATA_TYPE::INT); + Assert::AreEqual(cmdArgsI["--elenor-int"].GetInt32(), 5994); - Assert::IsTrue(nupp.HasParam("--federich-float")); - Assert::IsTrue(nupp["--federich-float"].GetDataType() == DATA_TYPE::FLOAT); - Assert::AreEqual(nupp["--federich-float"].GetFloat32(), 420.69); + Assert::IsTrue(cmdArgsI.HasParam("--federich-float")); + Assert::IsTrue(cmdArgsI["--federich-float"].GetDataType() == DATA_TYPE::FLOAT); + Assert::AreEqual(cmdArgsI["--federich-float"].GetFloat32(), 420.69); - Assert::IsTrue(nupp.HasParam("--siegbert-string")); - Assert::IsTrue(nupp["--siegbert-string"].GetDataType() == DATA_TYPE::STRING); - Assert::AreEqual(nupp["--siegbert-string"].GetString(), std::string("banana")); + Assert::IsTrue(cmdArgsI.HasParam("--siegbert-string")); + Assert::IsTrue(cmdArgsI["--siegbert-string"].GetDataType() == DATA_TYPE::STRING); + Assert::AreEqual(cmdArgsI["--siegbert-string"].GetString(), std::string("banana")); - Assert::IsTrue(nupp.HasParam("--lieber-liste")); - Assert::IsTrue(nupp["--lieber-liste"].GetDataType() == DATA_TYPE::LIST); - Assert::AreEqual(nupp["--lieber-liste"].GetList()[0]->GetString(), std::string("banana")); - Assert::AreEqual(nupp["--lieber-liste"].GetList()[1]->GetString(), std::string("apple")); - Assert::AreEqual(nupp["--lieber-liste"].GetList()[2]->GetInt32(), 59); + Assert::IsTrue(cmdArgsI.HasParam("--lieber-liste")); + Assert::IsTrue(cmdArgsI["--lieber-liste"].GetDataType() == DATA_TYPE::LIST); + Assert::AreEqual(cmdArgsI["--lieber-liste"].GetList()[0]->GetString(), std::string("banana")); + Assert::AreEqual(cmdArgsI["--lieber-liste"].GetList()[1]->GetString(), std::string("apple")); + Assert::AreEqual(cmdArgsI["--lieber-liste"].GetList()[2]->GetInt32(), 59); return; } @@ -75,34 +75,34 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterConstraint("--elenor-int", ParamConstraint::Require({ "6871" })); - nupp.RegisterConstraint("--federich-float", ParamConstraint::Require({ "-199.44" })); - nupp.RegisterConstraint("--siegbert-string", ParamConstraint::Require({ "bornana" })); - nupp.RegisterConstraint("--lieber-liste", ParamConstraint::Require({ "bornana", "ollpe", "5" })); + cmdArgsI.RegisterConstraint("--elenor-int", ParamConstraint::Require({ "6871" })); + cmdArgsI.RegisterConstraint("--federich-float", ParamConstraint::Require({ "-199.44" })); + cmdArgsI.RegisterConstraint("--siegbert-string", ParamConstraint::Require({ "bornana" })); + cmdArgsI.RegisterConstraint("--lieber-liste", ParamConstraint::Require({ "bornana", "ollpe", "5" })); - nupp.Parse(C_Ify(args)); + cmdArgsI.Parse(C_Ify(args)); // Verify - Assert::IsTrue(nupp.HasParam("--elenor-int")); - Assert::IsTrue(nupp["--elenor-int"].GetDataType() == DATA_TYPE::INT); - Assert::AreEqual(nupp["--elenor-int"].GetInt32(), 5994); + Assert::IsTrue(cmdArgsI.HasParam("--elenor-int")); + Assert::IsTrue(cmdArgsI["--elenor-int"].GetDataType() == DATA_TYPE::INT); + Assert::AreEqual(cmdArgsI["--elenor-int"].GetInt32(), 5994); - Assert::IsTrue(nupp.HasParam("--federich-float")); - Assert::IsTrue(nupp["--federich-float"].GetDataType() == DATA_TYPE::FLOAT); - Assert::AreEqual(nupp["--federich-float"].GetFloat32(), 420.69); + Assert::IsTrue(cmdArgsI.HasParam("--federich-float")); + Assert::IsTrue(cmdArgsI["--federich-float"].GetDataType() == DATA_TYPE::FLOAT); + Assert::AreEqual(cmdArgsI["--federich-float"].GetFloat32(), 420.69); - Assert::IsTrue(nupp.HasParam("--siegbert-string")); - Assert::IsTrue(nupp["--siegbert-string"].GetDataType() == DATA_TYPE::STRING); - Assert::AreEqual(nupp["--siegbert-string"].GetString(), std::string("banana")); + Assert::IsTrue(cmdArgsI.HasParam("--siegbert-string")); + Assert::IsTrue(cmdArgsI["--siegbert-string"].GetDataType() == DATA_TYPE::STRING); + Assert::AreEqual(cmdArgsI["--siegbert-string"].GetString(), std::string("banana")); - Assert::IsTrue(nupp.HasParam("--lieber-liste")); - Assert::IsTrue(nupp["--lieber-liste"].GetDataType() == DATA_TYPE::LIST); - Assert::AreEqual(nupp["--lieber-liste"].GetList()[0]->GetString(), std::string("banana")); - Assert::AreEqual(nupp["--lieber-liste"].GetList()[1]->GetString(), std::string("apple")); - Assert::AreEqual(nupp["--lieber-liste"].GetList()[2]->GetInt32(), 59); + Assert::IsTrue(cmdArgsI.HasParam("--lieber-liste")); + Assert::IsTrue(cmdArgsI["--lieber-liste"].GetDataType() == DATA_TYPE::LIST); + Assert::AreEqual(cmdArgsI["--lieber-liste"].GetList()[0]->GetString(), std::string("banana")); + Assert::AreEqual(cmdArgsI["--lieber-liste"].GetList()[1]->GetString(), std::string("apple")); + Assert::AreEqual(cmdArgsI["--lieber-liste"].GetList()[2]->GetInt32(), 59); return; } @@ -129,41 +129,41 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterConstraint("--num-apples", ParamConstraint::TypeSafety(DATA_TYPE::INT)); - nupp.RegisterConstraint("--table-height", ParamConstraint::TypeSafety(DATA_TYPE::FLOAT)); - nupp.RegisterConstraint("--license-plate", ParamConstraint::TypeSafety(DATA_TYPE::STRING)); - nupp.RegisterConstraint("--fav-fruits", ParamConstraint::TypeSafety(DATA_TYPE::LIST)); - nupp.RegisterConstraint("--indices", ParamConstraint::TypeSafety(DATA_TYPE::LIST)); - nupp.RegisterConstraint("--force", ParamConstraint::TypeSafety(DATA_TYPE::VOID)); + cmdArgsI.RegisterConstraint("--num-apples", ParamConstraint::TypeSafety(DATA_TYPE::INT)); + cmdArgsI.RegisterConstraint("--table-height", ParamConstraint::TypeSafety(DATA_TYPE::FLOAT)); + cmdArgsI.RegisterConstraint("--license-plate", ParamConstraint::TypeSafety(DATA_TYPE::STRING)); + cmdArgsI.RegisterConstraint("--fav-fruits", ParamConstraint::TypeSafety(DATA_TYPE::LIST)); + cmdArgsI.RegisterConstraint("--indices", ParamConstraint::TypeSafety(DATA_TYPE::LIST)); + cmdArgsI.RegisterConstraint("--force", ParamConstraint::TypeSafety(DATA_TYPE::VOID)); - nupp.Parse(C_Ify(args)); + cmdArgsI.Parse(C_Ify(args)); // Verify - Assert::IsTrue(nupp.HasParam("--num-apples")); - Assert::IsTrue(nupp["--num-apples"].GetDataType() == DATA_TYPE::INT); - Assert::AreEqual(nupp["--num-apples"].GetInt32(), 39); + Assert::IsTrue(cmdArgsI.HasParam("--num-apples")); + Assert::IsTrue(cmdArgsI["--num-apples"].GetDataType() == DATA_TYPE::INT); + Assert::AreEqual(cmdArgsI["--num-apples"].GetInt32(), 39); - Assert::IsTrue(nupp.HasParam("--table-height")); - Assert::IsTrue(nupp["--table-height"].GetDataType() == DATA_TYPE::FLOAT); - Assert::AreEqual(nupp["--table-height"].GetFloat32(), 400.0); + Assert::IsTrue(cmdArgsI.HasParam("--table-height")); + Assert::IsTrue(cmdArgsI["--table-height"].GetDataType() == DATA_TYPE::FLOAT); + Assert::AreEqual(cmdArgsI["--table-height"].GetFloat32(), 400.0); - Assert::IsTrue(nupp.HasParam("--license-plate")); - Assert::IsTrue(nupp["--license-plate"].GetDataType() == DATA_TYPE::STRING); - Assert::AreEqual(nupp["--license-plate"].GetString(), std::string("193273")); + Assert::IsTrue(cmdArgsI.HasParam("--license-plate")); + Assert::IsTrue(cmdArgsI["--license-plate"].GetDataType() == DATA_TYPE::STRING); + Assert::AreEqual(cmdArgsI["--license-plate"].GetString(), std::string("193273")); - Assert::IsTrue(nupp.HasParam("--fav-fruits")); - Assert::IsTrue(nupp["--fav-fruits"].GetDataType() == DATA_TYPE::LIST); - Assert::AreEqual(nupp["--fav-fruits"].GetList()[0]->GetString(), std::string("apple")); + Assert::IsTrue(cmdArgsI.HasParam("--fav-fruits")); + Assert::IsTrue(cmdArgsI["--fav-fruits"].GetDataType() == DATA_TYPE::LIST); + Assert::AreEqual(cmdArgsI["--fav-fruits"].GetList()[0]->GetString(), std::string("apple")); - Assert::IsTrue(nupp.HasParam("--indices")); - Assert::IsTrue(nupp["--indices"].GetDataType() == DATA_TYPE::LIST); - Assert::AreEqual(nupp["--indices"].GetList()[0]->GetInt32(), 9); + Assert::IsTrue(cmdArgsI.HasParam("--indices")); + Assert::IsTrue(cmdArgsI["--indices"].GetDataType() == DATA_TYPE::LIST); + Assert::AreEqual(cmdArgsI["--indices"].GetList()[0]->GetInt32(), 9); - Assert::IsTrue(nupp.HasParam("--force")); - Assert::IsTrue(nupp["--force"].GetDataType() == DATA_TYPE::VOID); + Assert::IsTrue(cmdArgsI.HasParam("--force")); + Assert::IsTrue(cmdArgsI["--force"].GetDataType() == DATA_TYPE::VOID); return; } @@ -189,15 +189,15 @@ namespace TestHazelnupp Assert::ExpectException( [args] { - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterConstraint( + cmdArgsI.RegisterConstraint( "--elenor-int", ParamConstraint::Require() ); - nupp.Parse(C_Ify(args)); + cmdArgsI.Parse(C_Ify(args)); } ); @@ -227,15 +227,15 @@ namespace TestHazelnupp Assert::ExpectException( [args] { - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterConstraint( + cmdArgsI.RegisterConstraint( "--elenor-int", ParamConstraint::TypeSafety(DATA_TYPE::INT) ); - nupp.Parse(C_Ify(args)); + cmdArgsI.Parse(C_Ify(args)); } ); @@ -261,25 +261,25 @@ namespace TestHazelnupp "baz" }); - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterConstraint("--void1", ParamConstraint::TypeSafety(DATA_TYPE::VOID)); - nupp.RegisterConstraint("--void2", ParamConstraint::TypeSafety(DATA_TYPE::VOID)); - nupp.RegisterConstraint("--void3", ParamConstraint::TypeSafety(DATA_TYPE::VOID)); - nupp.RegisterConstraint("--void4", ParamConstraint::TypeSafety(DATA_TYPE::VOID)); - nupp.RegisterConstraint("--void5", ParamConstraint::TypeSafety(DATA_TYPE::VOID)); + cmdArgsI.RegisterConstraint("--void1", ParamConstraint::TypeSafety(DATA_TYPE::VOID)); + cmdArgsI.RegisterConstraint("--void2", ParamConstraint::TypeSafety(DATA_TYPE::VOID)); + cmdArgsI.RegisterConstraint("--void3", ParamConstraint::TypeSafety(DATA_TYPE::VOID)); + cmdArgsI.RegisterConstraint("--void4", ParamConstraint::TypeSafety(DATA_TYPE::VOID)); + cmdArgsI.RegisterConstraint("--void5", ParamConstraint::TypeSafety(DATA_TYPE::VOID)); // Exercise - nupp.Parse(C_Ify(args)); + cmdArgsI.Parse(C_Ify(args)); // Verify - Assert::IsTrue(nupp["--void1"].GetDataType() == DATA_TYPE::VOID); - Assert::IsTrue(nupp["--void2"].GetDataType() == DATA_TYPE::VOID); - Assert::IsTrue(nupp["--void3"].GetDataType() == DATA_TYPE::VOID); - Assert::IsTrue(nupp["--void4"].GetDataType() == DATA_TYPE::VOID); - Assert::IsTrue(nupp["--void5"].GetDataType() == DATA_TYPE::VOID); + Assert::IsTrue(cmdArgsI["--void1"].GetDataType() == DATA_TYPE::VOID); + Assert::IsTrue(cmdArgsI["--void2"].GetDataType() == DATA_TYPE::VOID); + Assert::IsTrue(cmdArgsI["--void3"].GetDataType() == DATA_TYPE::VOID); + Assert::IsTrue(cmdArgsI["--void4"].GetDataType() == DATA_TYPE::VOID); + Assert::IsTrue(cmdArgsI["--void5"].GetDataType() == DATA_TYPE::VOID); return; } @@ -294,21 +294,21 @@ namespace TestHazelnupp "--empty-list", }); - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterConstraint( + cmdArgsI.RegisterConstraint( "--empty-list", ParamConstraint::TypeSafety(DATA_TYPE::LIST) ); // Exercise - nupp.Parse(C_Ify(args)); + cmdArgsI.Parse(C_Ify(args)); // Verify - Assert::IsTrue(nupp["--empty-list"].GetDataType() == DATA_TYPE::LIST, L"Wrong datatype"); - Assert::AreEqual(std::size_t(0), nupp["--empty-list"].GetList().size(), L"Wrong size"); + Assert::IsTrue(cmdArgsI["--empty-list"].GetDataType() == DATA_TYPE::LIST, L"Wrong datatype"); + Assert::AreEqual(std::size_t(0), cmdArgsI["--empty-list"].GetList().size(), L"Wrong size"); return; } @@ -323,21 +323,21 @@ namespace TestHazelnupp "--empty-string", }); - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterConstraint( + cmdArgsI.RegisterConstraint( "--empty-string", ParamConstraint::TypeSafety(DATA_TYPE::STRING) ); // Exercise - nupp.Parse(C_Ify(args)); + cmdArgsI.Parse(C_Ify(args)); // Verify - Assert::IsTrue(nupp["--empty-string"].GetDataType() == DATA_TYPE::STRING, L"Wrong datatype"); - Assert::AreEqual(std::size_t(0), nupp["--empty-string"].GetString().length(), L"Wrong size"); + Assert::IsTrue(cmdArgsI["--empty-string"].GetDataType() == DATA_TYPE::STRING, L"Wrong datatype"); + Assert::AreEqual(std::size_t(0), cmdArgsI["--empty-string"].GetString().length(), L"Wrong size"); return; } @@ -354,16 +354,16 @@ namespace TestHazelnupp // Test section: INT Assert::ExpectException([args] { - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterConstraint( + cmdArgsI.RegisterConstraint( "--thisisvoid", ParamConstraint::TypeSafety(DATA_TYPE::INT) ); // Exercise - nupp.Parse(C_Ify(args)); + cmdArgsI.Parse(C_Ify(args)); }, L"Failed with int"); @@ -382,16 +382,16 @@ namespace TestHazelnupp // Test section: FLOAT Assert::ExpectException([args] { - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterConstraint( + cmdArgsI.RegisterConstraint( "--thisisvoid", ParamConstraint::TypeSafety(DATA_TYPE::FLOAT) ); // Exercise - nupp.Parse(C_Ify(args)); + cmdArgsI.Parse(C_Ify(args)); }, L"Failed with float"); @@ -408,30 +408,30 @@ namespace TestHazelnupp "--empty-list", }); - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterConstraint( + cmdArgsI.RegisterConstraint( "--default-val", ParamConstraint::Require({ "32" }, true) ); - nupp.RegisterConstraint( + cmdArgsI.RegisterConstraint( "--not-there", ParamConstraint::Require({}, true) ); // Exercise - nupp.ClearConstraint("--not-there"); + cmdArgsI.ClearConstraint("--not-there"); // Verify - nupp.Parse(C_Ify(args)); + cmdArgsI.Parse(C_Ify(args)); // Also verifies that parse does not throw an exception for --not-there - Assert::IsTrue(nupp.HasParam("--default-val"), L"Default value is missing"); - Assert::AreEqual(32, nupp["--default-val"].GetInt32(), L"Default value has wrong value"); + Assert::IsTrue(cmdArgsI.HasParam("--default-val"), L"Default value is missing"); + Assert::AreEqual(32, cmdArgsI["--default-val"].GetInt32(), L"Default value has wrong value"); return; } @@ -446,19 +446,19 @@ namespace TestHazelnupp "--empty-list", }); - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterConstraint( + cmdArgsI.RegisterConstraint( "--not-there", ParamConstraint::Require({}, true) ); // Exercise - nupp.ClearConstraints(); + cmdArgsI.ClearConstraints(); // Verify - nupp.Parse(C_Ify(args)); + cmdArgsI.Parse(C_Ify(args)); return; } @@ -473,22 +473,22 @@ namespace TestHazelnupp "--empty-list", }); - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); - nupp.RegisterConstraint( + cmdArgsI.RegisterConstraint( "--not-there", ParamConstraint::Require({}, true) ); //Exercise - nupp.RegisterConstraint( + cmdArgsI.RegisterConstraint( "--not-there", ParamConstraint::Require({}, false) ); // Verify - nupp.Parse(C_Ify(args)); + cmdArgsI.Parse(C_Ify(args)); return; } @@ -503,18 +503,18 @@ namespace TestHazelnupp "--empty-list", }); - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); ParamConstraint dftvalConst_expected = ParamConstraint::Require({ "32" }, true); - nupp.RegisterConstraint("--default-val", dftvalConst_expected); - nupp.RegisterConstraint("--not-there", ParamConstraint::Require({}, true)); - nupp.RegisterConstraint("--another-one", ParamConstraint::Require({ "bites" }, true)); + cmdArgsI.RegisterConstraint("--default-val", dftvalConst_expected); + cmdArgsI.RegisterConstraint("--not-there", ParamConstraint::Require({}, true)); + cmdArgsI.RegisterConstraint("--another-one", ParamConstraint::Require({ "bites" }, true)); // Exercise - ParamConstraint dftvalConst = nupp.GetConstraint("--default-val"); + ParamConstraint dftvalConst = cmdArgsI.GetConstraint("--default-val"); // Verify Assert::IsTrue(dftvalConst_expected.required == dftvalConst.required, L"required"); diff --git a/Test_Hazelnupp/Conversion.cpp b/Test_Hazelnupp/Conversion.cpp index 8c92c1d..dab2d58 100644 --- a/Test_Hazelnupp/Conversion.cpp +++ b/Test_Hazelnupp/Conversion.cpp @@ -1,6 +1,6 @@ #include "CppUnitTest.h" #include "helper.h" -#include "../Hazelnupp/Hazelnupp.h" +#include "../Hazelnupp/CmdArgsInterface.h" #include "../Hazelnupp/HazelnuppException.h" using namespace Microsoft::VisualStudio::CppUnitTestFramework; @@ -23,44 +23,44 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp(C_Ify(args)); - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI(C_Ify(args)); + cmdArgsI.SetCrashOnFail(false); // Verify - const Hazelnupp* ptnupp = &nupp; + const CmdArgsInterface* ptcmdArgsI = &cmdArgsI; Assert::ExpectException( - [ptnupp] + [ptcmdArgsI] { - (*ptnupp)["--pud"].GetInt64(); + (*ptcmdArgsI)["--pud"].GetInt64(); } , L"Int64"); Assert::ExpectException( - [ptnupp] + [ptcmdArgsI] { - (*ptnupp)["--pud"].GetInt32(); + (*ptcmdArgsI)["--pud"].GetInt32(); } , L"Int32"); Assert::ExpectException( - [ptnupp] + [ptcmdArgsI] { - (*ptnupp)["--pud"].GetFloat64(); + (*ptcmdArgsI)["--pud"].GetFloat64(); } , L"Float64"); Assert::ExpectException( - [ptnupp] + [ptcmdArgsI] { - (*ptnupp)["--pud"].GetFloat32(); + (*ptcmdArgsI)["--pud"].GetFloat32(); } , L"Float32"); Assert::ExpectException( - [ptnupp] + [ptcmdArgsI] { - (*ptnupp)["--pud"].GetList(); + (*ptcmdArgsI)["--pud"].GetList(); } , L"List"); @@ -78,45 +78,45 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp(C_Ify(args)); - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI(C_Ify(args)); + cmdArgsI.SetCrashOnFail(false); // Verify - const Hazelnupp* ptnupp = &nupp; + const CmdArgsInterface* ptcmdArgsI = &cmdArgsI; Assert::ExpectException( - [ptnupp] + [ptcmdArgsI] { - (*ptnupp)["--pud"].GetInt64(); + (*ptcmdArgsI)["--pud"].GetInt64(); } , L"Int64"); Assert::ExpectException( - [ptnupp] + [ptcmdArgsI] { - (*ptnupp)["--pud"].GetInt32(); + (*ptcmdArgsI)["--pud"].GetInt32(); } , L"Int32"); Assert::ExpectException( - [ptnupp] + [ptcmdArgsI] { - (*ptnupp)["--pud"].GetFloat64(); + (*ptcmdArgsI)["--pud"].GetFloat64(); } , L"Float64"); Assert::ExpectException( - [ptnupp] + [ptcmdArgsI] { - (*ptnupp)["--pud"].GetFloat32(); + (*ptcmdArgsI)["--pud"].GetFloat32(); } , L"Float32"); // Expect empty string - Assert::AreEqual(std::string(), nupp["--pud"].GetString(), L"String"); + Assert::AreEqual(std::string(), cmdArgsI["--pud"].GetString(), L"String"); // Expect empty list - Assert::AreEqual(std::size_t(0), nupp["--pud"].GetList().size(), L"List"); + Assert::AreEqual(std::size_t(0), cmdArgsI["--pud"].GetList().size(), L"List"); return; } @@ -132,22 +132,22 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp(C_Ify(args)); - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI(C_Ify(args)); + cmdArgsI.SetCrashOnFail(false); // Verify - const Hazelnupp* ptnupp = &nupp; + const CmdArgsInterface* ptcmdArgsI = &cmdArgsI; - Assert::AreEqual(39ll, nupp["--pud"].GetInt64(), L"Int64"); - Assert::AreEqual(39, nupp["--pud"].GetInt32(), L"Int32"); - Assert::IsTrue(39.0l == nupp["--pud"].GetFloat64(), L"Float64"); - Assert::AreEqual(39.0, nupp["--pud"].GetFloat32(), L"Float32"); - Assert::AreEqual(std::string("39"), nupp["--pud"].GetString(), L"String"); + Assert::AreEqual(39ll, cmdArgsI["--pud"].GetInt64(), L"Int64"); + Assert::AreEqual(39, cmdArgsI["--pud"].GetInt32(), L"Int32"); + Assert::IsTrue(39.0l == cmdArgsI["--pud"].GetFloat64(), L"Float64"); + Assert::AreEqual(39.0, cmdArgsI["--pud"].GetFloat32(), L"Float32"); + Assert::AreEqual(std::string("39"), cmdArgsI["--pud"].GetString(), L"String"); Assert::ExpectException( - [ptnupp] + [ptcmdArgsI] { - (*ptnupp)["--pud"].GetList(); + (*ptcmdArgsI)["--pud"].GetList(); } , L"List"); @@ -166,22 +166,22 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp(C_Ify(args)); - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI(C_Ify(args)); + cmdArgsI.SetCrashOnFail(false); // Verify - const Hazelnupp* ptnupp = &nupp; + const CmdArgsInterface* ptcmdArgsI = &cmdArgsI; - Assert::AreEqual(39ll, nupp["--pud"].GetInt64(), L"Int64"); - Assert::AreEqual(39, nupp["--pud"].GetInt32(), L"Int32"); - Assert::IsTrue(39.5l == nupp["--pud"].GetFloat64(), L"Float64"); - Assert::AreEqual(39.5, nupp["--pud"].GetFloat32(), L"Float32"); - Assert::AreEqual(std::string("39.5"), nupp["--pud"].GetString(), L"String"); + Assert::AreEqual(39ll, cmdArgsI["--pud"].GetInt64(), L"Int64"); + Assert::AreEqual(39, cmdArgsI["--pud"].GetInt32(), L"Int32"); + Assert::IsTrue(39.5l == cmdArgsI["--pud"].GetFloat64(), L"Float64"); + Assert::AreEqual(39.5, cmdArgsI["--pud"].GetFloat32(), L"Float32"); + Assert::AreEqual(std::string("39.5"), cmdArgsI["--pud"].GetString(), L"String"); Assert::ExpectException( - [ptnupp] + [ptcmdArgsI] { - (*ptnupp)["--pud"].GetList(); + (*ptcmdArgsI)["--pud"].GetList(); } , L"List"); @@ -203,44 +203,44 @@ namespace TestHazelnupp }); // Exercise - Hazelnupp nupp(C_Ify(args)); - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI(C_Ify(args)); + cmdArgsI.SetCrashOnFail(false); // Verify - const Hazelnupp* ptnupp = &nupp; + const CmdArgsInterface* ptcmdArgsI = &cmdArgsI; Assert::ExpectException( - [ptnupp] + [ptcmdArgsI] { - (*ptnupp)["--pud"].GetInt64(); + (*ptcmdArgsI)["--pud"].GetInt64(); } , L"Int64"); Assert::ExpectException( - [ptnupp] + [ptcmdArgsI] { - (*ptnupp)["--pud"].GetInt32(); + (*ptcmdArgsI)["--pud"].GetInt32(); } , L"Int32"); Assert::ExpectException( - [ptnupp] + [ptcmdArgsI] { - (*ptnupp)["--pud"].GetFloat64(); + (*ptcmdArgsI)["--pud"].GetFloat64(); } , L"Float64"); Assert::ExpectException( - [ptnupp] + [ptcmdArgsI] { - (*ptnupp)["--pud"].GetFloat32(); + (*ptcmdArgsI)["--pud"].GetFloat32(); } , L"Float32"); Assert::ExpectException( - [ptnupp] + [ptcmdArgsI] { - (*ptnupp)["--pud"].GetString(); + (*ptcmdArgsI)["--pud"].GetString(); } , L"String"); diff --git a/Test_Hazelnupp/Descriptions.cpp b/Test_Hazelnupp/Descriptions.cpp index a67f6fe..988ed56 100644 --- a/Test_Hazelnupp/Descriptions.cpp +++ b/Test_Hazelnupp/Descriptions.cpp @@ -1,6 +1,6 @@ #include "CppUnitTest.h" #include "helper.h" -#include "../Hazelnupp/Hazelnupp.h" +#include "../Hazelnupp/CmdArgsInterface.h" #include "../Hazelnupp/HazelnuppException.h" using namespace Microsoft::VisualStudio::CppUnitTestFramework; @@ -16,16 +16,16 @@ namespace TestHazelnupp TEST_METHOD(Set_Get_Application_Brief) { // Setup - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); std::string text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse in quam tincidunt sapien euismod egestas eget vel dolor. Duis non turpis porttitor, convallis velit at."; // Exercise - nupp.SetBriefDescription(text); + cmdArgsI.SetBriefDescription(text); // Verify - Assert::AreEqual(text, nupp.GetBriefDescription()); + Assert::AreEqual(text, cmdArgsI.GetBriefDescription()); return; } @@ -34,18 +34,18 @@ namespace TestHazelnupp TEST_METHOD(Can_Set_Parameter_Description) { // Setup - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); // Exercise - nupp.RegisterDescription("--force", "Just force it"); - nupp.RegisterDescription("--lose", "Just lose it"); - nupp.RegisterDescription("--crazy", "Go crazy"); + cmdArgsI.RegisterDescription("--force", "Just force it"); + cmdArgsI.RegisterDescription("--lose", "Just lose it"); + cmdArgsI.RegisterDescription("--crazy", "Go crazy"); // Verify - Assert::AreEqual(std::string("Just force it"), nupp.GetDescription("--force")); - Assert::AreEqual(std::string("Go crazy"), nupp.GetDescription("--crazy")); - Assert::AreEqual(std::string("Just lose it"), nupp.GetDescription("--lose")); + Assert::AreEqual(std::string("Just force it"), cmdArgsI.GetDescription("--force")); + Assert::AreEqual(std::string("Go crazy"), cmdArgsI.GetDescription("--crazy")); + Assert::AreEqual(std::string("Just lose it"), cmdArgsI.GetDescription("--lose")); return; } @@ -54,17 +54,17 @@ namespace TestHazelnupp TEST_METHOD(Has_Description) { // Setup - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); // Exercise, verify - Assert::IsFalse(nupp.HasDescription("--force")); - Assert::IsFalse(nupp.HasDescription("--main")); + Assert::IsFalse(cmdArgsI.HasDescription("--force")); + Assert::IsFalse(cmdArgsI.HasDescription("--main")); - nupp.RegisterDescription("--force", "Just force it"); + cmdArgsI.RegisterDescription("--force", "Just force it"); - Assert::IsTrue(nupp.HasDescription("--force")); - Assert::IsFalse(nupp.HasDescription("--main")); + Assert::IsTrue(cmdArgsI.HasDescription("--force")); + Assert::IsFalse(cmdArgsI.HasDescription("--main")); return; } @@ -73,16 +73,16 @@ namespace TestHazelnupp TEST_METHOD(No_Description_Is_Empty_String) { // Setup - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); // Exercise - nupp.RegisterDescription("--force", "Just force it"); - nupp.RegisterDescription("--lose", "Just lose it"); - nupp.RegisterDescription("--crazy", "Go crazy"); + cmdArgsI.RegisterDescription("--force", "Just force it"); + cmdArgsI.RegisterDescription("--lose", "Just lose it"); + cmdArgsI.RegisterDescription("--crazy", "Go crazy"); // Verify - Assert::AreEqual(std::string(), nupp.GetDescription("--man")); + Assert::AreEqual(std::string(), cmdArgsI.GetDescription("--man")); return; } @@ -91,23 +91,23 @@ namespace TestHazelnupp TEST_METHOD(ClearDescription) { // Setup - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); // Exercise - nupp.RegisterDescription("--force", "Just force it"); - nupp.RegisterDescription("--lose", "Just lose it"); - nupp.RegisterDescription("--crazy", "Go crazy"); + cmdArgsI.RegisterDescription("--force", "Just force it"); + cmdArgsI.RegisterDescription("--lose", "Just lose it"); + cmdArgsI.RegisterDescription("--crazy", "Go crazy"); - nupp.ClearDescription("--lose"); + cmdArgsI.ClearDescription("--lose"); // Verify // These two should still work - Assert::AreEqual(std::string("Just force it"), nupp.GetDescription("--force")); - Assert::AreEqual(std::string("Go crazy"), nupp.GetDescription("--crazy")); + Assert::AreEqual(std::string("Just force it"), cmdArgsI.GetDescription("--force")); + Assert::AreEqual(std::string("Go crazy"), cmdArgsI.GetDescription("--crazy")); - Assert::IsFalse(nupp.HasDescription("--lose")); + Assert::IsFalse(cmdArgsI.HasDescription("--lose")); return; } @@ -116,22 +116,22 @@ namespace TestHazelnupp TEST_METHOD(ClearDescriptions) { // Setup - Hazelnupp nupp; - nupp.SetCrashOnFail(false); + CmdArgsInterface cmdArgsI; + cmdArgsI.SetCrashOnFail(false); // Exercise - nupp.RegisterDescription("--force", "Just force it"); - nupp.RegisterDescription("--lose", "Just lose it"); - nupp.RegisterDescription("--crazy", "Go crazy"); + cmdArgsI.RegisterDescription("--force", "Just force it"); + cmdArgsI.RegisterDescription("--lose", "Just lose it"); + cmdArgsI.RegisterDescription("--crazy", "Go crazy"); - nupp.ClearDescriptions(); + cmdArgsI.ClearDescriptions(); // Verify // These two should still work - Assert::IsFalse(nupp.HasDescription("--force")); - Assert::IsFalse(nupp.HasDescription("--crazy")); - Assert::IsFalse(nupp.HasDescription("--lose")); + Assert::IsFalse(cmdArgsI.HasDescription("--force")); + Assert::IsFalse(cmdArgsI.HasDescription("--crazy")); + Assert::IsFalse(cmdArgsI.HasDescription("--lose")); return; }