TestHazelnupp Namespace Reference

## Functions

| TEST_CLASS (_Abbreviations)
| TEST_CLASS (_Basics)
| TEST_CLASS (_Constraints)
| TEST_CLASS (_Conversion)

## Function Documentation

## TEST_CLASS() [1/4]

TestHazelnupp::TEST_CLASS | ( | _Abbreviations |  | ) |

Definition at line 9 of file Abbreviations.cpp.

{
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;
}
};

## TEST_CLASS() [2/4]

TestHazelnupp::TEST_CLASS | ( | _Basics |  | ) |

Definition at line 10 of file Basics.cpp.

{
public:
// Tests the application path gets exported correctly
TEST_METHOD(ApplicationPathWorks)
{
// 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());
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;
}
// Edgecase test: We begin with an actual value, instead of an argument.
TEST_METHOD(Weird_Case_1)
{
// Setup
ArgList args({
"/my/fake/path/wahoo.out",
"dummy"
});
// Exercise
Hazelnupp nupp(C_Ify(args));
nupp.SetCrashOnFail(false);
// Verify (no exception)
return;
}
// Edgecase test: We begin with first an actual value, and then an argument.
TEST_METHOD(Weird_Case_2)
{
// Setup
ArgList args({
"/my/fake/path/wahoo.out",
"dummy",
"--dummy"
});
// Exercise
Hazelnupp nupp(C_Ify(args));
nupp.SetCrashOnFail(false);
// Verify
Assert::IsTrue(nupp.HasParam("--dummy"), L"Failed has-param");
Assert::IsTrue(nupp["--dummy"].GetDataType() == DATA_TYPE::VOID, L"Failed type");
return;
}
// Tests keys exist after parsing
TEST_METHOD(KeysExist)
{
// 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",
});
// Exercise
Hazelnupp nupp(C_Ify(args));
nupp.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"));
return;
}
// Tests keys are of the correct type after parsing
TEST_METHOD(CorrectType)
{
// 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",
});
// Exercise
Hazelnupp nupp(C_Ify(args));
nupp.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);
return;
}
// Tests keys have the correct value after parsing
TEST_METHOD(CorrectValues)
{
// 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",
});
// Exercise
Hazelnupp nupp(C_Ify(args));
nupp.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"));
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<HazelnuppInvalidKeyException>(
[args]
{
Hazelnupp nupp(C_Ify(args));
nupp["--borrnana"];
}
);
return;
}
};

## TEST_CLASS() [3/4]

TestHazelnupp::TEST_CLASS | ( | _Constraints |  | ) |

Definition at line 10 of file Constraints.cpp.

