1 /*
2 * Copyright (C) 1998-2018 ALPS Collaboration. See COPYRIGHT.TXT
3 * All rights reserved. Use is subject to license terms. See LICENSE.TXT
4 * For use in publications, see ACKNOWLEDGE.TXT
5 */
6
7 /** @file params.cpp
8
9 @brief Tests the behaviour of parameters
10 */
11
12 #include "./params_test_support.hpp"
13
14 #include <alps/params/iniparser_interface.hpp>
15
16 #include <boost/foreach.hpp>
17
18 namespace ap=alps::params_ns;
19 using ap::dictionary;
20 using ap::params;
21 namespace de=ap::exception;
22 namespace atst=alps::testing;
23
24 namespace test_data {
25 static const char inifile_content[]=
26 // "[HEAD]\n"
27 "simple_string=simple!\n"
28 "quoted_string=\"quoted\"\n"
29 "spaced_string=\"string with spaces\"\n"
30 "an_int=1234\n"
31 "spaced_int=\"123 456\"\n"
32 "quoted_int=\"123456\"\n"
33 "# it's a comment\n"
34 "duplicate=duplicate1\n"
35 "duplicate=duplicate2\n"
36 "empty_quoted_string=\"\"\n"
37 "empty_string=\n"
38 "empty_string_trailing_space= \n"
39 "MiXed_CaSe=MiXeD\n"
40 "[section1]\n"
41 "# it's another comment\n"
42 "simple_string=simple1!\n"
43 "quoted_string=\"quoted1\"\n"
44 "[empty]\n"
45 "[section2]\n"
46 "simple_string=simple2!\n"
47 ;
48 }
49
50
51 // FIXME: This class tests implementation details,
52 // will likely be removed at some point
53 class IniparserTest : public ::testing::Test {
54 protected:
55 ParamsAndFile params_and_file_;
56 ap::detail::iniparser parser_;
57 public:
IniparserTest()58 IniparserTest() : params_and_file_(::test_data::inifile_content),
59 parser_(params_and_file_.fname())
60 { }
61 };
62
TEST_F(IniparserTest,printAll)63 TEST_F(IniparserTest, printAll) {
64 ap::detail::iniparser::kv_container_type kvs;
65 kvs=parser_();
66 BOOST_FOREACH(const ap::detail::iniparser::kv_pair& kv, kvs) {
67 std::cout << "Key='" << kv.first << "' value='" << kv.second << "'\n";
68 }
69 }
70
71 class ParamsTest0 : public testing::Test {
72 protected:
73 ParamsAndFile params_and_file_;
74 params& par_;
75 const params& cpar_;
76 public:
ParamsTest0()77 ParamsTest0() : params_and_file_(::test_data::inifile_content),
78 par_(*params_and_file_.get_params_ptr()),
79 cpar_(par_)
80 { }
81
82 };
83
TEST_F(ParamsTest0,ctor)84 TEST_F(ParamsTest0, ctor) {
85 EXPECT_FALSE(cpar_.exists("simple_string"));
86 }
87
TEST_F(ParamsTest0,copyCtor)88 TEST_F(ParamsTest0, copyCtor) {
89 params par2=cpar_;
90 EXPECT_EQ(cpar_, par2);
91 }
92
TEST_F(ParamsTest0,assignParams)93 TEST_F(ParamsTest0, assignParams) {
94 arg_holder args;
95 args.add("one=1").add("two=2");
96 params par2(args.argc(), args.argv());
97 par2.define<int>("one", "One arg");
98 par2["some_string"]="some string value";
99
100 par2=cpar_;
101 EXPECT_EQ(cpar_, par2);
102 }
103
TEST_F(ParamsTest0,swapParams)104 TEST_F(ParamsTest0, swapParams) {
105 arg_holder args;
106 args.add("one=1").add("two=2");
107 params par2(args.argc(), args.argv());
108 par2.define<int>("one", "One arg");
109 par2["some_string"]="some string value";
110
111 params par2_copy=par2;
112 params par1_copy=cpar_;
113
114 using std::swap;
115 swap(par_, par2);
116
117 EXPECT_EQ(cpar_, par2_copy);
118 EXPECT_EQ(par2, par1_copy);
119 }
120
121
122
TEST_F(ParamsTest0,quotesAndSpaces)123 TEST_F(ParamsTest0, quotesAndSpaces) {
124 const std::string expected="string with spaces";
125 par_.define<std::string>("spaced_string", "Quoted string with spaces");
126 const std::string actual=cpar_["spaced_string"];
127 EXPECT_EQ(expected, actual);
128 }
129
TEST_F(ParamsTest0,numbersWithSpaces)130 TEST_F(ParamsTest0, numbersWithSpaces) {
131 EXPECT_FALSE(par_.define<int>("spaced_int", "Quoted int with spaces").ok());
132 }
133
TEST_F(ParamsTest0,numbersWithQuotes)134 TEST_F(ParamsTest0, numbersWithQuotes) {
135 EXPECT_TRUE(par_.define<int>("quoted_int", "Quoted int without spaces").ok());
136 const int actual=cpar_["quoted_int"];
137 EXPECT_EQ(123456, actual);
138 }
139
TEST_F(ParamsTest0,sections)140 TEST_F(ParamsTest0, sections) {
141 EXPECT_TRUE(par_.define<std::string>("section1.simple_string", "String in sec 1").ok());
142 EXPECT_EQ(std::string("simple1!"), cpar_["section1.simple_string"].as<std::string>());
143 }
144
TEST_F(ParamsTest0,duplicates)145 TEST_F(ParamsTest0, duplicates) {
146 EXPECT_TRUE(par_.define<std::string>("duplicate", "Repeated string").ok());
147 EXPECT_EQ(std::string("duplicate2"), cpar_["duplicate"].as<std::string>());
148 }
149
TEST_F(ParamsTest0,emptyQuotedString)150 TEST_F(ParamsTest0, emptyQuotedString) {
151 EXPECT_TRUE(par_.define<std::string>("empty_quoted_string", "Empty quoted string").ok());
152 EXPECT_EQ(std::string(), cpar_["empty_quoted_string"].as<std::string>());
153 }
154
TEST_F(ParamsTest0,emptyString)155 TEST_F(ParamsTest0, emptyString) {
156 EXPECT_TRUE(par_.define<std::string>("empty_string", "Empty string").ok());
157 EXPECT_EQ(std::string(), cpar_["empty_string"].as<std::string>());
158 }
159
TEST_F(ParamsTest0,emptyStringTrailingSpace)160 TEST_F(ParamsTest0, emptyStringTrailingSpace) {
161 EXPECT_TRUE(par_.define<std::string>("empty_string_trailing_space", "Empty string").ok());
162 EXPECT_EQ(std::string(), cpar_["empty_string_trailing_space"].as<std::string>());
163 }
164
TEST_F(ParamsTest0,mixedCaseAsMixed)165 TEST_F(ParamsTest0, mixedCaseAsMixed) {
166 ASSERT_TRUE(par_.define<std::string>("MiXed_CaSe", "default", "Mixed-case").ok());
167 EXPECT_EQ("MiXeD", cpar_["MiXed_CaSe"].as<std::string>());
168 }
169
TEST_F(ParamsTest0,mixedCaseAsLowercase)170 TEST_F(ParamsTest0, mixedCaseAsLowercase) {
171 ASSERT_TRUE(par_.define<std::string>("mixed_case", "default", "Mixed-case").ok());
172 EXPECT_EQ("default", cpar_["mixed_case"].as<std::string>());
173 }
174
TEST_F(ParamsTest0,mixedCaseAsUppercase)175 TEST_F(ParamsTest0, mixedCaseAsUppercase) {
176 ASSERT_TRUE(par_.define<std::string>("MIXED_CASE", "default", "Mixed-case").ok());
177 EXPECT_EQ("default", cpar_["MIXED_CASE"].as<std::string>());
178 }
179
180
TEST_F(ParamsTest0,flags)181 TEST_F(ParamsTest0, flags) {
182 arg_holder args;
183 args.add("--flag");
184 params p(args.argc(), args.argv());
185 ASSERT_TRUE(p.define("flag", "A flag option").ok());
186 ASSERT_TRUE(p.define("other_flag", "Another flag option").ok());
187
188 EXPECT_TRUE(p["flag"].as<bool>());
189 EXPECT_FALSE(p["other_flag"].as<bool>());
190 }
191
TEST_F(ParamsTest0,hasMissingRequired)192 TEST_F(ParamsTest0, hasMissingRequired) {
193 EXPECT_FALSE(par_.define<int>("no_such_int", "whole-number").ok());
194 EXPECT_FALSE(par_.define<double>("no_such_double", "floating-point").ok());
195 EXPECT_TRUE(par_.has_missing());
196 std::ostringstream ostr;
197 EXPECT_TRUE(par_.has_missing(ostr));
198 EXPECT_TRUE(ostr.str().find("no_such_int")!=std::string::npos);
199 // EXPECT_TRUE(ostr.str().find("whole-number")!=std::string::npos);
200 EXPECT_TRUE(ostr.str().find("no_such_double")!=std::string::npos);
201 // EXPECT_TRUE(ostr.str().find("floating-point")!=std::string::npos);
202 EXPECT_TRUE(ostr.str().find("missing")!=std::string::npos);
203 // std::cout << ostr.str(); // DEBUG
204 }
205
TEST_F(ParamsTest0,hasMissingParsing)206 TEST_F(ParamsTest0, hasMissingParsing) {
207 EXPECT_FALSE(par_.define<int>("simple_string", "wrong-number").ok());
208 EXPECT_TRUE(par_.has_missing());
209 std::ostringstream ostr;
210 EXPECT_TRUE(par_.has_missing(ostr));
211 EXPECT_TRUE(ostr.str().find("simple_string")!=std::string::npos);
212 // EXPECT_TRUE(ostr.str().find("wrong-number")!=std::string::npos);
213 EXPECT_TRUE(ostr.str().find(" parse ")!=std::string::npos);
214 // std::cout << ostr.str(); // DEBUG
215 }
216
TEST_F(ParamsTest0,helpNotRequested)217 TEST_F(ParamsTest0, helpNotRequested) {
218 EXPECT_FALSE(par_.help_requested());
219 EXPECT_TRUE(par_.exists("help"));
220
221 par_.description("This is a test message");
222 EXPECT_TRUE(par_.exists("help"));
223 EXPECT_FALSE(par_.help_requested());
224
225 par_.
226 define<int>("whole_num", "My-integer").
227 define<double>("fp_num", 1.25, "My-fp").
228 define<std::string>("solver.name", "Solver name").
229 define<double>("solver.precision", 1E-5, "Solver precision").
230 define< std::vector<int> >("solver.parameters", "Solver internal parameters");
231
232 std::ostringstream ostr;
233 EXPECT_FALSE(par_.help_requested(ostr));
234 EXPECT_TRUE(ostr.str().empty());
235
236 EXPECT_EQ(&ostr, & par_.print_help(ostr));
237 EXPECT_TRUE(ostr.str().find("This is a test message")!=std::string::npos);
238 EXPECT_TRUE(ostr.str().find("whole_num")!=std::string::npos);
239 EXPECT_TRUE(ostr.str().find("My-integer")!=std::string::npos);
240 EXPECT_TRUE(ostr.str().find("fp_num")!=std::string::npos);
241 EXPECT_TRUE(ostr.str().find("My-fp")!=std::string::npos);
242 EXPECT_TRUE(ostr.str().find("1.25")!=std::string::npos);
243
244 std::cout << ostr.str(); // DEBUG
245 }
246
TEST_F(ParamsTest0,helpBooleanOff)247 TEST_F(ParamsTest0, helpBooleanOff) {
248 par_.
249 define("some_option", "An option");
250 std::ostringstream ostr;
251 par_.print_help(ostr);
252 EXPECT_TRUE(ostr.str().find("false")!=std::string::npos);
253 std::cout << ostr.str(); // DEBUG
254 }
255
TEST_F(ParamsTest0,helpBooleanOn)256 TEST_F(ParamsTest0, helpBooleanOn) {
257 par_.
258 define<bool>("some_option", true, "An option normally ON");
259 std::ostringstream ostr;
260 par_.print_help(ostr);
261 EXPECT_TRUE(ostr.str().find("true")!=std::string::npos);
262 std::cout << ostr.str(); // DEBUG
263 }
264
TEST_F(ParamsTest0,helpRequested)265 TEST_F(ParamsTest0, helpRequested) {
266 arg_holder args;
267 args.add("--help");
268 params p(args.argc(), args.argv());
269
270 p.
271 description("This is a test message").
272 define<int>("whole_num", "My-integer").
273 define<double>("fp_num", 1.25, "My-fp").
274 define<std::string>("solver.name", "Solver name").
275 define<double>("solver.precision", 1E-5, "Solver precision").
276 define< std::vector<int> >("solver.parameters", "Solver internal parameters");
277
278 EXPECT_TRUE(p.help_requested());
279 std::ostringstream ostr;
280 EXPECT_TRUE(p.help_requested(ostr));
281 EXPECT_TRUE(ostr.str().find("This is a test message")!=std::string::npos);
282 EXPECT_TRUE(ostr.str().find("whole_num")!=std::string::npos);
283 EXPECT_TRUE(ostr.str().find("My-integer")!=std::string::npos);
284 EXPECT_TRUE(ostr.str().find("fp_num")!=std::string::npos);
285 EXPECT_TRUE(ostr.str().find("My-fp")!=std::string::npos);
286 EXPECT_TRUE(ostr.str().find("1.25")!=std::string::npos);
287 std::cout << ostr.str(); // DEBUG
288 }
289
TEST_F(ParamsTest0,helpRequestedNoDescription)290 TEST_F(ParamsTest0, helpRequestedNoDescription) {
291 arg_holder args;
292 args.add("--help");
293 params p(args.argc(), args.argv());
294
295 p.define<int>("whole_num", "My-integer");
296 EXPECT_TRUE(p.help_requested());
297 std::ostringstream ostr;
298 EXPECT_TRUE(p.help_requested(ostr));
299 EXPECT_TRUE(ostr.str().find("whole_num")!=std::string::npos);
300 std::cout << ostr.str(); // DEBUG
301 }
302
TEST_F(ParamsTest0,helpRequestedUserDefined)303 TEST_F(ParamsTest0, helpRequestedUserDefined) {
304 arg_holder args;
305 args.add("--help");
306 params p(args.argc(), args.argv());
307
308 EXPECT_TRUE(p.help_requested());
309
310 p
311 .define("help", "A user-defined help message")
312 .define<int>("whole_num", "My-integer");
313
314 EXPECT_TRUE(p.help_requested());
315
316 std::ostringstream ostr;
317 EXPECT_TRUE(p.help_requested(ostr));
318 EXPECT_TRUE(ostr.str().find("A user-defined help message")!=std::string::npos);
319 EXPECT_TRUE(ostr.str().find("whole_num")!=std::string::npos);
320 std::cout << ostr.str(); // DEBUG
321 }
322
TEST_F(ParamsTest0,helpDeletedRedefined)323 TEST_F(ParamsTest0, helpDeletedRedefined) {
324 arg_holder args;
325 args.add("--help");
326 params p(args.argc(), args.argv());
327
328 // We can reassign a different type, whatever it means
329 p["help"]=1234;
330 EXPECT_NO_THROW(p["help"].as<int>());
331 EXPECT_FALSE(p.help_requested());
332
333 // We can erase help from the dictionary
334 p.erase("help");
335 EXPECT_FALSE(p.exists("help"));
336 EXPECT_FALSE(p.help_requested());
337
338 // but we cannot alter the parameter definition
339 EXPECT_THROW(p.define<int>("help", "Help is integer"), de::type_mismatch);
340
341 // and the help message still has the old definition
342 // (in this respect all paramnames behave the same)
343 p.define<int>("whole_num", "My-integer");
344
345 std::ostringstream ostr;
346 p.print_help(ostr);
347 EXPECT_FALSE(ostr.str().find("Help is integer")!=std::string::npos);
348 EXPECT_TRUE(ostr.str().find("whole_num")!=std::string::npos);
349 std::cout << ostr.str(); // DEBUG
350 }
351
352 /* ***** */
353 /* The following 54 test cases are pre-generated using the script `params_def_gen_test_helper.sh`
354 and manually edited.
355
356 The test names are of the following format:
357
358 defined{DEF|NODEF}dict{N|C|W}arg{N|C|W}redef{N|C|W},
359
360 where:
361 N generally stand for "nothing", C for "correct", W for "wrong"; specifically:
362
363 defined... : call to the defined<T>():
364 { with default | without default }
365
366 dict... : before defined<T>(), the parameter was:
367 { not in dictionary | in dictionary, of type T | in dictionary, of other type }
368
369 arg... : in the INI file, the argument is:
370 { absent | parseable as T | not parseable as T}
371
372 redef... : the second call to define<X>() with default is:
373 { absent | X is T | X is another type }
374
375 */
376
377 /*
378 Variant 1
379 the argument is missing
380 not defined in dict
381 Parameter defined without default
382 not redefined
383 */
TEST_F(ParamsTest0,definedNODEFdictNargNredefN)384 TEST_F(ParamsTest0, definedNODEFdictNargNredefN) {
385 std::string name="no_such_arg";
386
387 /* not in dict */
388
389 EXPECT_EQ("", cpar_.get_descr(name));
390
391 EXPECT_FALSE(par_.define<int>(name, "Int arg without default").ok());
392 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
393
394 /* not redefined */
395
396 ASSERT_FALSE(cpar_.exists(name));
397 }
398
399 /*
400 Variant 2
401 the argument is missing
402 not defined in dict
403 Parameter defined without default
404 redefined with the same type
405 */
TEST_F(ParamsTest0,definedNODEFdictNargNredefC)406 TEST_F(ParamsTest0, definedNODEFdictNargNredefC) {
407 std::string name="no_such_arg";
408
409 /* not in dict */
410
411 EXPECT_FALSE(par_.define<int>(name, "Int arg without default").ok());
412 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
413
414 const int redef_int_value=9999;
415 EXPECT_FALSE(par_.define<int>(name, redef_int_value, "int argument with a default").ok());
416 EXPECT_EQ("int argument with a default", cpar_.get_descr(name));
417
418 ASSERT_FALSE(cpar_.exists(name));
419 }
420
421 /*
422 Variant 3
423 the argument is missing
424 not defined in dict
425 Parameter defined without default
426 redefined with new type
427 */
TEST_F(ParamsTest0,definedNODEFdictNargNredefW)428 TEST_F(ParamsTest0, definedNODEFdictNargNredefW) {
429 std::string name="no_such_arg";
430
431 /* not in dict */
432
433 EXPECT_FALSE(par_.define<int>(name, "Int arg without default").ok());
434 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
435
436 EXPECT_THROW(par_.define<std::string>(name, "NEW default value", "String arg with NEW default"),
437 de::type_mismatch);
438
439 ASSERT_FALSE(cpar_.exists(name));
440 }
441
442 /*
443 Variant 4
444 the argument is correct type
445 not defined in dict
446 Parameter defined without default
447 not redefined
448 */
TEST_F(ParamsTest0,definedNODEFdictNargCredefN)449 TEST_F(ParamsTest0, definedNODEFdictNargCredefN) {
450 std::string name="an_int";
451 const int expected_arg_val=1234;
452
453 /* not in dict */
454
455 EXPECT_TRUE(par_.define<int>(name, "Int arg without default").ok());
456 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
457
458 /* not redefined */
459
460 ASSERT_TRUE(cpar_.exists(name));
461 int actual=cpar_[name];
462 EXPECT_EQ(expected_arg_val, actual);
463 }
464
465 /*
466 Variant 5
467 the argument is correct type
468 not defined in dict
469 Parameter defined without default
470 redefined with the same type
471 */
TEST_F(ParamsTest0,definedNODEFdictNargCredefC)472 TEST_F(ParamsTest0, definedNODEFdictNargCredefC) {
473 std::string name="an_int";
474 const int expected_arg_val=1234;
475
476 /* not in dict */
477
478 EXPECT_TRUE(par_.define<int>(name, "Int arg without default").ok());
479 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
480
481 const int redef_int_value=9999;
482 EXPECT_TRUE(par_.define<int>(name, redef_int_value, "int argument with a default").ok());
483 EXPECT_EQ("int argument with a default", cpar_.get_descr(name));
484
485 ASSERT_TRUE(cpar_.exists(name));
486 int actual=cpar_[name];
487 EXPECT_EQ(expected_arg_val, actual);
488 }
489
490 /*
491 Variant 6
492 the argument is correct type
493 not defined in dict
494 Parameter defined without default
495 redefined with new type
496 */
TEST_F(ParamsTest0,definedNODEFdictNargCredefW)497 TEST_F(ParamsTest0, definedNODEFdictNargCredefW) {
498 std::string name="an_int";
499 const int expected_arg_val=1234;
500
501 /* not in dict */
502
503 EXPECT_TRUE(par_.define<int>(name, "Int arg without default").ok());
504 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
505
506 EXPECT_THROW(par_.define<std::string>(name, "NEW default value", "String arg with NEW default"),
507 de::type_mismatch);
508 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
509
510 ASSERT_TRUE(cpar_.exists(name));
511 int actual=cpar_[name];
512 EXPECT_EQ(expected_arg_val, actual);
513 }
514
515 /*
516 Variant 7
517 the argument is incorrect type
518 not defined in dict
519 Parameter defined without default
520 not redefined
521 */
TEST_F(ParamsTest0,definedNODEFdictNargWredefN)522 TEST_F(ParamsTest0, definedNODEFdictNargWredefN) {
523 std::string name="simple_string";
524
525 /* not in dict */
526
527 EXPECT_FALSE(par_.define<int>(name, "Int arg without default").ok());
528 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
529
530 /* not redefined */
531
532 ASSERT_FALSE(cpar_.exists(name));
533 }
534
535 /*
536 Variant 8
537 the argument is incorrect type
538 not defined in dict
539 Parameter defined without default
540 redefined with the same type
541 */
TEST_F(ParamsTest0,definedNODEFdictNargWredefC)542 TEST_F(ParamsTest0, definedNODEFdictNargWredefC) {
543 std::string name="simple_string";
544
545 /* not in dict */
546
547 EXPECT_FALSE(par_.define<int>(name, "Int arg without default").ok());
548 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
549
550 const int redef_int_value=9999;
551 EXPECT_FALSE(par_.define<int>(name, redef_int_value, "int argument with a default").ok());
552 EXPECT_EQ("int argument with a default", cpar_.get_descr(name));
553
554 ASSERT_FALSE(cpar_.exists(name));
555 }
556
557 /*
558 Variant 9
559 the argument is incorrect type
560 not defined in dict
561 Parameter defined without default
562 redefined with new type
563 */
TEST_F(ParamsTest0,definedNODEFdictNargWredefW)564 TEST_F(ParamsTest0, definedNODEFdictNargWredefW) {
565 std::string name="simple_string";
566
567 /* not in dict */
568
569 EXPECT_FALSE(par_.define<int>(name, "Int arg without default").ok());
570 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
571
572 EXPECT_THROW(par_.define<std::string>(name, "NEW default value", "String arg with NEW default"),
573 de::type_mismatch);
574
575 ASSERT_FALSE(cpar_.exists(name));
576 }
577
578 /*
579 Variant 10
580 the argument is missing
581 pre-defined in dict, same type
582 Parameter defined without default
583 not redefined
584 */
TEST_F(ParamsTest0,definedNODEFdictCargNredefN)585 TEST_F(ParamsTest0, definedNODEFdictCargNredefN) {
586 std::string name="no_such_arg";
587
588 const int preexisting_int_val=7777;
589 par_[name]=preexisting_int_val;
590
591 EXPECT_EQ("", cpar_.get_descr(name));
592
593 EXPECT_TRUE(par_.define<int>(name, "Int arg without default").ok());
594 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
595
596 /* not redefined */
597
598 ASSERT_TRUE(cpar_.exists(name));
599 int actual=cpar_[name];
600 EXPECT_EQ(preexisting_int_val, actual);
601 }
602
603 /*
604 Variant 11
605 the argument is missing
606 pre-defined in dict, same type
607 Parameter defined without default
608 redefined with the same type
609 */
TEST_F(ParamsTest0,definedNODEFdictCargNredefC)610 TEST_F(ParamsTest0, definedNODEFdictCargNredefC) {
611 std::string name="no_such_arg";
612
613 const int preexisting_int_val=7777;
614 par_[name]=preexisting_int_val;
615
616 EXPECT_TRUE(par_.define<int>(name, "Int arg without default").ok());
617 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
618
619 const int redef_int_value=9999;
620 EXPECT_TRUE(par_.define<int>(name, redef_int_value, "int argument with a default").ok());
621 EXPECT_EQ("int argument with a default", cpar_.get_descr(name));
622
623 ASSERT_TRUE(cpar_.exists(name));
624 int actual=cpar_[name];
625 EXPECT_EQ(preexisting_int_val, actual);
626 }
627
628 /*
629 Variant 12
630 the argument is missing
631 pre-defined in dict, same type
632 Parameter defined without default
633 redefined with new type
634 */
TEST_F(ParamsTest0,definedNODEFdictCargNredefW)635 TEST_F(ParamsTest0, definedNODEFdictCargNredefW) {
636 std::string name="no_such_arg";
637
638 const int preexisting_int_val=7777;
639 par_[name]=preexisting_int_val;
640
641 EXPECT_TRUE(par_.define<int>(name, "Int arg without default").ok());
642 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
643
644 EXPECT_THROW(par_.define<std::string>(name, "NEW default value", "String arg with NEW default"),
645 de::type_mismatch);
646 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
647
648 ASSERT_TRUE(cpar_.exists(name));
649 int actual=cpar_[name];
650 EXPECT_EQ(preexisting_int_val, actual);
651 }
652
653 /*
654 Variant 13
655 the argument is correct type
656 pre-defined in dict, same type
657 Parameter defined without default
658 not redefined
659 */
TEST_F(ParamsTest0,definedNODEFdictCargCredefN)660 TEST_F(ParamsTest0, definedNODEFdictCargCredefN) {
661 std::string name="an_int";
662 const int expected_arg_val=1234;
663
664 const int preexisting_int_val=7777;
665 par_[name]=preexisting_int_val;
666
667 EXPECT_TRUE(par_.define<int>(name, "Int arg without default").ok());
668 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
669
670 /* not redefined */
671
672 ASSERT_TRUE(cpar_.exists(name));
673 int actual=cpar_[name];
674 EXPECT_EQ(expected_arg_val, actual);
675 }
676
677 /*
678 Variant 14
679 the argument is correct type
680 pre-defined in dict, same type
681 Parameter defined without default
682 redefined with the same type
683 */
TEST_F(ParamsTest0,definedNODEFdictCargCredefC)684 TEST_F(ParamsTest0, definedNODEFdictCargCredefC) {
685 std::string name="an_int";
686 const int expected_arg_val=1234;
687
688 const int preexisting_int_val=7777;
689 par_[name]=preexisting_int_val;
690
691 EXPECT_TRUE(par_.define<int>(name, "Int arg without default").ok());
692 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
693
694 const int redef_int_value=9999;
695 EXPECT_TRUE(par_.define<int>(name, redef_int_value, "int argument with a default").ok());
696 EXPECT_EQ("int argument with a default", cpar_.get_descr(name));
697
698 ASSERT_TRUE(cpar_.exists(name));
699 int actual=cpar_[name];
700 EXPECT_EQ(expected_arg_val, actual);
701 }
702
703 /*
704 Variant 15
705 the argument is correct type
706 pre-defined in dict, same type
707 Parameter defined without default
708 redefined with new type
709 */
TEST_F(ParamsTest0,definedNODEFdictCargCredefW)710 TEST_F(ParamsTest0, definedNODEFdictCargCredefW) {
711 std::string name="an_int";
712 const int expected_arg_val=1234;
713
714 const int preexisting_int_val=7777;
715 par_[name]=preexisting_int_val;
716
717 EXPECT_TRUE(par_.define<int>(name, "Int arg without default").ok());
718 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
719
720 EXPECT_THROW(par_.define<std::string>(name, "NEW default value", "String arg with NEW default"),
721 de::type_mismatch);
722 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
723
724 ASSERT_TRUE(cpar_.exists(name));
725 int actual=cpar_[name];
726 EXPECT_EQ(expected_arg_val, actual);
727 }
728
729 /*
730 Variant 16
731 the argument is incorrect type
732 pre-defined in dict, same type
733 Parameter defined without default
734 not redefined
735 */
TEST_F(ParamsTest0,definedNODEFdictCargWredefN)736 TEST_F(ParamsTest0, definedNODEFdictCargWredefN) {
737 std::string name="simple_string";
738
739 const int preexisting_int_val=7777;
740 par_[name]=preexisting_int_val;
741
742 EXPECT_FALSE(par_.define<int>(name, "Int arg without default").ok());
743 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
744
745 /* not redefined */
746
747 ASSERT_FALSE(cpar_.exists(name));
748 }
749
750 /*
751 Variant 17
752 the argument is incorrect type
753 pre-defined in dict, same type
754 Parameter defined without default
755 redefined with the same type
756 */
TEST_F(ParamsTest0,definedNODEFdictCargWredefC)757 TEST_F(ParamsTest0, definedNODEFdictCargWredefC) {
758 std::string name="simple_string";
759
760 const int preexisting_int_val=7777;
761 par_[name]=preexisting_int_val;
762
763 EXPECT_FALSE(par_.define<int>(name, "Int arg without default").ok());
764 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
765
766 const int redef_int_value=9999;
767 EXPECT_FALSE(par_.define<int>(name, redef_int_value, "int argument with a default").ok());
768 EXPECT_EQ("int argument with a default", cpar_.get_descr(name));
769
770 ASSERT_FALSE(cpar_.exists(name));
771 }
772
773 /*
774 Variant 18
775 the argument is incorrect type
776 pre-defined in dict, same type
777 Parameter defined without default
778 redefined with new type
779 */
TEST_F(ParamsTest0,definedNODEFdictCargWredefW)780 TEST_F(ParamsTest0, definedNODEFdictCargWredefW) {
781 std::string name="simple_string";
782
783 const int preexisting_int_val=7777;
784 par_[name]=preexisting_int_val;
785
786 EXPECT_FALSE(par_.define<int>(name, "Int arg without default").ok());
787 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
788
789 EXPECT_THROW(par_.define<std::string>(name, "NEW default value", "String arg with NEW default"),
790 de::type_mismatch);
791 EXPECT_EQ("Int arg without default", cpar_.get_descr(name));
792
793 ASSERT_FALSE(cpar_.exists(name));
794 }
795
796 /*
797 Variant 19
798 the argument is missing
799 pre-defined in dict, different type
800 Parameter defined without default
801 not redefined
802 */
TEST_F(ParamsTest0,definedNODEFdictWargNredefN)803 TEST_F(ParamsTest0, definedNODEFdictWargNredefN) {
804 std::string name="no_such_arg";
805
806 const std::string preexisting_string_val="pre-existing value";
807 par_[name]=preexisting_string_val;
808
809 EXPECT_THROW(par_.define<int>(name, "Int arg without default"),
810 de::type_mismatch);
811 EXPECT_EQ("", cpar_.get_descr(name));
812
813 /* not redefined */
814
815 ASSERT_TRUE(cpar_.exists(name));
816 std::string actual=cpar_[name];
817 EXPECT_EQ(preexisting_string_val, actual);
818 }
819
820 /*
821 Variant 20
822 the argument is missing
823 pre-defined in dict, different type
824 Parameter defined without default
825 redefined with the same type
826 */
TEST_F(ParamsTest0,definedNODEFdictWargNredefC)827 TEST_F(ParamsTest0, definedNODEFdictWargNredefC) {
828 std::string name="no_such_arg";
829
830 const std::string preexisting_string_val="pre-existing value";
831 par_[name]=preexisting_string_val;
832
833 EXPECT_THROW(par_.define<int>(name, "Int arg without default"),
834 de::type_mismatch);
835 EXPECT_EQ("", cpar_.get_descr(name));
836
837 const int redef_int_value=9999;
838 EXPECT_THROW(par_.define<int>(name, redef_int_value, "int argument with a default"),
839 de::type_mismatch);
840 EXPECT_EQ("", cpar_.get_descr(name));
841
842 ASSERT_TRUE(cpar_.exists(name));
843 std::string actual=cpar_[name];
844 EXPECT_EQ(preexisting_string_val, actual);
845 }
846
847 /*
848 Variant 21
849 the argument is missing
850 pre-defined in dict, different type
851 Parameter defined without default
852 redefined with new type
853 */
TEST_F(ParamsTest0,definedNODEFdictWargNredefW)854 TEST_F(ParamsTest0, definedNODEFdictWargNredefW) {
855 std::string name="no_such_arg";
856
857 const std::string preexisting_string_val="pre-existing value";
858 par_[name]=preexisting_string_val;
859
860 EXPECT_THROW(par_.define<int>(name, "Int arg without default"),
861 de::type_mismatch);
862 EXPECT_EQ("", cpar_.get_descr(name));
863
864 EXPECT_TRUE(par_.define<std::string>(name, "NEW default value", "String arg with NEW default").ok());
865 EXPECT_EQ("String arg with NEW default", cpar_.get_descr(name));
866
867 ASSERT_TRUE(cpar_.exists(name));
868 std::string actual=cpar_[name];
869 EXPECT_EQ(preexisting_string_val, actual);
870 }
871
872 /*
873 Variant 22
874 the argument is correct type
875 pre-defined in dict, different type
876 Parameter defined without default
877 not redefined
878 */
TEST_F(ParamsTest0,definedNODEFdictWargCredefN)879 TEST_F(ParamsTest0, definedNODEFdictWargCredefN) {
880 std::string name="an_int";
881 // const int expected_arg_val=1234;
882
883 const std::string preexisting_string_val="pre-existing value";
884 par_[name]=preexisting_string_val;
885
886 EXPECT_THROW(par_.define<int>(name, "Int arg without default"),
887 de::type_mismatch);
888 EXPECT_EQ("", cpar_.get_descr(name));
889
890 /* not redefined */
891
892 ASSERT_TRUE(cpar_.exists(name));
893 std::string actual=cpar_[name];
894 EXPECT_EQ(preexisting_string_val, actual);
895 }
896
897 /*
898 Variant 23
899 the argument is correct type
900 pre-defined in dict, different type
901 Parameter defined without default
902 redefined with the same type
903 */
TEST_F(ParamsTest0,definedNODEFdictWargCredefC)904 TEST_F(ParamsTest0, definedNODEFdictWargCredefC) {
905 std::string name="an_int";
906 // const int expected_arg_val=1234;
907
908 const std::string preexisting_string_val="pre-existing value";
909 par_[name]=preexisting_string_val;
910
911 EXPECT_THROW(par_.define<int>(name, "Int arg without default"),
912 de::type_mismatch);
913
914 const int redef_int_value=9999;
915 EXPECT_THROW(par_.define<int>(name, redef_int_value, "int argument with a default"),
916 de::type_mismatch);
917
918 ASSERT_TRUE(cpar_.exists(name));
919 std::string actual=cpar_[name];
920 EXPECT_EQ(preexisting_string_val, actual);
921 }
922
923 /*
924 Variant 24
925 the argument is correct type
926 pre-defined in dict, different type
927 Parameter defined without default
928 redefined with new type
929 */
TEST_F(ParamsTest0,definedNODEFdictWargCredefW)930 TEST_F(ParamsTest0, definedNODEFdictWargCredefW) {
931 std::string name="simple_string";
932
933 const int preexisting_int_val=7777;
934 par_[name]=preexisting_int_val;
935
936 EXPECT_THROW(par_.define<std::string>(name, "String arg without default"),
937 de::type_mismatch);
938 EXPECT_EQ("", cpar_.get_descr(name));
939
940 const int redef_int_value=9999;
941 EXPECT_FALSE(par_.define<int>(name, redef_int_value, "int argument with a default").ok());
942 EXPECT_EQ("int argument with a default", cpar_.get_descr(name));
943
944 ASSERT_FALSE(cpar_.exists(name));
945 }
946
947 /*
948 Variant 25
949 the argument is incorrect type
950 pre-defined in dict, different type
951 Parameter defined without default
952 not redefined
953 */
TEST_F(ParamsTest0,definedNODEFdictWargWredefN)954 TEST_F(ParamsTest0, definedNODEFdictWargWredefN) {
955 std::string name="simple_string";
956
957 const std::string preexisting_string_val="pre-existing value";
958 par_[name]=preexisting_string_val;
959
960 EXPECT_THROW(par_.define<int>(name, "Int arg without default"),
961 de::type_mismatch);
962 EXPECT_EQ("", cpar_.get_descr(name));
963
964 /* not redefined */
965
966 ASSERT_TRUE(cpar_.exists(name));
967 std::string actual=cpar_[name];
968 EXPECT_EQ(preexisting_string_val, actual);
969 }
970
971 /*
972 Variant 26
973 the argument is incorrect type
974 pre-defined in dict, different type
975 Parameter defined without default
976 redefined with the same type
977 */
TEST_F(ParamsTest0,definedNODEFdictWargWredefC)978 TEST_F(ParamsTest0, definedNODEFdictWargWredefC) {
979 std::string name="simple_string";
980
981 const std::string preexisting_string_val="pre-existing value";
982 par_[name]=preexisting_string_val;
983
984 EXPECT_THROW(par_.define<int>(name, "Int arg without default"),
985 de::type_mismatch);
986 EXPECT_EQ("", cpar_.get_descr(name));
987
988 const int redef_int_value=9999;
989 EXPECT_THROW(par_.define<int>(name, redef_int_value, "int argument with a default"),
990 de::type_mismatch);
991 EXPECT_EQ("", cpar_.get_descr(name));
992
993 ASSERT_TRUE(cpar_.exists(name));
994 std::string actual=cpar_[name];
995 EXPECT_EQ(preexisting_string_val, actual);
996 }
997
998 /*
999 Variant 27
1000 the argument is incorrect type
1001 pre-defined in dict, different type
1002 Parameter defined without default
1003 redefined with new type
1004 */
TEST_F(ParamsTest0,definedNODEFdictWargWredefW)1005 TEST_F(ParamsTest0, definedNODEFdictWargWredefW) {
1006 std::string name="simple_string";
1007
1008 const std::string preexisting_string_val="pre-existing value";
1009 par_[name]=preexisting_string_val;
1010
1011 EXPECT_THROW(par_.define<int>(name, "Int arg without default"),
1012 de::type_mismatch);
1013 EXPECT_EQ("", cpar_.get_descr(name));
1014
1015 EXPECT_TRUE(par_.define<std::string>(name, "NEW default value", "String arg with NEW default").ok());
1016 EXPECT_EQ("String arg with NEW default", cpar_.get_descr(name));
1017
1018 ASSERT_TRUE(cpar_.exists(name));
1019 std::string actual=cpar_[name];
1020 EXPECT_EQ("simple!", actual);
1021 }
1022
1023 /*
1024 Variant 28
1025 the argument is missing
1026 not defined in dict
1027 Parameter defined with default
1028 not redefined
1029 */
TEST_F(ParamsTest0,definedDEFdictNargNredefN)1030 TEST_F(ParamsTest0, definedDEFdictNargNredefN) {
1031 std::string name="no_such_arg";
1032
1033 /* not in dict */
1034
1035 const int deflt_int_val=1111;
1036 EXPECT_TRUE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1037 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1038
1039 /* not redefined */
1040
1041 ASSERT_TRUE(cpar_.exists(name));
1042 int actual=cpar_[name];
1043 EXPECT_EQ(deflt_int_val, actual);
1044 }
1045
1046 /*
1047 Variant 29
1048 the argument is missing
1049 not defined in dict
1050 Parameter defined with default
1051 redefined with the same type
1052 */
TEST_F(ParamsTest0,definedDEFdictNargNredefC)1053 TEST_F(ParamsTest0, definedDEFdictNargNredefC) {
1054 std::string name="no_such_arg";
1055
1056 /* not in dict */
1057
1058 const int deflt_int_val=1111;
1059 EXPECT_TRUE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1060 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1061
1062 const int redef_int_value=9999;
1063 EXPECT_TRUE(par_.define<int>(name, redef_int_value, "int argument with a default").ok());
1064 EXPECT_EQ("int argument with a default", cpar_.get_descr(name));
1065
1066 ASSERT_TRUE(cpar_.exists(name));
1067 int actual=cpar_[name];
1068 EXPECT_EQ(deflt_int_val, actual);
1069 }
1070
1071 /*
1072 Variant 30
1073 the argument is missing
1074 not defined in dict
1075 Parameter defined with default
1076 redefined with new type
1077 */
TEST_F(ParamsTest0,definedDEFdictNargNredefW)1078 TEST_F(ParamsTest0, definedDEFdictNargNredefW) {
1079 std::string name="no_such_arg";
1080
1081 /* not in dict */
1082
1083 const int deflt_int_val=1111;
1084 EXPECT_TRUE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1085 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1086
1087 EXPECT_THROW(par_.define<std::string>(name, "NEW default value", "String arg with NEW default"),
1088 de::type_mismatch);
1089 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1090
1091 ASSERT_TRUE(cpar_.exists(name));
1092 int actual=cpar_[name];
1093 EXPECT_EQ(deflt_int_val, actual);
1094 }
1095
1096 /*
1097 Variant 31
1098 the argument is correct type
1099 not defined in dict
1100 Parameter defined with default
1101 not redefined
1102 */
TEST_F(ParamsTest0,definedDEFdictNargCredefN)1103 TEST_F(ParamsTest0, definedDEFdictNargCredefN) {
1104 std::string name="an_int";
1105 const int expected_arg_val=1234;
1106
1107 /* not in dict */
1108
1109 const int deflt_int_val=1111;
1110 EXPECT_TRUE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1111 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1112
1113 /* not redefined */
1114
1115 ASSERT_TRUE(cpar_.exists(name));
1116 int actual=cpar_[name];
1117 EXPECT_EQ(expected_arg_val, actual);
1118 }
1119
1120 /*
1121 Variant 32
1122 the argument is correct type
1123 not defined in dict
1124 Parameter defined with default
1125 redefined with the same type
1126 */
TEST_F(ParamsTest0,definedDEFdictNargCredefC)1127 TEST_F(ParamsTest0, definedDEFdictNargCredefC) {
1128 std::string name="an_int";
1129 const int expected_arg_val=1234;
1130
1131 /* not in dict */
1132
1133 const int deflt_int_val=1111;
1134 EXPECT_TRUE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1135 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1136
1137 const int redef_int_value=9999;
1138 EXPECT_TRUE(par_.define<int>(name, redef_int_value, "int argument with a default").ok());
1139 EXPECT_EQ("int argument with a default", cpar_.get_descr(name));
1140
1141 ASSERT_TRUE(cpar_.exists(name));
1142 int actual=cpar_[name];
1143 EXPECT_EQ(expected_arg_val, actual);
1144 }
1145
1146 /*
1147 Variant 33
1148 the argument is correct type
1149 not defined in dict
1150 Parameter defined with default
1151 redefined with new type
1152 */
TEST_F(ParamsTest0,definedDEFdictNargCredefW)1153 TEST_F(ParamsTest0, definedDEFdictNargCredefW) {
1154 std::string name="an_int";
1155 const int expected_arg_val=1234;
1156
1157 /* not in dict */
1158
1159 const int deflt_int_val=1111;
1160 EXPECT_TRUE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1161 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1162
1163 EXPECT_THROW(par_.define<std::string>(name, "NEW default value", "String arg with NEW default"),
1164 de::type_mismatch);
1165 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1166
1167 ASSERT_TRUE(cpar_.exists(name));
1168 int actual=cpar_[name];
1169 EXPECT_EQ(expected_arg_val, actual);
1170 }
1171
1172 /*
1173 Variant 34
1174 the argument is incorrect type
1175 not defined in dict
1176 Parameter defined with default
1177 not redefined
1178 */
TEST_F(ParamsTest0,definedDEFdictNargWredefN)1179 TEST_F(ParamsTest0, definedDEFdictNargWredefN) {
1180 std::string name="simple_string";
1181
1182 /* not in dict */
1183
1184 const int deflt_int_val=1111;
1185 EXPECT_FALSE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1186 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1187
1188 /* not redefined */
1189
1190 ASSERT_FALSE(cpar_.exists(name));
1191 }
1192
1193 /*
1194 Variant 35
1195 the argument is incorrect type
1196 not defined in dict
1197 Parameter defined with default
1198 redefined with the same type
1199 */
TEST_F(ParamsTest0,definedDEFdictNargWredefC)1200 TEST_F(ParamsTest0, definedDEFdictNargWredefC) {
1201 std::string name="simple_string";
1202
1203 /* not in dict */
1204
1205 const int deflt_int_val=1111;
1206 EXPECT_FALSE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1207 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1208
1209 const int redef_int_value=9999;
1210 EXPECT_FALSE(par_.define<int>(name, redef_int_value, "int argument with a default").ok());
1211 EXPECT_EQ("int argument with a default", cpar_.get_descr(name));
1212
1213 ASSERT_FALSE(cpar_.exists(name));
1214 }
1215
1216 /*
1217 Variant 36
1218 the argument is incorrect type
1219 not defined in dict
1220 Parameter defined with default
1221 redefined with new type
1222 */
TEST_F(ParamsTest0,definedDEFdictNargWredefW)1223 TEST_F(ParamsTest0, definedDEFdictNargWredefW) {
1224 std::string name="simple_string";
1225
1226 /* not in dict */
1227
1228 const int deflt_int_val=1111;
1229 EXPECT_FALSE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1230 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1231
1232 EXPECT_THROW(par_.define<std::string>(name, "NEW default value", "String arg with NEW default"),
1233 de::type_mismatch);
1234
1235 ASSERT_FALSE(cpar_.exists(name));
1236 }
1237
1238 /*
1239 Variant 37
1240 the argument is missing
1241 pre-defined in dict, same type
1242 Parameter defined with default
1243 not redefined
1244 */
TEST_F(ParamsTest0,definedDEFdictCargNredefN)1245 TEST_F(ParamsTest0, definedDEFdictCargNredefN) {
1246 std::string name="no_such_arg";
1247
1248 const int preexisting_int_val=7777;
1249 par_[name]=preexisting_int_val;
1250
1251 const int deflt_int_val=1111;
1252 EXPECT_TRUE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1253 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1254
1255 /* not redefined */
1256
1257 ASSERT_TRUE(cpar_.exists(name));
1258 int actual=cpar_[name];
1259 EXPECT_EQ(preexisting_int_val, actual);
1260 }
1261
1262 /*
1263 Variant 38
1264 the argument is missing
1265 pre-defined in dict, same type
1266 Parameter defined with default
1267 redefined with the same type
1268 */
TEST_F(ParamsTest0,definedDEFdictCargNredefC)1269 TEST_F(ParamsTest0, definedDEFdictCargNredefC) {
1270 std::string name="no_such_arg";
1271
1272 const int preexisting_int_val=7777;
1273 par_[name]=preexisting_int_val;
1274
1275 const int deflt_int_val=1111;
1276 EXPECT_TRUE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1277 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1278
1279 const int redef_int_value=9999;
1280 EXPECT_TRUE(par_.define<int>(name, redef_int_value, "int argument with a default").ok());
1281 EXPECT_EQ("int argument with a default", cpar_.get_descr(name));
1282
1283 ASSERT_TRUE(cpar_.exists(name));
1284 int actual=cpar_[name];
1285 EXPECT_EQ(preexisting_int_val, actual);
1286 }
1287
1288 /*
1289 Variant 39
1290 the argument is missing
1291 pre-defined in dict, same type
1292 Parameter defined with default
1293 redefined with new type
1294 */
TEST_F(ParamsTest0,definedDEFdictCargNredefW)1295 TEST_F(ParamsTest0, definedDEFdictCargNredefW) {
1296 std::string name="no_such_arg";
1297
1298 const int preexisting_int_val=7777;
1299 par_[name]=preexisting_int_val;
1300
1301 const int deflt_int_val=1111;
1302 EXPECT_TRUE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1303 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1304
1305 EXPECT_THROW(par_.define<std::string>(name, "NEW default value", "String arg with NEW default"),
1306 de::type_mismatch);
1307 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1308
1309 ASSERT_TRUE(cpar_.exists(name));
1310 int actual=cpar_[name];
1311 EXPECT_EQ(preexisting_int_val, actual);
1312 }
1313
1314 /*
1315 Variant 40
1316 the argument is correct type
1317 pre-defined in dict, same type
1318 Parameter defined with default
1319 not redefined
1320 */
TEST_F(ParamsTest0,definedDEFdictCargCredefN)1321 TEST_F(ParamsTest0, definedDEFdictCargCredefN) {
1322 std::string name="an_int";
1323 const int expected_arg_val=1234;
1324
1325 const int preexisting_int_val=7777;
1326 par_[name]=preexisting_int_val;
1327
1328 const int deflt_int_val=1111;
1329 EXPECT_TRUE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1330 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1331
1332 /* not redefined */
1333
1334 ASSERT_TRUE(cpar_.exists(name));
1335 int actual=cpar_[name];
1336 EXPECT_EQ(expected_arg_val, actual);
1337 }
1338
1339 /*
1340 Variant 41
1341 the argument is correct type
1342 pre-defined in dict, same type
1343 Parameter defined with default
1344 redefined with the same type
1345 */
TEST_F(ParamsTest0,definedDEFdictCargCredefC)1346 TEST_F(ParamsTest0, definedDEFdictCargCredefC) {
1347 std::string name="an_int";
1348 const int expected_arg_val=1234;
1349
1350 const int preexisting_int_val=7777;
1351 par_[name]=preexisting_int_val;
1352
1353 const int deflt_int_val=1111;
1354 EXPECT_TRUE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1355 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1356
1357 const int redef_int_value=9999;
1358 EXPECT_TRUE(par_.define<int>(name, redef_int_value, "int argument with a default").ok());
1359 EXPECT_EQ("int argument with a default", cpar_.get_descr(name));
1360
1361 ASSERT_TRUE(cpar_.exists(name));
1362 int actual=cpar_[name];
1363 EXPECT_EQ(expected_arg_val, actual);
1364 }
1365
1366 /*
1367 Variant 42
1368 the argument is correct type
1369 pre-defined in dict, same type
1370 Parameter defined with default
1371 redefined with new type
1372 */
TEST_F(ParamsTest0,definedDEFdictCargCredefW)1373 TEST_F(ParamsTest0, definedDEFdictCargCredefW) {
1374 std::string name="an_int";
1375 const int expected_arg_val=1234;
1376
1377 const int preexisting_int_val=7777;
1378 par_[name]=preexisting_int_val;
1379
1380 const int deflt_int_val=1111;
1381 EXPECT_TRUE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1382 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1383
1384 EXPECT_THROW(par_.define<std::string>(name, "NEW default value", "String arg with NEW default"),
1385 de::type_mismatch);
1386 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1387
1388 ASSERT_TRUE(cpar_.exists(name));
1389 int actual=cpar_[name];
1390 EXPECT_EQ(expected_arg_val, actual);
1391 }
1392
1393 /*
1394 Variant 43
1395 the argument is incorrect type
1396 pre-defined in dict, same type
1397 Parameter defined with default
1398 not redefined
1399 */
TEST_F(ParamsTest0,definedDEFdictCargWredefN)1400 TEST_F(ParamsTest0, definedDEFdictCargWredefN) {
1401 std::string name="simple_string";
1402
1403 const int preexisting_int_val=7777;
1404 par_[name]=preexisting_int_val;
1405
1406 const int deflt_int_val=1111;
1407 EXPECT_FALSE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1408 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1409
1410 /* not redefined */
1411
1412 ASSERT_FALSE(cpar_.exists(name));
1413 }
1414
1415 /*
1416 Variant 44
1417 the argument is incorrect type
1418 pre-defined in dict, same type
1419 Parameter defined with default
1420 redefined with the same type
1421 */
TEST_F(ParamsTest0,definedDEFdictCargWredefC)1422 TEST_F(ParamsTest0, definedDEFdictCargWredefC) {
1423 std::string name="simple_string";
1424
1425 const int preexisting_int_val=7777;
1426 par_[name]=preexisting_int_val;
1427
1428 const int deflt_int_val=1111;
1429 EXPECT_FALSE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1430 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1431
1432 const int redef_int_value=9999;
1433 EXPECT_FALSE(par_.define<int>(name, redef_int_value, "int argument with a default").ok());
1434 EXPECT_EQ("int argument with a default", cpar_.get_descr(name));
1435
1436 ASSERT_FALSE(cpar_.exists(name));
1437 }
1438
1439 /*
1440 Variant 45
1441 the argument is incorrect type
1442 pre-defined in dict, same type
1443 Parameter defined with default
1444 redefined with new type
1445 */
TEST_F(ParamsTest0,definedDEFdictCargWredefW)1446 TEST_F(ParamsTest0, definedDEFdictCargWredefW) {
1447 std::string name="simple_string";
1448
1449 const int preexisting_int_val=7777;
1450 par_[name]=preexisting_int_val;
1451
1452 const int deflt_int_val=1111;
1453 EXPECT_FALSE(par_.define<int>(name, deflt_int_val, "Int arg with default").ok());
1454 EXPECT_EQ("Int arg with default", cpar_.get_descr(name));
1455
1456 EXPECT_THROW(par_.define<std::string>(name, "NEW default value", "String arg with NEW default"),
1457 de::type_mismatch);
1458
1459 ASSERT_FALSE(cpar_.exists(name));
1460 }
1461
1462 /*
1463 Variant 46
1464 the argument is missing
1465 pre-defined in dict, different type
1466 Parameter defined with default
1467 not redefined
1468 */
TEST_F(ParamsTest0,definedDEFdictWargNredefN)1469 TEST_F(ParamsTest0, definedDEFdictWargNredefN) {
1470 std::string name="no_such_arg";
1471
1472 const std::string preexisting_string_val="pre-existing value";
1473 par_[name]=preexisting_string_val;
1474
1475 const int deflt_int_val=1111;
1476 EXPECT_THROW(par_.define<int>(name, deflt_int_val, "Int arg with default"),
1477 de::type_mismatch);
1478 EXPECT_EQ("", cpar_.get_descr(name));
1479
1480 /* not redefined */
1481
1482 ASSERT_TRUE(cpar_.exists(name));
1483 std::string actual=cpar_[name];
1484 EXPECT_EQ(preexisting_string_val, actual);
1485 }
1486
1487 /*
1488 Variant 47
1489 the argument is missing
1490 pre-defined in dict, different type
1491 Parameter defined with default
1492 redefined with the same type
1493 */
TEST_F(ParamsTest0,definedDEFdictWargNredefC)1494 TEST_F(ParamsTest0, definedDEFdictWargNredefC) {
1495 std::string name="no_such_arg";
1496
1497 const std::string preexisting_string_val="pre-existing value";
1498 par_[name]=preexisting_string_val;
1499
1500 const int deflt_int_val=1111;
1501 EXPECT_THROW(par_.define<int>(name, deflt_int_val, "Int arg with default"),
1502 de::type_mismatch);
1503
1504 const int redef_int_value=9999;
1505 EXPECT_THROW(par_.define<int>(name, redef_int_value, "int argument with a default"),
1506 de::type_mismatch);
1507
1508 EXPECT_EQ("", cpar_.get_descr(name));
1509
1510 ASSERT_TRUE(cpar_.exists(name));
1511 std::string actual=cpar_[name];
1512 EXPECT_EQ(preexisting_string_val, actual);
1513 }
1514
1515 /*
1516 Variant 48
1517 the argument is missing
1518 pre-defined in dict, different type
1519 Parameter defined with default
1520 redefined with new type
1521 */
TEST_F(ParamsTest0,definedDEFdictWargNredefW)1522 TEST_F(ParamsTest0, definedDEFdictWargNredefW) {
1523 std::string name="no_such_arg";
1524
1525 const std::string preexisting_string_val="pre-existing value";
1526 par_[name]=preexisting_string_val;
1527
1528 const int deflt_int_val=1111;
1529 EXPECT_THROW(par_.define<int>(name, deflt_int_val, "Int arg with default"),
1530 de::type_mismatch);
1531
1532 EXPECT_TRUE(par_.define<std::string>(name, "NEW default value", "String arg with NEW default").ok());
1533 EXPECT_EQ("String arg with NEW default", cpar_.get_descr(name));
1534
1535 ASSERT_TRUE(cpar_.exists(name));
1536 std::string actual=cpar_[name];
1537 EXPECT_EQ(preexisting_string_val, actual);
1538 }
1539
1540 /*
1541 Variant 49
1542 the argument is correct type
1543 pre-defined in dict, different type
1544 Parameter defined with default
1545 not redefined
1546 */
TEST_F(ParamsTest0,definedDEFdictWargCredefN)1547 TEST_F(ParamsTest0, definedDEFdictWargCredefN) {
1548 std::string name="an_int";
1549 // const int expected_arg_val=1234;
1550
1551 const std::string preexisting_string_val="pre-existing value";
1552 par_[name]=preexisting_string_val;
1553
1554 const int deflt_int_val=1111;
1555 EXPECT_THROW(par_.define<int>(name, deflt_int_val, "Int arg with default"),
1556 de::type_mismatch);
1557 EXPECT_EQ("", cpar_.get_descr(name));
1558
1559 /* not redefined */
1560
1561 ASSERT_TRUE(cpar_.exists(name));
1562 std::string actual=cpar_[name];
1563 EXPECT_EQ(preexisting_string_val, actual);
1564 }
1565
1566 /*
1567 Variant 50
1568 the argument is correct type
1569 pre-defined in dict, different type
1570 Parameter defined with default
1571 redefined with the same type
1572 */
TEST_F(ParamsTest0,definedDEFdictWargCredefC)1573 TEST_F(ParamsTest0, definedDEFdictWargCredefC) {
1574 std::string name="an_int";
1575 // const int expected_arg_val=1234;
1576
1577 const std::string preexisting_string_val="pre-existing value";
1578 par_[name]=preexisting_string_val;
1579
1580 const int deflt_int_val=1111;
1581 EXPECT_THROW(par_.define<int>(name, deflt_int_val, "Int arg with default"),
1582 de::type_mismatch);
1583
1584 const int redef_int_value=9999;
1585 EXPECT_THROW(par_.define<int>(name, redef_int_value, "int argument with a default"),
1586 de::type_mismatch);
1587
1588 EXPECT_EQ("", cpar_.get_descr(name));
1589
1590 ASSERT_TRUE(cpar_.exists(name));
1591 std::string actual=cpar_[name];
1592 EXPECT_EQ(preexisting_string_val, actual);
1593 }
1594
1595 /*
1596 Variant 51
1597 the argument is correct type
1598 pre-defined in dict, different type
1599 Parameter defined with default
1600 redefined with new type
1601 */
TEST_F(ParamsTest0,definedDEFdictWargCredefW)1602 TEST_F(ParamsTest0, definedDEFdictWargCredefW) {
1603 std::string name="simple_string";
1604 // const std::string expected_arg_val="simple!";
1605
1606 const int preexisting_int_val=7777;
1607 par_[name]=preexisting_int_val;
1608
1609 EXPECT_THROW(par_.define<std::string>(name, "default string val", "String arg with default"),
1610 de::type_mismatch);
1611 EXPECT_EQ("", cpar_.get_descr(name));
1612
1613 const int redef_int_value=9999;
1614 EXPECT_FALSE(par_.define<int>(name, redef_int_value, "int argument with a default").ok());
1615 EXPECT_EQ("int argument with a default", cpar_.get_descr(name));
1616
1617 ASSERT_FALSE(cpar_.exists(name));
1618 }
1619
1620 /*
1621 Variant 52
1622 the argument is incorrect type
1623 pre-defined in dict, different type
1624 Parameter defined with default
1625 not redefined
1626 */
TEST_F(ParamsTest0,definedDEFdictWargWredefN)1627 TEST_F(ParamsTest0, definedDEFdictWargWredefN) {
1628 std::string name="simple_string";
1629
1630 const std::string preexisting_string_val="pre-existing value";
1631 par_[name]=preexisting_string_val;
1632
1633 const int deflt_int_val=1111;
1634 EXPECT_THROW(par_.define<int>(name, deflt_int_val, "Int arg with default"),
1635 de::type_mismatch);
1636 EXPECT_EQ("", cpar_.get_descr(name));
1637
1638 /* not redefined */
1639
1640 ASSERT_TRUE(cpar_.exists(name));
1641 std::string actual=cpar_[name];
1642 EXPECT_EQ(preexisting_string_val, actual);
1643 }
1644
1645 /*
1646 Variant 53
1647 the argument is incorrect type
1648 pre-defined in dict, different type
1649 Parameter defined with default
1650 redefined with the same type
1651 */
TEST_F(ParamsTest0,definedDEFdictWargWredefC)1652 TEST_F(ParamsTest0, definedDEFdictWargWredefC) {
1653 std::string name="simple_string";
1654
1655 const std::string preexisting_string_val="pre-existing value";
1656 par_[name]=preexisting_string_val;
1657
1658 const int deflt_int_val=1111;
1659 EXPECT_THROW(par_.define<int>(name, deflt_int_val, "Int arg with default"),
1660 de::type_mismatch);
1661
1662 const int redef_int_value=9999;
1663 EXPECT_THROW(par_.define<int>(name, redef_int_value, "int argument with a default"),
1664 de::type_mismatch);
1665
1666 EXPECT_EQ("", cpar_.get_descr(name));
1667
1668 ASSERT_TRUE(cpar_.exists(name));
1669 std::string actual=cpar_[name];
1670 EXPECT_EQ(preexisting_string_val, actual);
1671 }
1672
1673 /*
1674 Variant 54
1675 the argument is incorrect type
1676 pre-defined in dict, different type
1677 Parameter defined with default
1678 redefined with new type
1679 */
TEST_F(ParamsTest0,definedDEFdictWargWredefW)1680 TEST_F(ParamsTest0, definedDEFdictWargWredefW) {
1681 std::string name="simple_string";
1682 const std::string expected_arg_val="simple!";
1683
1684 const std::string preexisting_string_val="pre-existing value";
1685 par_[name]=preexisting_string_val;
1686
1687 const int deflt_int_val=1111;
1688 EXPECT_THROW(par_.define<int>(name, deflt_int_val, "Int arg with default"),
1689 de::type_mismatch);
1690 EXPECT_EQ("", cpar_.get_descr(name));
1691
1692 EXPECT_TRUE(par_.define<std::string>(name, "NEW default value", "String arg with NEW default").ok());
1693 EXPECT_EQ("String arg with NEW default", cpar_.get_descr(name));
1694
1695 ASSERT_TRUE(cpar_.exists(name));
1696 std::string actual=cpar_[name];
1697 EXPECT_EQ(expected_arg_val, actual);
1698 }
1699
1700 /* ***** */
1701 /* *** End of auto-generated tests *** */
1702
1703
1704 // #define X_EXPECT_THROW(a,b) a
1705