Iguana 0.0.0
Implementation Guardian of Analysis Algorithms
Loading...
Searching...
No Matches
TestConfig.h
1// test configuration
2
3#include <cassert>
4#include <iguana/algorithms/Algorithm.h>
5
6inline int TestConfig(int test_num, bool verbose)
7{
8 if(test_num == 0) {
9 fmt::print(stderr, "ERROR: need a test number\n");
10 return 1;
11 }
12 // first, some sanity checks of `ConfigFileReader`
13 iguana::ConfigFileReader bad_config("bad_config");
14 bad_config.AddDirectory("non_existent_directory");
15 try {
16 bad_config.AddFile("non_existent_file.yaml");
17 }
18 catch(std::exception const& ex) {
19 fmt::print("excpected exception thrown when trying to add non-existent file\n");
20 }
21 bad_config.PrintDirectories();
22
23 // then test configuring an algorithm
24 auto algo = iguana::AlgorithmFactory::Create("example::ExampleAlgorithm");
25 algo->SetOption("log", verbose ? "debug" : "info");
26 algo->SetConfigDirectory("src/iguana/tests"); // must be relative to build directory
27 algo->SetConfigFile(fmt::format("test_{}.yaml", test_num));
28 algo->Start();
29
30 switch(test_num) {
31
32 case 1: {
33 // test `GetOptionScalar`
34 assert((algo->GetOptionScalar<int>("scalar_int") == 1));
35 assert((algo->GetOptionScalar<double>("scalar_double") == 2.5));
36 assert((algo->GetOptionScalar<std::string>("scalar_string") == "lizard"));
37 // test `GetOptionVector`
38 assert((algo->GetOptionVector<int>("vector_int") == std::vector<int>{1, 2, 3}));
39 assert((algo->GetOptionVector<double>("vector_double") == std::vector<double>{1.5, 2.5}));
40 assert((algo->GetOptionVector<std::string>("vector_string") == std::vector<std::string>{"spider", "bat", "chameleon", "spider"}));
41 // test `GetOptionSet`
42 auto s = algo->GetOptionSet<std::string>("vector_string");
43 assert((s.size() == 3));
44 assert((s.find("spider") != s.end()));
45 assert((s.find("bee") == s.end()));
46 // test empty access - expect exceptions, so just catch them and do nothing
47 try {
48 algo->GetOptionScalar<int>("scalar_empty");
49 fmt::print(stderr, "ERROR: accessing 'scalar_empty' did not throw exception\n");
50 return 1;
51 }
52 catch(std::exception const& ex) {
53 fmt::print("SUCCESS: accessing 'scalar_empty' threw an expected exception\n");
54 }
55 try {
56 algo->GetOptionVector<int>("vector_empty");
57 fmt::print(stderr, "ERROR: accessing 'vector_empty' did not throw exception\n");
58 return 1;
59 }
60 catch(std::exception const& ex) {
61 fmt::print("SUCCESS: accessing 'vector_empty' threw an expected exception\n");
62 }
63 try {
64 algo->GetOptionSet<int>("vector_empty");
65 fmt::print(stderr, "ERROR: accessing 'vector_empty' as a `set` did not throw exception\n");
66 return 1;
67 }
68 catch(std::exception const& ex) {
69 fmt::print("SUCCESS: accessing 'vector_empty' as a `set` threw an expected exception\n");
70 }
71 // test access to a key that does not exist
72 try {
73 algo->GetOptionScalar<int>("non_existent_scalar");
74 fmt::print(stderr, "ERROR: accessing 'non_existent_scalar' did not throw exception\n");
75 return 1;
76 }
77 catch(std::exception const& ex) {
78 fmt::print("SUCCESS: accessing 'non_existent_scalar' threw an expected exception\n");
79 }
80 try {
81 algo->GetOptionVector<int>("non_existent_vector");
82 fmt::print(stderr, "ERROR: accessing 'non_existent_vector' did not throw exception\n");
83 return 1;
84 }
85 catch(std::exception const& ex) {
86 fmt::print("SUCCESS: accessing 'non_existent_vector' threw an expected exception\n");
87 }
88 try {
89 algo->GetOptionSet<int>("non_existent_vector");
90 fmt::print(stderr, "ERROR: accessing 'non_existent_vector' as a `set` did not throw exception\n");
91 return 1;
92 }
93 catch(std::exception const& ex) {
94 fmt::print("SUCCESS: accessing 'non_existent_vector' as a `set` threw an expected exception\n");
95 }
96 break;
97 }
98
99 case 2: {
100 assert((algo->GetOptionScalar<double>("t1s1", {"tree1", "scalar1"}) == 1.5));
101 assert((algo->GetOptionScalar<double>("t1s2", {"tree1", "scalar2"}) == 2.5));
102 assert((algo->GetOptionScalar<double>("t2t1s1", {"tree2", "tree1", "scalar1"}) == 3.5));
103 assert((algo->GetOptionVector<std::string>("t2t2t3v1", {"tree2", "tree2", "tree3", "vector1"}) == std::vector<std::string>{"gecko", "snake"}));
104 assert((algo->GetOptionVector<int>("t2v2", {"tree2", "vector2"}) == std::vector<int>{3, -4, 5}));
105 assert((algo->GetOptionVector<std::string>("vector1", {"vector1"}) == std::vector<std::string>{"bee"}));
106 assert((algo->GetOptionVector<std::string>("vector1") == std::vector<std::string>{"bee"}));
107 break;
108 }
109
110 case 3: {
111 // test InRange tree1
112 assert((algo->GetOptionScalar<int>("t1a", {"tree1", algo->GetConfig()->InRange("test_range", 1), "val"}) == 3));
113 assert((algo->GetOptionScalar<int>("t1b", {"tree1", algo->GetConfig()->InRange("test_range", 3), "val"}) == 3));
114 assert((algo->GetOptionScalar<int>("t1c", {"tree1", algo->GetConfig()->InRange("test_range", 5), "val"}) == 3)); // at a border
115 assert((algo->GetOptionScalar<int>("t1d", {"tree1", algo->GetConfig()->InRange("test_range", 6), "val"}) == 4));
116 assert((algo->GetOptionScalar<int>("t1e", {"tree1", algo->GetConfig()->InRange("test_range", 10), "val"}) == 4));
117 assert((algo->GetOptionScalar<int>("t1f", {"tree1", algo->GetConfig()->InRange("test_range", 11), "val"}) == 0)); // default fallback
118 assert((algo->GetOptionScalar<int>("t1g", {"tree1", algo->GetConfig()->InRange("test_range", 10.1), "val"}) == 0)); // wrong type
119 assert((algo->GetOptionScalar<int>("t1h", {"tree1", algo->GetConfig()->InRange("test_range", 3.7), "val"}) == 3)); // wrong type
120 // test InRange tree2
121 assert((algo->GetOptionScalar<std::string>("t2a", {"tree2", algo->GetConfig()->InRange("test_range", 1.9), "subtree", "lizard"}) == "iguana"));
122 assert((algo->GetOptionScalar<int>("t2b", {"tree2", algo->GetConfig()->InRange("test_range", 1.9), "subtree", "number"}) == 7));
123 assert((algo->GetOptionScalar<int>("t2c", {"tree2", algo->GetConfig()->InRange("test_range", 3.0), "subtree", algo->GetConfig()->InRange("sub_range", 1), "val"}) == 7));
124 assert((algo->GetOptionScalar<int>("t2d", {"tree2", algo->GetConfig()->InRange("test_range", 3.0), "subtree", algo->GetConfig()->InRange("sub_range", 8), "val"}) == 8));
125 assert((algo->GetOptionScalar<int>("t2e", {"tree2", algo->GetConfig()->InRange("test_range", 3.5), "subtree", algo->GetConfig()->InRange("sub_range", 11), "val"}) == 1));
126 assert((algo->GetOptionScalar<int>("t2f", {"tree2", algo->GetConfig()->InRange("test_range", 4.0), "subtree"}) == 10));
127 // test InRange tree3
128 assert((algo->GetOptionScalar<int>("t3a", {"tree3", algo->GetConfig()->InRange("test_range", 3), "val"}) == 3));
129 try {
130 assert((algo->GetOptionScalar<int>("t3b", {"tree3", algo->GetConfig()->InRange("test_range", 11), "val"}) == 0));
131 fmt::print(stderr, "ERROR: accessing a missing default value for `InRange` did not throw exception\n");
132 return 1;
133 }
134 catch(std::exception const& ex) {
135 fmt::print("SUCCESS: accessing a missing default value for `InRange` threw expected exception\n");
136 }
137 break;
138 }
139
140 default:
141 fmt::print(stderr, "ERROR: unknown test number '{}'", test_num);
142 return 1;
143 }
144 return 0;
145}
iguana::AlgorithmFactory::Create
static algo_t Create(std::string const &name) noexcept(false)
iguana::ConfigFileReader
Configuration file manager.
Definition ConfigFileReader.h:10
Generated by doxygen 1.12.0