Leonetienne/Hazelnupp
Simple, easy to use, command line parameter interface
Constraints.cpp
Go to the documentation of this file.
1 #include "CppUnitTest.h"
2 #include "helper.h"
3 #include "../Hazelnupp/Hazelnupp.h"
4 #include "../Hazelnupp/HazelnuppException.h"
5 
6 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
7 
8 namespace TestHazelnupp
9 {
10  TEST_CLASS(_Constraints)
11  {
12  public:
13 
14  // Tests that default values get added
15  TEST_METHOD(DefaultValues_GetAdded)
16  {
17  // Setup
18  ArgList args({
19  "/my/fake/path/wahoo.out",
20  "--dummy",
21  "123"
22  });
23 
24  // Exercise
25  Hazelnupp nupp;
26  nupp.SetCrashOnFail(false);
27 
28  nupp.RegisterConstraints({
29  ParamConstraint::Require("--elenor-int", {"5994"}),
30  ParamConstraint::Require("--federich-float", {"420.69"}),
31  ParamConstraint::Require("--siegbert-string", {"banana"}),
32  ParamConstraint::Require("--lieber-liste", {"banana", "apple", "59"})
33  });
34 
35  nupp.Parse(C_Ify(args));
36 
37  // Verify
38  Assert::IsTrue(nupp.HasParam("--elenor-int"));
39  Assert::IsTrue(nupp["--elenor-int"].GetDataType() == DATA_TYPE::INT);
40  Assert::AreEqual(nupp["--elenor-int"].GetInt32(), 5994);
41 
42  Assert::IsTrue(nupp.HasParam("--federich-float"));
43  Assert::IsTrue(nupp["--federich-float"].GetDataType() == DATA_TYPE::FLOAT);
44  Assert::AreEqual(nupp["--federich-float"].GetFloat32(), 420.69);
45 
46  Assert::IsTrue(nupp.HasParam("--siegbert-string"));
47  Assert::IsTrue(nupp["--siegbert-string"].GetDataType() == DATA_TYPE::STRING);
48  Assert::AreEqual(nupp["--siegbert-string"].GetString(), std::string("banana"));
49 
50  Assert::IsTrue(nupp.HasParam("--lieber-liste"));
51  Assert::IsTrue(nupp["--lieber-liste"].GetDataType() == DATA_TYPE::LIST);
52  Assert::AreEqual(nupp["--lieber-liste"].GetList()[0]->GetString(), std::string("banana"));
53  Assert::AreEqual(nupp["--lieber-liste"].GetList()[1]->GetString(), std::string("apple"));
54  Assert::AreEqual(nupp["--lieber-liste"].GetList()[2]->GetInt32(), 59);
55 
56  return;
57  }
58 
59  // Tests that the default values do not override actually set values
60  TEST_METHOD(DefaultValues_DefaultDoesntOverride)
61  {
62  // Setup
63  ArgList args({
64  "/my/fake/path/wahoo.out",
65  "--dummy",
66  "--elenor-int",
67  "5994",
68  "--federich-float",
69  "420.69",
70  "--siegbert-string",
71  "banana",
72  "--lieber-liste",
73  "banana",
74  "apple",
75  "59"
76  });
77 
78  // Exercise
79  Hazelnupp nupp;
80  nupp.SetCrashOnFail(false);
81 
82  nupp.RegisterConstraints({
83  ParamConstraint::Require("--elenor-int", {"6871"}),
84  ParamConstraint::Require("--federich-float", {"-199.44"}),
85  ParamConstraint::Require("--siegbert-string", {"bornana"}),
86  ParamConstraint::Require("--lieber-liste", {"bornana", "ollpe", "5"})
87  });
88 
89  nupp.Parse(C_Ify(args));
90 
91  // Verify
92  Assert::IsTrue(nupp.HasParam("--elenor-int"));
93  Assert::IsTrue(nupp["--elenor-int"].GetDataType() == DATA_TYPE::INT);
94  Assert::AreEqual(nupp["--elenor-int"].GetInt32(), 5994);
95 
96  Assert::IsTrue(nupp.HasParam("--federich-float"));
97  Assert::IsTrue(nupp["--federich-float"].GetDataType() == DATA_TYPE::FLOAT);
98  Assert::AreEqual(nupp["--federich-float"].GetFloat32(), 420.69);
99 
100  Assert::IsTrue(nupp.HasParam("--siegbert-string"));
101  Assert::IsTrue(nupp["--siegbert-string"].GetDataType() == DATA_TYPE::STRING);
102  Assert::AreEqual(nupp["--siegbert-string"].GetString(), std::string("banana"));
103 
104  Assert::IsTrue(nupp.HasParam("--lieber-liste"));
105  Assert::IsTrue(nupp["--lieber-liste"].GetDataType() == DATA_TYPE::LIST);
106  Assert::AreEqual(nupp["--lieber-liste"].GetList()[0]->GetString(), std::string("banana"));
107  Assert::AreEqual(nupp["--lieber-liste"].GetList()[1]->GetString(), std::string("apple"));
108  Assert::AreEqual(nupp["--lieber-liste"].GetList()[2]->GetInt32(), 59);
109 
110  return;
111  }
112 
113  // Tests that data types get forced according to the constraints
114  TEST_METHOD(ForceTypes)
115  {
116  // Setup
117  ArgList args({
118  "/my/fake/path/wahoo.out",
119  "--dummy",
120  "--num-apples",
121  "39.75",
122  "--table-height",
123  "400",
124  "--license-plate",
125  "193273",
126  "--fav-fruits",
127  "apple",
128  "--indices",
129  "9",
130  "--force",
131  "plsdontuseme"
132  });
133 
134  // Exercise
135  Hazelnupp nupp;
136  nupp.SetCrashOnFail(false);
137 
138  nupp.RegisterConstraints({
139  ParamConstraint::TypeSafety("--num-apples", DATA_TYPE::INT),
140  ParamConstraint::TypeSafety("--table-height", DATA_TYPE::FLOAT),
141  ParamConstraint::TypeSafety("--license-plate", DATA_TYPE::STRING),
142  ParamConstraint::TypeSafety("--fav-fruits", DATA_TYPE::LIST),
143  ParamConstraint::TypeSafety("--indices", DATA_TYPE::LIST),
144  ParamConstraint::TypeSafety("--force", DATA_TYPE::VOID),
145  });
146 
147  nupp.Parse(C_Ify(args));
148 
149  // Verify
150  Assert::IsTrue(nupp.HasParam("--num-apples"));
151  Assert::IsTrue(nupp["--num-apples"].GetDataType() == DATA_TYPE::INT);
152  Assert::AreEqual(nupp["--num-apples"].GetInt32(), 39);
153 
154  Assert::IsTrue(nupp.HasParam("--table-height"));
155  Assert::IsTrue(nupp["--table-height"].GetDataType() == DATA_TYPE::FLOAT);
156  Assert::AreEqual(nupp["--table-height"].GetFloat32(), 400.0);
157 
158  Assert::IsTrue(nupp.HasParam("--license-plate"));
159  Assert::IsTrue(nupp["--license-plate"].GetDataType() == DATA_TYPE::STRING);
160  Assert::AreEqual(nupp["--license-plate"].GetString(), std::string("193273"));
161 
162  Assert::IsTrue(nupp.HasParam("--fav-fruits"));
163  Assert::IsTrue(nupp["--fav-fruits"].GetDataType() == DATA_TYPE::LIST);
164  Assert::AreEqual(nupp["--fav-fruits"].GetList()[0]->GetString(), std::string("apple"));
165 
166  Assert::IsTrue(nupp.HasParam("--indices"));
167  Assert::IsTrue(nupp["--indices"].GetDataType() == DATA_TYPE::LIST);
168  Assert::AreEqual(nupp["--indices"].GetList()[0]->GetInt32(), 9);
169 
170  Assert::IsTrue(nupp.HasParam("--force"));
171  Assert::IsTrue(nupp["--force"].GetDataType() == DATA_TYPE::VOID);
172 
173  return;
174  }
175 
176  // Tests that an HazelnuppConstraintMissingValue gets raised if a required parameter
177  // is missing and does not have a default parameter
178  TEST_METHOD(Exception_MissingImportant_Parameter_WithoutDefault)
179  {
180  // Setup
181  ArgList args({
182  "/my/fake/path/wahoo.out",
183  "--dummy",
184  "--federich-float",
185  "420.69",
186  "--siegbert-string",
187  "banana",
188  "--lieber-liste",
189  "banana",
190  "apple",
191  "59"
192  });
193 
194  Assert::ExpectException<HazelnuppConstraintMissingValue>(
195  [args]
196  {
197  Hazelnupp nupp;
198  nupp.SetCrashOnFail(false);
199 
200  nupp.RegisterConstraints({
201  ParamConstraint::Require("--elenor-int"),
202  });
203 
204  nupp.Parse(C_Ify(args));
205  }
206  );
207 
208  return;
209  }
210 
211  // Tests that an HazelnuppConstraintTypeMissmatch gets raised if a required parameter
212  // is missing of the wrong type and cannot be converted
213  TEST_METHOD(Exception_TypeMismatch_Parameter_NotConvertable)
214  {
215  // Setup
216  ArgList args({
217  "/my/fake/path/wahoo.out",
218  "--dummy",
219  "--elenor-int",
220  "hello"
221  "--federich-float",
222  "420.69",
223  "--siegbert-string",
224  "banana",
225  "--lieber-liste",
226  "banana",
227  "apple",
228  "59"
229  });
230 
231  Assert::ExpectException<HazelnuppConstraintTypeMissmatch>(
232  [args]
233  {
234  Hazelnupp nupp;
235  nupp.SetCrashOnFail(false);
236 
237  nupp.RegisterConstraints({
238  ParamConstraint::TypeSafety("--elenor-int", DATA_TYPE::INT),
239  });
240 
241  nupp.Parse(C_Ify(args));
242  }
243  );
244 
245  return;
246  }
247 
248  // Tests that everything can be converted to void
249  TEST_METHOD(Weird_Load_Conversions_ToVoid)
250  {
251  // Setup
252  ArgList args({
253  "/my/fake/path/wahoo.out",
254  "--dummy",
255  "--void1",
256  "--void2",
257  "12",
258  "--void3",
259  "9.5",
260  "--void4",
261  "hello",
262  "--void5",
263  "foo",
264  "baz"
265  });
266 
267  Hazelnupp nupp;
268  nupp.SetCrashOnFail(false);
269 
270  nupp.RegisterConstraints({
271  ParamConstraint::TypeSafety("--void1", DATA_TYPE::VOID),
272  ParamConstraint::TypeSafety("--void2", DATA_TYPE::VOID),
273  ParamConstraint::TypeSafety("--void3", DATA_TYPE::VOID),
274  ParamConstraint::TypeSafety("--void4", DATA_TYPE::VOID),
275  ParamConstraint::TypeSafety("--void5", DATA_TYPE::VOID)
276  });
277 
278 
279  // Exercise
280  nupp.Parse(C_Ify(args));
281 
282  // Verify
283  Assert::IsTrue(nupp["--void1"].GetDataType() == DATA_TYPE::VOID);
284  Assert::IsTrue(nupp["--void2"].GetDataType() == DATA_TYPE::VOID);
285  Assert::IsTrue(nupp["--void3"].GetDataType() == DATA_TYPE::VOID);
286  Assert::IsTrue(nupp["--void4"].GetDataType() == DATA_TYPE::VOID);
287  Assert::IsTrue(nupp["--void5"].GetDataType() == DATA_TYPE::VOID);
288 
289  return;
290  }
291 
292  // Tests that everything a void can be converted to an empty list
293  TEST_METHOD(Weird_Load_Conversions_VoidToEmptyList)
294  {
295  // Setup
296  ArgList args({
297  "/my/fake/path/wahoo.out",
298  "--dummy",
299  "--empty-list",
300  });
301 
302  Hazelnupp nupp;
303  nupp.SetCrashOnFail(false);
304 
305  nupp.RegisterConstraints({
306  ParamConstraint::TypeSafety("--empty-list", DATA_TYPE::LIST),
307  });
308 
309 
310  // Exercise
311  nupp.Parse(C_Ify(args));
312 
313  // Verify
314  Assert::IsTrue(nupp["--empty-list"].GetDataType() == DATA_TYPE::LIST);
315  Assert::AreEqual(std::size_t(0), nupp["--empty-list"].GetList().size());
316 
317  return;
318  }
319  };
320 }
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
TestHazelnupp
Definition: Abbreviations.cpp:7
ParamConstraint::TypeSafety
static ParamConstraint TypeSafety(const std::string &key, DATA_TYPE wantedType, bool constrainType=true)
Constructs a type-safety constraint.
Definition: ParamConstraint.h:25
TestHazelnupp::TEST_CLASS
TEST_CLASS(_Constraints)
Definition: Constraints.cpp:10
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
helper.h
Hazelnupp::Parse
void Parse(const int argc, const char *const *argv)
Will parse command line arguments.
Definition: Hazelnupp.cpp:33
Generated on Thu Jun 3 2021 12:11:52 for Leonetienne/Hazelnupp by   doxygen 1.8.17