{
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::Require("--elenor-int", {"5994"}),
ParamConstraint::Require("--federich-float", {"420.69"}),
ParamConstraint::Require("--siegbert-string", {"banana"}),
ParamConstraint::Require("--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::Require("--elenor-int", {"6871"}),
ParamConstraint::Require("--federich-float", {"-199.44"}),
ParamConstraint::Require("--siegbert-string", {"bornana"}),
ParamConstraint::Require("--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::TypeSafety("--num-apples", DATA_TYPE::INT),
ParamConstraint::TypeSafety("--table-height", DATA_TYPE::FLOAT),
ParamConstraint::TypeSafety("--license-plate", DATA_TYPE::STRING),
ParamConstraint::TypeSafety("--fav-fruits", DATA_TYPE::LIST),
ParamConstraint::TypeSafety("--indices", DATA_TYPE::LIST),
ParamConstraint::TypeSafety("--force", 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<HazelnuppConstraintMissingValue>(
[args]
{
Hazelnupp nupp;
nupp.SetCrashOnFail(false);
nupp.RegisterConstraints({
ParamConstraint::Require("--elenor-int"),
});
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<HazelnuppConstraintTypeMissmatch>(
[args]
{
Hazelnupp nupp;
nupp.SetCrashOnFail(false);
nupp.RegisterConstraints({
ParamConstraint::TypeSafety("--elenor-int", DATA_TYPE::INT),
});
nupp.Parse(C_Ify(args));
}
);
return;
}
// Tests that everything can be converted to void
TEST_METHOD(Weird_Load_Conversions_ToVoid)
{
// Setup
ArgList args({
"/my/fake/path/wahoo.out",
"--dummy",
"--void1",
"--void2",
"12",
"--void3",
"9.5",
"--void4",
"hello",
"--void5",
"foo",
"baz"
});
Hazelnupp nupp;
nupp.SetCrashOnFail(false);
nupp.RegisterConstraints({
ParamConstraint::TypeSafety("--void1", DATA_TYPE::VOID),
ParamConstraint::TypeSafety("--void2", DATA_TYPE::VOID),
ParamConstraint::TypeSafety("--void3", DATA_TYPE::VOID),
ParamConstraint::TypeSafety("--void4", DATA_TYPE::VOID),
ParamConstraint::TypeSafety("--void5", DATA_TYPE::VOID)
});
// Exercise
nupp.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);
return;
}
// Tests that everything a void can be converted to an empty list
TEST_METHOD(Weird_Load_Conversions_VoidToEmptyList)
{
// Setup
ArgList args({
"/my/fake/path/wahoo.out",
"--dummy",
"--empty-list",
});
Hazelnupp nupp;
nupp.SetCrashOnFail(false);
nupp.RegisterConstraints({
ParamConstraint::TypeSafety("--empty-list", DATA_TYPE::LIST),
});
// Exercise
nupp.Parse(C_Ify(args));
// Verify
Assert::IsTrue(nupp["--empty-list"].GetDataType() == DATA_TYPE::LIST);
Assert::AreEqual(std::size_t(0), nupp["--empty-list"].GetList().size());
return;
}
};

## TEST_CLASS() [4/4]

TestHazelnupp::TEST_CLASS | ( | _Conversion |  | ) |

Definition at line 10 of file Conversion.cpp.

{
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<HazelnuppValueNotConvertibleException>(
[ptnupp]
{
(*ptnupp)["--pud"].GetInt64();
}
, L"Int64");
Assert::ExpectException<HazelnuppValueNotConvertibleException>(
[ptnupp]
{
(*ptnupp)["--pud"].GetInt32();
}
, L"Int32");
Assert::ExpectException<HazelnuppValueNotConvertibleException>(
[ptnupp]
{
(*ptnupp)["--pud"].GetFloat64();
}
, L"Float64");
Assert::ExpectException<HazelnuppValueNotConvertibleException>(
[ptnupp]
{
(*ptnupp)["--pud"].GetFloat32();
}
, L"Float32");
Assert::ExpectException<HazelnuppValueNotConvertibleException>(
[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<HazelnuppValueNotConvertibleException>(
[ptnupp]
{
(*ptnupp)["--pud"].GetInt64();
}
, L"Int64");
Assert::ExpectException<HazelnuppValueNotConvertibleException>(
[ptnupp]
{
(*ptnupp)["--pud"].GetInt32();
}
, L"Int32");
Assert::ExpectException<HazelnuppValueNotConvertibleException>(
[ptnupp]
{
(*ptnupp)["--pud"].GetFloat64();
}
, L"Float64");
Assert::ExpectException<HazelnuppValueNotConvertibleException>(
[ptnupp]
{
(*ptnupp)["--pud"].GetFloat32();
}
, L"Float32");
Assert::ExpectException<HazelnuppValueNotConvertibleException>(
[ptnupp]
{
(*ptnupp)["--pud"].GetString();
}
, L"String");
Assert::ExpectException<HazelnuppValueNotConvertibleException>(
[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<HazelnuppValueNotConvertibleException>(
[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<HazelnuppValueNotConvertibleException>(
[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<HazelnuppValueNotConvertibleException>(
[ptnupp]
{
(*ptnupp)["--pud"].GetInt64();
}
, L"Int64");
Assert::ExpectException<HazelnuppValueNotConvertibleException>(
[ptnupp]
{
(*ptnupp)["--pud"].GetInt32();
}
, L"Int32");
Assert::ExpectException<HazelnuppValueNotConvertibleException>(
[ptnupp]
{
(*ptnupp)["--pud"].GetFloat64();
}
, L"Float64");
Assert::ExpectException<HazelnuppValueNotConvertibleException>(
[ptnupp]
{
(*ptnupp)["--pud"].GetFloat32();
}
, L"Float32");
Assert::ExpectException<HazelnuppValueNotConvertibleException>(
[ptnupp]
{
(*ptnupp)["--pud"].GetString();
}
, L"String");
return;
}
};
DATA_TYPE::VOID
@ VOID
Hazelnupp::RegisterConstraints
void RegisterConstraints(const std::vector< ParamConstraint > &constraints)
Will register parameter constraints.
Definition: Hazelnupp.cpp:352
DATA_TYPE::LIST
@ LIST
DATA_TYPE::FLOAT
@ FLOAT
ParamConstraint::TypeSafety
static ParamConstraint TypeSafety(const std::string &key, DATA_TYPE wantedType, bool constrainType=true)
Constructs a type-safety constraint.
Definition: ParamConstraint.h:25
DATA_TYPE::INT
@ INT
ParamConstraint::Require
static ParamConstraint Require(const std::string &key, const std::vector< std::string > &defaultValue={}, bool required=true)
Constructs a require constraint.
Definition: ParamConstraint.h:14
C_Ify
#define C_Ify(vector)
Definition: helper.h:4
Hazelnupp::SetCrashOnFail
void SetCrashOnFail(bool crashOnFail)
Sets whether to crash the application, and print to stderr, when an exception is raised whilst parsin...
Definition: Hazelnupp.cpp:379
ArgList
std::vector< const char * > ArgList
Definition: helper.h:6
DATA_TYPE::STRING
@ STRING
Hazelnupp
The main class to interface with.
Definition: Hazelnupp.h:9
Hazelnupp::Parse
void Parse(const int argc, const char *const *argv)
Will parse command line arguments.
Definition: Hazelnupp.cpp:33