1 /** @file gsUtils_test.cpp
2 
3     @brief Tests helper functions in util namespace.
4     Most of them exist native in CXX11 and are handmade for CXX98.
5     This Unittests help us to prove that the work as expected.
6 
7     This file is part of the G+Smo library.
8 
9     This Source Code Form is subject to the terms of the Mozilla Public
10     License, v. 2.0. If a copy of the MPL was not distributed with this
11     file, You can obtain one at http://mozilla.org/MPL/2.0/.
12 
13     Author(s): J. Vogl
14 **/
15 
16 #include "gismo_unittest.h"
17 
SUITE(gsUtils_test)18 SUITE(gsUtils_test)
19 {
20 TEST(to_string)
21 {
22     CHECK_EQUAL("1", util::to_string(int(1)));
23     CHECK_EQUAL("-1", util::to_string(int(-1)));
24     CHECK_EQUAL("1", util::to_string(long(1)));
25     CHECK_EQUAL("abcd", util::to_string("abcd"));
26     CHECK_EQUAL("abcd", util::to_string("abcd\0"));
27     CHECK_EQUAL("ab", util::to_string("ab\0cd"));
28     //char array[] = { 'a', 'b', 'c' };
29     //CHECK_EQUAL("abc", util::to_string(array)); // should fail to build
30 }
31 
32 TEST(starts_with)
33 {
34     CHECK(util::starts_with("abcd", "a"));
35     CHECK(util::starts_with("abcd", "ab"));
36     CHECK(util::starts_with("abcd", "abc"));
37     CHECK(util::starts_with("abcd", "abcd"));
38 
39     CHECK(!util::starts_with("abcd", "bcd"));
40     CHECK(!util::starts_with("abcd", "acd"));
41     CHECK(!util::starts_with("abcd", "abd"));
42 
43     CHECK(!util::starts_with("abc", "abcd"));
44 
45     CHECK(util::starts_with("a\0bcd", "a"));
46     CHECK(!util::starts_with("a\0bcd", "ab"));
47     CHECK(util::starts_with("acd", "a\0b"));
48 }
49 
50 TEST(ends_with)
51 {
52     CHECK(util::ends_with("abcd", "d"));
53     CHECK(util::ends_with("abcd", "cd"));
54     CHECK(util::ends_with("abcd", "bcd"));
55     CHECK(util::ends_with("abcd", "abcd"));
56 
57     CHECK(!util::ends_with("abcd", "acd"));
58     CHECK(!util::ends_with("abcd", "abd"));
59     CHECK(!util::ends_with("abcd", "abc"));
60 
61     CHECK(!util::ends_with("abc", "abcd"));
62 
63     CHECK(util::ends_with("abc\0d", "bc"));
64     CHECK(util::ends_with("a\0bcd", "a"));
65     CHECK(util::ends_with("abc", "bc\0d"));
66 }
67 
68 TEST(iota)
69 {
70     {
71         std::vector<index_t> v(10);
72         util::iota(v.begin(), v.end(), -4);
73 
74         for (size_t i = 0; i < v.size(); ++i)
75         {
76             CHECK_EQUAL((index_t)i - 4, v[i]);
77         }
78     }
79 
80     {
81         std::list<index_t> l(10);
82         util::iota(l.begin(), l.end(), -4);
83 
84         for (size_t i = 0; i < l.size(); ++i)
85         {
86             CHECK_EQUAL((index_t)i - 4, l.front());
87             l.pop_front();
88         }
89 
90     }
91 }
92 
93 TEST(stoi)
94 {
95     // based on CXX11+ std::stoi(str) <=> std::stoi(str, 0, 10);
96     CHECK_EQUAL(1, util::stoi("0001"));
97     CHECK_EQUAL(1234567890, util::stoi("1234567890"));
98     CHECK_EQUAL(-1, util::stoi("-0001"));
99     CHECK_EQUAL(-1234567890, util::stoi("-1234567890"));
100     CHECK_EQUAL(42, util::stoi("42"));
101     CHECK_EQUAL(42, util::stoi(" 42"));
102     CHECK_EQUAL(42, util::stoi("42 "));
103     CHECK_EQUAL(42, util::stoi(" 42 "));
104     CHECK_EQUAL(4, util::stoi(" 4 2 "));
105 
106     CHECK_THROW(util::stoi("a1"), std::invalid_argument);
107     CHECK_EQUAL(1, util::stoi("1a"));
108     CHECK_EQUAL(0, util::stoi("0x42"));
109 }
110 
111 TEST(stod)
112 {
113     CHECK_EQUAL(0.1, util::stod(".1"));
114     CHECK_EQUAL(1.1, util::stod("0001.1000"));
115     CHECK_EQUAL(1234567890., util::stod("1234567890"));
116     CHECK_EQUAL(1234567890.123456789, util::stod("1234567890.123456789"));
117     CHECK_EQUAL(-1234567890.123456789, util::stod(" -1234567890.123456789 "));
118     CHECK_EQUAL(4.2, util::stod("4.2"));
119     CHECK_EQUAL(4.2, util::stod(" 4.2"));
120     CHECK_EQUAL(4.2, util::stod("4.2 "));
121     CHECK_EQUAL(4.2, util::stod(" 4.2 "));
122     CHECK_EQUAL(4., util::stod(" 4 2 "));
123 
124     CHECK_THROW(util::stod("a0.5"), std::invalid_argument);
125     CHECK_EQUAL(0.4, util::stod("0.4")); //Note: util::stod("0.4a") fails on C98
126 #if !defined(_MSC_VER) || _MSC_VER >= 1900
127     CHECK_EQUAL(-255.99609375, util::stod("-0xFF.FF"));
128     CHECK_EQUAL(-255.99609375, util::stod("-0XFF.FF"));
129     CHECK_EQUAL(-255.99609375, util::stod("-0xff.ff"));
130     CHECK_EQUAL(-255.99609375, util::stod("-0Xff.ff"));
131 #endif
132 }
133 
134 TEST(string_replace)
135 {
136     std::string s0 = "abcdefghijk";
137     util::string_replace(s0, "abc", "xxx");
138     CHECK_EQUAL("xxxdefghijk", s0);
139 
140     util::string_replace(s0, "ijk", "yyy");
141     CHECK_EQUAL("xxxdefghyyy", s0);
142 
143     util::string_replace(s0, "efg", "zzz");
144     CHECK_EQUAL("xxxdzzzhyyy", s0);
145 
146     util::string_replace(s0, "xxx", "x");
147     util::string_replace(s0, "yyy", "y");
148     util::string_replace(s0, "zzz", "z");
149 
150     CHECK_EQUAL("xdzhy", s0);
151 
152     util::string_replace(s0, "x", "abc");
153     util::string_replace(s0, "y", "ijk");
154     util::string_replace(s0, "z", "efg");
155 
156     CHECK_EQUAL("abcdefghijk", s0);
157 }
158 
159 TEST(tokenize)
160 {
161     std::string s0("ab,ba,aa,bb");
162     CHECK_EQUAL("ab", util::tokenize(s0, ",", 0));
163     CHECK_EQUAL("ba", util::tokenize(s0, ",", 1));
164     CHECK_EQUAL("aa", util::tokenize(s0, ",", 2));
165     CHECK_EQUAL("bb", util::tokenize(s0, ",", 3));
166     CHECK_THROW(util::tokenize(s0, ",", 4), std::runtime_error);
167     CHECK_EQUAL("ab,ba,aa,bb", s0);
168 
169     std::string s1("ab..ba");
170     CHECK_EQUAL("ab", util::tokenize(s1, ".", 0));
171     CHECK_EQUAL("ba", util::tokenize(s1, ".", 1));
172     CHECK_THROW(util::tokenize(s1, ".", 2), std::runtime_error);
173 
174     // ab ... ba
175     //    ^^^
176     std::string s2("ab...ba");
177     CHECK_EQUAL("ab", util::tokenize(s2, "..", 0));
178     CHECK_EQUAL("ba", util::tokenize(s2, "..", 1));
179     CHECK_THROW(util::tokenize(s2, "..", 2), std::runtime_error);
180 
181     // xxx ab c ba zzz
182     //     ^^   ^^
183     std::string s3("xxxabcbazzz");
184     CHECK_EQUAL("xxx", util::tokenize(s3, "ab", 0));
185     CHECK_EQUAL("c", util::tokenize(s3, "ab", 1));
186     CHECK_EQUAL("zzz", util::tokenize(s3, "ab", 2));
187     CHECK_THROW(util::tokenize(s3, "ab", 3), std::runtime_error);
188 
189     /// xxx abbab zzz
190     ///     ^^^^^
191     std::string s4("xxxabbabzzz");
192     CHECK_EQUAL("xxx", util::tokenize(s4, "ab", 0));
193     CHECK_EQUAL("zzz", util::tokenize(s4, "ab", 1));
194     CHECK_THROW(util::tokenize(s4, "ab", 3), std::runtime_error);
195 
196     /// xxx aba b aba zzz
197     std::string s5("xxxabababazzz");
198     CHECK_EQUAL("xxx", util::tokenize(s5, "aba", 0));
199     CHECK_EQUAL("zzz", util::tokenize(s5, "aba", 1));
200     CHECK_THROW(util::tokenize(s5, "aba", 2), std::runtime_error);
201 }
202 
203 TEST(capitalize)
204 {
205     std::string s0("abc");
206     util::capitalize(s0);
207     CHECK_EQUAL("Abc", s0);
208 
209     s0 = "Abc";
210     util::capitalize(s0);
211     CHECK_EQUAL("Abc", s0);
212 
213     s0 = "aBc";
214     util::capitalize(s0);
215     CHECK_EQUAL("ABc", s0);
216 
217     s0 = "abC";
218     util::capitalize(s0);
219     CHECK_EQUAL("AbC", s0);
220 
221     s0 = "AbC";
222     util::capitalize(s0);
223     CHECK_EQUAL("AbC", s0);
224 
225     s0 = "ABc";
226     util::capitalize(s0);
227     CHECK_EQUAL("ABc", s0);
228 
229     s0 = "aBC";
230     util::capitalize(s0);
231     CHECK_EQUAL("ABC", s0);
232 
233     s0 = "ABC";
234     util::capitalize(s0);
235     CHECK_EQUAL("ABC", s0);
236 
237     s0 = "def";
238     util::capitalize(s0);
239     CHECK_EQUAL("Def", s0);
240 }
241 
242 TEST(returnCapitalized)
243 {
244     std::string s0("abc");
245     CHECK_EQUAL("Abc", util::returnCapitalized(s0));
246 
247     s0 = "Abc";
248     CHECK_EQUAL("Abc", util::returnCapitalized(s0));
249 
250     s0 = "aBc";
251     CHECK_EQUAL("ABc", util::returnCapitalized(s0));
252 
253     s0 = "abC";
254     CHECK_EQUAL("AbC", util::returnCapitalized(s0));
255 
256     s0 = "AbC";
257     CHECK_EQUAL("AbC", util::returnCapitalized(s0));
258 
259     s0 = "ABc";
260     CHECK_EQUAL("ABc", util::returnCapitalized(s0));
261 
262     s0 = "aBC";
263     CHECK_EQUAL("ABC", util::returnCapitalized(s0));
264 
265     s0 = "ABC";
266     CHECK_EQUAL("ABC", util::returnCapitalized(s0));
267 
268     s0 = "def";
269     CHECK_EQUAL("Def", util::returnCapitalized(s0));
270 }
271 
272 TEST(name)
273 {
274     // Fundamental types
275     CHECK_EQUAL("bool", util::type<bool>::name());
276     CHECK_EQUAL("signed char", util::type<signed char>::name());
277     CHECK_EQUAL("unsigned char", util::type<unsigned char>::name());
278     CHECK_EQUAL("char", util::type<char>::name());
279     CHECK_EQUAL("short", util::type<signed short>::name());
280     CHECK_EQUAL("short", util::type<signed short>::name());
281     CHECK_EQUAL("unsigned short", util::type<unsigned short int>::name());
282     CHECK_EQUAL("int", util::type<signed int>::name());
283     CHECK_EQUAL("unsigned int", util::type<unsigned>::name());
284     CHECK_EQUAL("long", util::type<long>::name());
285     CHECK_EQUAL("unsigned long", util::type<unsigned long>::name());
286 #ifndef _WIN32
287     CHECK_EQUAL("long long", util::type<signed long long int>::name());
288     CHECK_EQUAL("unsigned long long", util::type<unsigned long long int>::name());
289     //CHECK_EQUAL("gismo::gsGenericGeometry<(" + util::type<short_t>::name() + ")2, " + util::type<real_t>::name() + ">", util::type<gsGenericGeometry<2> >::name());
290 #else
291     CHECK_EQUAL("__int64", util::type<signed long long int>::name());
292     CHECK_EQUAL("unsigned __int64", util::type<unsigned long long int>::name());
293     CHECK_EQUAL("class gismo::gsGenericGeometry<2," + util::type<real_t>::name() + ">",
294         util::type<gsGenericGeometry<2> >::name());
295 #endif
296 }
297 }
298