From 1cd9abd11d8bf395f5a405a4a8304243e21a6eac Mon Sep 17 00:00:00 2001 From: Leonetienne Date: Wed, 2 Jun 2021 22:48:54 +0200 Subject: [PATCH] Added unit tests --- Test_Hazelnupp/Abbreviations.cpp | 161 +++++++++++ .../{Test_Hazelnupp.cpp => Basics.cpp} | 77 +++++- Test_Hazelnupp/Constraints.cpp | 1 + Test_Hazelnupp/Constraints.h | 248 +++++++++++++++++ Test_Hazelnupp/Conversion.cpp | 258 ++++++++++++++++++ Test_Hazelnupp/Test_Hazelnupp.vcxproj | 6 +- Test_Hazelnupp/Test_Hazelnupp.vcxproj.filters | 22 +- 7 files changed, 760 insertions(+), 13 deletions(-) create mode 100644 Test_Hazelnupp/Abbreviations.cpp rename Test_Hazelnupp/{Test_Hazelnupp.cpp => Basics.cpp} (68%) create mode 100644 Test_Hazelnupp/Constraints.cpp create mode 100644 Test_Hazelnupp/Constraints.h create mode 100644 Test_Hazelnupp/Conversion.cpp diff --git a/Test_Hazelnupp/Abbreviations.cpp b/Test_Hazelnupp/Abbreviations.cpp new file mode 100644 index 0000000..94b94db --- /dev/null +++ b/Test_Hazelnupp/Abbreviations.cpp @@ -0,0 +1,161 @@ +#include "CppUnitTest.h" +#include "helper.h" +#include "../Hazelnupp/Hazelnupp.h" + +using namespace Microsoft::VisualStudio::CppUnitTestFramework; + +namespace TestHazelnupp +{ + TEST_CLASS(_Abbreviations) + { + public: + + // Tests keys exist after parsing + TEST_METHOD(KeysExist) + { + // Setup + ArgList args({ + "/my/fake/path/wahoo.out", + "-ms", + "billybob", + "-mv", + "-mf", + "-23.199", + "-mi", + "199", + "-mnl", + "1", + "2", + "3", + "4", + "-msl", + "apple", + "banana", + "pumpkin", + }); + + // Exercise + Hazelnupp nupp; + nupp.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"); + + nupp.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")); + + return; + } + + // Tests keys are of the correct type after parsing + TEST_METHOD(CorrectType) + { + // Setup + ArgList args({ + "/my/fake/path/wahoo.out", + "-ms", + "billybob", + "-mv", + "-mf", + "-23.199", + "-mi", + "199", + "-mnl", + "1", + "2", + "3", + "4", + "-msl", + "apple", + "banana", + "pumpkin", + }); + + // Exercise + Hazelnupp nupp; + nupp.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"); + + nupp.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); + + return; + } + + // Tests keys have the correct value after parsing + TEST_METHOD(CorrectValues) + { + // Setup + ArgList args({ + "/my/fake/path/wahoo.out", + "-ms", + "billybob", + "-mv", + "-mf", + "-23.199", + "-mi", + "199", + "-mnl", + "1", + "2", + "3", + "4", + "-msl", + "apple", + "banana", + "pumpkin", + }); + + // Exercise + Hazelnupp nupp; + nupp.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"); + + nupp.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")); + + return; + } + }; +} diff --git a/Test_Hazelnupp/Test_Hazelnupp.cpp b/Test_Hazelnupp/Basics.cpp similarity index 68% rename from Test_Hazelnupp/Test_Hazelnupp.cpp rename to Test_Hazelnupp/Basics.cpp index 7d88034..419f0e3 100644 --- a/Test_Hazelnupp/Test_Hazelnupp.cpp +++ b/Test_Hazelnupp/Basics.cpp @@ -1,6 +1,7 @@ #include "CppUnitTest.h" #include "helper.h" #include "../Hazelnupp/Hazelnupp.h" +#include "../Hazelnupp/HazelnuppException.h" using namespace Microsoft::VisualStudio::CppUnitTestFramework; @@ -16,10 +17,11 @@ namespace TestHazelnupp // Setup ArgList args({ "/my/fake/path/wahoo.out" - }); + }); // Exercise Hazelnupp nupp(C_Ify(args)); + nupp.SetCrashOnFail(false); // Verify Assert::AreEqual(std::string("/my/fake/path/wahoo.out"), nupp.GetExecutableName()); @@ -27,8 +29,27 @@ namespace TestHazelnupp return; } + // Edgecase test: We only have one param. + TEST_METHOD(Only_One_Param) + { + // Setup + ArgList args({ + "/my/fake/path/wahoo.out", + "--dummy" + }); + + // Exercise + Hazelnupp nupp(C_Ify(args)); + nupp.SetCrashOnFail(false); + + // Verify + Assert::IsTrue(nupp.HasParam("--dummy")); + + return; + } + // Tests keys exist after parsing - TEST_METHOD(BasicParsing_KeysExist) + TEST_METHOD(KeysExist) { // Setup ArgList args({ @@ -49,10 +70,11 @@ namespace TestHazelnupp "apple", "banana", "pumpkin", - }); + }); // Exercise Hazelnupp nupp(C_Ify(args)); + nupp.SetCrashOnFail(false); // Verify Assert::IsTrue(nupp.HasParam("--my_string")); @@ -66,7 +88,7 @@ namespace TestHazelnupp } // Tests keys are of the correct type after parsing - TEST_METHOD(BasicParsing_CorrectType) + TEST_METHOD(CorrectType) { // Setup ArgList args({ @@ -87,10 +109,11 @@ namespace TestHazelnupp "apple", "banana", "pumpkin", - }); + }); // Exercise Hazelnupp nupp(C_Ify(args)); + nupp.SetCrashOnFail(false); // Verify Assert::IsTrue(nupp["--my_string"].GetDataType() == DATA_TYPE::STRING); @@ -104,7 +127,7 @@ namespace TestHazelnupp } // Tests keys have the correct value after parsing - TEST_METHOD(BasicParsing_CorrectValues) + TEST_METHOD(CorrectValues) { // Setup ArgList args({ @@ -125,10 +148,11 @@ namespace TestHazelnupp "apple", "banana", "pumpkin", - }); + }); // Exercise Hazelnupp nupp(C_Ify(args)); + nupp.SetCrashOnFail(false); // Verify Assert::AreEqual(nupp["--my_string"].GetString(), std::string("billybob")); @@ -144,5 +168,44 @@ namespace TestHazelnupp return; } + + // Tests that an HazelnuppInvalidKeyException gets raised, if an invalid gey is tried to access + TEST_METHOD(Exception_On_Invalid_Key) + { + // Setup + ArgList args({ + "/my/fake/path/wahoo.out", + "--my_string", + "billybob", + "--my_void", + "--my_float", + "-23.199", + "--my_int", + "199", + "--my_num_list", + "1", + "2", + "3", + "4", + "--my_str_list", + "apple", + "banana", + "pumpkin", + }); + + Hazelnupp nupp(C_Ify(args)); + nupp.SetCrashOnFail(false); + + // Exercise, Verify + Assert::ExpectException( + [args] + { + Hazelnupp nupp(C_Ify(args)); + nupp["--borrnana"]; + } + ); + + return; + } }; } diff --git a/Test_Hazelnupp/Constraints.cpp b/Test_Hazelnupp/Constraints.cpp new file mode 100644 index 0000000..6711703 --- /dev/null +++ b/Test_Hazelnupp/Constraints.cpp @@ -0,0 +1 @@ +#include "Constraints.h" diff --git a/Test_Hazelnupp/Constraints.h b/Test_Hazelnupp/Constraints.h new file mode 100644 index 0000000..f47678a --- /dev/null +++ b/Test_Hazelnupp/Constraints.h @@ -0,0 +1,248 @@ +#include "CppUnitTest.h" +#include "helper.h" +#include "../Hazelnupp/Hazelnupp.h" +#include "../Hazelnupp/HazelnuppException.h" + +using namespace Microsoft::VisualStudio::CppUnitTestFramework; + +namespace TestHazelnupp +{ + TEST_CLASS(_Constraints) + { + public: + + // Tests that default values get added + TEST_METHOD(DefaultValues_GetAdded) + { + // Setup + ArgList args({ + "/my/fake/path/wahoo.out", + "--dummy", + "123" + }); + + // Exercise + Hazelnupp nupp; + nupp.SetCrashOnFail(false); + + nupp.RegisterConstraints({ + ParamConstraint("--elenor-int", {"5994"}), + ParamConstraint("--federich-float", {"420.69"}), + ParamConstraint("--siegbert-string", {"banana"}), + ParamConstraint("--lieber-liste", {"banana", "apple", "59"}) + }); + + nupp.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(nupp.HasParam("--federich-float")); + Assert::IsTrue(nupp["--federich-float"].GetDataType() == DATA_TYPE::FLOAT); + Assert::AreEqual(nupp["--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(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); + + return; + } + + // Tests that the default values do not override actually set values + TEST_METHOD(DefaultValues_DefaultDoesntOverride) + { + // Setup + ArgList args({ + "/my/fake/path/wahoo.out", + "--dummy", + "--elenor-int", + "5994", + "--federich-float", + "420.69", + "--siegbert-string", + "banana", + "--lieber-liste", + "banana", + "apple", + "59" + }); + + // Exercise + Hazelnupp nupp; + nupp.SetCrashOnFail(false); + + nupp.RegisterConstraints({ + ParamConstraint("--elenor-int", {"6871"}), + ParamConstraint("--federich-float", {"-199.44"}), + ParamConstraint("--siegbert-string", {"bornana"}), + ParamConstraint("--lieber-liste", {"bornana", "ollpe", "5"}) + }); + + nupp.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(nupp.HasParam("--federich-float")); + Assert::IsTrue(nupp["--federich-float"].GetDataType() == DATA_TYPE::FLOAT); + Assert::AreEqual(nupp["--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(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); + + return; + } + + // Tests that data types get forced according to the constraints + TEST_METHOD(ForceTypes) + { + // Setup + ArgList args({ + "/my/fake/path/wahoo.out", + "--dummy", + "--num-apples", + "39.75", + "--table-height", + "400", + "--license-plate", + "193273", + "--fav-fruits", + "apple", + "--indices", + "9", + "--force", + "plsdontuseme" + }); + + // Exercise + Hazelnupp nupp; + nupp.SetCrashOnFail(false); + + nupp.RegisterConstraints({ + ParamConstraint("--num-apples", true, DATA_TYPE::INT), + ParamConstraint("--table-height", true, DATA_TYPE::FLOAT), + ParamConstraint("--license-plate", true, DATA_TYPE::STRING), + ParamConstraint("--fav-fruits", true, DATA_TYPE::LIST), + ParamConstraint("--indices", true, DATA_TYPE::LIST), + ParamConstraint("--force", true, DATA_TYPE::VOID), + }); + + nupp.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(nupp.HasParam("--table-height")); + Assert::IsTrue(nupp["--table-height"].GetDataType() == DATA_TYPE::FLOAT); + Assert::AreEqual(nupp["--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(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(nupp.HasParam("--indices")); + Assert::IsTrue(nupp["--indices"].GetDataType() == DATA_TYPE::LIST); + Assert::AreEqual(nupp["--indices"].GetList()[0]->GetInt32(), 9); + + Assert::IsTrue(nupp.HasParam("--force")); + Assert::IsTrue(nupp["--force"].GetDataType() == DATA_TYPE::VOID); + + return; + } + + // Tests that an HazelnuppConstraintMissingValue gets raised if a required parameter + // is missing and does not have a default parameter + TEST_METHOD(Exception_MissingImportant_Parameter_WithoutDefault) + { + // Setup + ArgList args({ + "/my/fake/path/wahoo.out", + "--dummy", + "--federich-float", + "420.69", + "--siegbert-string", + "banana", + "--lieber-liste", + "banana", + "apple", + "59" + }); + + Assert::ExpectException( + [args] + { + Hazelnupp nupp; + nupp.SetCrashOnFail(false); + + nupp.RegisterConstraints({ + ParamConstraint("--elenor-int", std::vector(), true), + }); + + nupp.Parse(C_Ify(args)); + } + ); + + return; + } + + // Tests that an HazelnuppConstraintTypeMissmatch gets raised if a required parameter + // is missing of the wrong type and cannot be converted + TEST_METHOD(Exception_TypeMismatch_Parameter_NotConvertable) + { + // Setup + ArgList args({ + "/my/fake/path/wahoo.out", + "--dummy", + "--elenor-int", + "hello" + "--federich-float", + "420.69", + "--siegbert-string", + "banana", + "--lieber-liste", + "banana", + "apple", + "59" + }); + + Assert::ExpectException( + [args] + { + Hazelnupp nupp; + nupp.SetCrashOnFail(false); + + nupp.RegisterConstraints({ + ParamConstraint("--elenor-int", true, DATA_TYPE::INT), + }); + + nupp.Parse(C_Ify(args)); + } + ); + + return; + } + }; +} diff --git a/Test_Hazelnupp/Conversion.cpp b/Test_Hazelnupp/Conversion.cpp new file mode 100644 index 0000000..ae4a195 --- /dev/null +++ b/Test_Hazelnupp/Conversion.cpp @@ -0,0 +1,258 @@ +#include "CppUnitTest.h" +#include "helper.h" +#include "../Hazelnupp/Hazelnupp.h" +#include "../Hazelnupp/HazelnuppException.h" + +using namespace Microsoft::VisualStudio::CppUnitTestFramework; + +namespace TestHazelnupp +{ + TEST_CLASS(_Conversion) + { + public: + + // Tests that string conversion methods work + TEST_METHOD(Convert_String) + { + // Setup + ArgList args({ + "/my/fake/path/wahoo.out", + "--pud", + "hello" + }); + + // Exercise + Hazelnupp nupp(C_Ify(args)); + nupp.SetCrashOnFail(false); + + // Verify + const Hazelnupp* ptnupp = &nupp; + + Assert::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetInt64(); + } + , L"Int64"); + + Assert::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetInt32(); + } + , L"Int32"); + + Assert::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetFloat64(); + } + , L"Float64"); + + Assert::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetFloat32(); + } + , L"Float32"); + + Assert::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetList(); + } + , L"List"); + + + return; + } + + // Tests that void conversion methods work + TEST_METHOD(Convert_Void) + { + // Setup + ArgList args({ + "/my/fake/path/wahoo.out", + "--pud" + }); + + // Exercise + Hazelnupp nupp(C_Ify(args)); + nupp.SetCrashOnFail(false); + + // Verify + const Hazelnupp* ptnupp = &nupp; + + Assert::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetInt64(); + } + , L"Int64"); + + Assert::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetInt32(); + } + , L"Int32"); + + Assert::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetFloat64(); + } + , L"Float64"); + + Assert::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetFloat32(); + } + , L"Float32"); + + Assert::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetString(); + } + , L"String"); + + Assert::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetList(); + } + , L"List"); + + + return; + } + + // Tests that int conversion methods work + TEST_METHOD(Convert_Int) + { + // Setup + ArgList args({ + "/my/fake/path/wahoo.out", + "--pud", + "39" + }); + + // Exercise + Hazelnupp nupp(C_Ify(args)); + nupp.SetCrashOnFail(false); + + // Verify + const Hazelnupp* ptnupp = &nupp; + + 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::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetList(); + } + , L"List"); + + + return; + } + + // Tests that float conversion methods work + TEST_METHOD(Convert_Float) + { + // Setup + ArgList args({ + "/my/fake/path/wahoo.out", + "--pud", + "39.5" + }); + + // Exercise + Hazelnupp nupp(C_Ify(args)); + nupp.SetCrashOnFail(false); + + // Verify + const Hazelnupp* ptnupp = &nupp; + + 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::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetList(); + } + , L"List"); + + + return; + } + + // Tests that list conversion methods work + TEST_METHOD(Convert_List) + { + // Setup + ArgList args({ + "/my/fake/path/wahoo.out", + "--pud", + "apple", + "1", + "2", + "3" + }); + + // Exercise + Hazelnupp nupp(C_Ify(args)); + nupp.SetCrashOnFail(false); + + // Verify + const Hazelnupp* ptnupp = &nupp; + + Assert::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetInt64(); + } + , L"Int64"); + + Assert::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetInt32(); + } + , L"Int32"); + + Assert::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetFloat64(); + } + , L"Float64"); + + Assert::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetFloat32(); + } + , L"Float32"); + + Assert::ExpectException( + [ptnupp] + { + (*ptnupp)["--pud"].GetString(); + } + , L"String"); + + return; + } + }; +} diff --git a/Test_Hazelnupp/Test_Hazelnupp.vcxproj b/Test_Hazelnupp/Test_Hazelnupp.vcxproj index 20b4123..70c5078 100644 --- a/Test_Hazelnupp/Test_Hazelnupp.vcxproj +++ b/Test_Hazelnupp/Test_Hazelnupp.vcxproj @@ -156,7 +156,10 @@ - + + + + @@ -164,6 +167,7 @@ + diff --git a/Test_Hazelnupp/Test_Hazelnupp.vcxproj.filters b/Test_Hazelnupp/Test_Hazelnupp.vcxproj.filters index a79436e..6e58c90 100644 --- a/Test_Hazelnupp/Test_Hazelnupp.vcxproj.filters +++ b/Test_Hazelnupp/Test_Hazelnupp.vcxproj.filters @@ -14,14 +14,26 @@ rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms - - - Quelldateien - - Headerdateien + + Headerdateien + + + + + Quelldateien + + + Quelldateien + + + Quelldateien + + + Quelldateien + \ No newline at end of file