1 /************************************************************************************
2 *                                                                                   *
3 *   Copyright (c) 2014 - 2018 Axel Menzel <info@rttr.org>                           *
4 *                                                                                   *
5 *   This file is part of RTTR (Run Time Type Reflection)                            *
6 *   License: MIT License                                                            *
7 *                                                                                   *
8 *   Permission is hereby granted, free of charge, to any person obtaining           *
9 *   a copy of this software and associated documentation files (the "Software"),    *
10 *   to deal in the Software without restriction, including without limitation       *
11 *   the rights to use, copy, modify, merge, publish, distribute, sublicense,        *
12 *   and/or sell copies of the Software, and to permit persons to whom the           *
13 *   Software is furnished to do so, subject to the following conditions:            *
14 *                                                                                   *
15 *   The above copyright notice and this permission notice shall be included in      *
16 *   all copies or substantial portions of the Software.                             *
17 *                                                                                   *
18 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR      *
19 *   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,        *
20 *   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE     *
21 *   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER          *
22 *   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,   *
23 *   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE   *
24 *   SOFTWARE.                                                                       *
25 *                                                                                   *
26 *************************************************************************************/
27 
28 #include "unit_tests/variant/test_enums.h"
29 
30 #include <catch/catch.hpp>
31 #include <rttr/type>
32 
33 using namespace rttr;
34 
35 /////////////////////////////////////////////////////////////////////////////////////////
36 
37 TEST_CASE("variant::to_uint64() - from empty", "[variant]")
38 {
39     variant var;
40     bool ok = false;
41     CHECK(var.to_uint64(&ok) == 0);
42     CHECK(ok == false);
43 }
44 
45 /////////////////////////////////////////////////////////////////////////////////////////
46 
47 TEST_CASE("variant::to_uint64() - from bool", "[variant]")
48 {
49     variant var = true;
50     REQUIRE(var.is_valid() == true);
51     REQUIRE(var.can_convert<uint64_t>() == true);
52 
53     // true case
54     bool ok = false;
55     CHECK(var.to_uint64(&ok) == 1);
56     CHECK(ok == true);
57 
58     CHECK(var.convert<uint64_t>(&ok) == 1);
59     CHECK(ok == true);
60     REQUIRE(var.convert(type::get<uint64_t>()) == true);
61     CHECK(var.get_value<uint64_t>() == 1);
62 
63     // false case
64     var = false;
65     CHECK(var.to_uint64(&ok) == 0);
66     CHECK(ok == true);
67 
68     CHECK(var.convert<uint64_t>(&ok) == 0);
69     CHECK(ok == true);
70     REQUIRE(var.convert(type::get<uint64_t>()) == true);
71     CHECK(var.get_value<uint64_t>() == 0);
72 }
73 
74 /////////////////////////////////////////////////////////////////////////////////////////
75 
76 TEST_CASE("variant::to_uint64() - from char", "[variant]")
77 {
78     SECTION("valid conversion")
79     {
80         variant var = char('A');
81         REQUIRE(var.can_convert<uint64_t>() == true);
82         bool ok = false;
83         CHECK(var.to_uint64(&ok) == 65);
84         CHECK(ok == true);
85 
86         REQUIRE(var.convert(type::get<uint64_t>()) == true);
87         CHECK(var.get_value<uint64_t>() == 65);
88     }
89 
90 RTTR_BEGIN_DISABLE_CONDITIONAL_EXPR_WARNING
91 
92     if (std::numeric_limits<char>::is_signed)
93     {
94         SECTION("invalid conversion negative")
95         {
96             variant var = char(-60);
97             bool ok = false;
98             CHECK(var.to_uint64(&ok) == 0);
99             CHECK(ok == false);
100             CHECK(var.convert(type::get<uint64_t>()) == false);
101         }
102     }
103 
104 RTTR_END_DISABLE_CONDITIONAL_EXPR_WARNING
105 
106 }
107 
108 /////////////////////////////////////////////////////////////////////////////////////////
109 
110 TEST_CASE("variant::to_uint64() - from std::string", "[variant]")
111 {
112     SECTION("valid conversion positive")
113     {
114         variant var = std::string("17446744073709551615");
115         REQUIRE(var.can_convert<uint64_t>() == true);
116         bool ok = false;
117 
118         CHECK(var.to_uint64(&ok) == 17446744073709551615UL);
119         CHECK(ok == true);
120 
121         REQUIRE(var.convert(type::get<uint64_t>()) == true);
122         CHECK(var.get_value<uint64_t>() == 17446744073709551615UL);
123     }
124 
125     SECTION("invalid conversion negative")
126     {
127         variant var = std::string("-2147483640");
128         bool ok = false;
129         CHECK(var.to_uint64(&ok) == 0);
130         CHECK(ok == false);
131         CHECK(var.convert(type::get<uint64_t>()) == false);
132     }
133 
134     SECTION("too big")
135     {
136         variant var = std::string("20446744073709551615");
137         bool ok = false;
138         CHECK(var.to_uint64(&ok) == 0);
139         CHECK(ok == false);
140         CHECK(var.convert(type::get<uint64_t>()) == false);
141     }
142 
143     SECTION("invalid conversion")
144     {
145         variant var = std::string("text 34 and text");
146         bool ok = false;
147         CHECK(var.to_uint64(&ok) == 0);
148         CHECK(ok == false);
149         CHECK(var.convert(type::get<uint64_t>()) == false);
150 
151         var = std::string("34 and text");
152         ok = false;
153         CHECK(var.to_uint64(&ok) == 0);
154         CHECK(ok == false);
155         CHECK(var.convert(type::get<uint64_t>()) == false);
156     }
157 }
158 
159 /////////////////////////////////////////////////////////////////////////////////////////
160 
161 TEST_CASE("variant::to_uint64() - from int", "[variant]")
162 {
163     SECTION("valid conversion positive")
164     {
165         variant var = 50;
166         REQUIRE(var.can_convert<uint64_t>() == true);
167         bool ok = false;
168         CHECK(var.to_uint64(&ok) == 50);
169         CHECK(ok == true);
170 
171         REQUIRE(var.convert(type::get<uint64_t>()) == true);
172         CHECK(var.get_value<uint64_t>() == 50);
173     }
174 
175     SECTION("invalid conversion negative")
176     {
177         variant var = -60;
178         bool ok = false;
179         CHECK(var.to_uint64(&ok) == 0);
180         CHECK(ok == false);
181         CHECK(var.convert(type::get<uint64_t>()) == false);
182     }
183 }
184 
185 /////////////////////////////////////////////////////////////////////////////////////////
186 
187 TEST_CASE("variant::to_uint64() - from float", "[variant]")
188 {
189     SECTION("valid conversion positive")
190     {
191         variant var = 214748.9f;
192         REQUIRE(var.can_convert<uint64_t>() == true);
193         bool ok = false;
194         CHECK(var.to_uint64(&ok) == 214748);
195         CHECK(ok == true);
196 
197         REQUIRE(var.convert(type::get<uint64_t>()) == true);
198         CHECK(var.get_value<uint64_t>() == 214748);
199     }
200 
201     SECTION("invalid conversion negative")
202     {
203         variant var = -21.9f;
204         bool ok = false;
205         CHECK(var.to_uint64(&ok) == 0);
206         CHECK(ok == false);
207         CHECK(var.convert(type::get<uint64_t>()) == false);
208     }
209 
210     SECTION("too big")
211     {
212         variant var = 3.40282e+37f;
213         bool ok = false;
214         CHECK(var.to_uint64(&ok) == 0);
215         CHECK(ok == false);
216         CHECK(var.convert(type::get<uint64_t>()) == false);
217     }
218 }
219 
220 /////////////////////////////////////////////////////////////////////////////////////////
221 
222 TEST_CASE("variant::to_uint64() - from double", "[variant]")
223 {
224     SECTION("valid conversion positive")
225     {
226         variant var = 174407329551615.9;
227         REQUIRE(var.can_convert<uint64_t>() == true);
228         bool ok = false;
229         CHECK(var.to_uint64(&ok) == 174407329551615u);
230 
231         CHECK(ok == true);
232         REQUIRE(var.convert(type::get<uint64_t>()) == true);
233         CHECK(var.get_value<uint64_t>() == 174407329551615u);
234     }
235 
236     SECTION("invalid conversion negative")
237     {
238         variant var = -21.9;
239         bool ok = false;
240         CHECK(var.to_uint64(&ok) == 0);
241         CHECK(ok == false);
242         CHECK(var.convert(type::get<uint64_t>()) == false);
243     }
244 
245     SECTION("too big")
246     {
247         variant var = 19446744073709551615.2;
248         bool ok = false;
249         CHECK(var.to_uint64(&ok) == 0);
250         CHECK(ok == false);
251         REQUIRE(var.convert(type::get<uint64_t>()) == false);
252         CHECK(var.get_value<double>() == 19446744073709551615.2);
253     }
254 }
255 
256 /////////////////////////////////////////////////////////////////////////////////////////
257 
258 TEST_CASE("variant::to_uint64() - from int8_t", "[variant]")
259 {
260     SECTION("valid conversion positive")
261     {
262         variant var = int8_t(50);
263         REQUIRE(var.can_convert<uint64_t>() == true);
264         bool ok = false;
265         CHECK(var.to_uint64(&ok) == uint64_t(50));
266         CHECK(ok == true);
267 
268         REQUIRE(var.convert(type::get<uint64_t>()) == true);
269         CHECK(var.get_value<uint64_t>() == 50);
270     }
271 
272     SECTION("invalid conversion negative")
273     {
274         variant var = int8_t(-60);
275         bool ok = false;
276         CHECK(var.to_uint64(&ok) == 0);
277         CHECK(ok == false);
278         CHECK(var.convert(type::get<uint64_t>()) == false);
279     }
280 }
281 
282 /////////////////////////////////////////////////////////////////////////////////////////
283 
284 TEST_CASE("variant::to_uint64() - from int16_t", "[variant]")
285 {
286     SECTION("valid conversion positive")
287     {
288         variant var = int16_t(50);
289         REQUIRE(var.can_convert<uint64_t>() == true);
290         bool ok = false;
291         CHECK(var.to_uint64(&ok) == uint64_t(50));
292         CHECK(ok == true);
293 
294         REQUIRE(var.convert(type::get<uint64_t>()) == true);
295         CHECK(var.get_value<uint64_t>() == uint64_t(50));
296     }
297 
298     SECTION("invalid conversion negative")
299     {
300         variant var = int16_t(-60);
301         bool ok = false;
302         CHECK(var.to_uint64(&ok) == 0);
303         CHECK(ok == false);
304         CHECK(var.convert(type::get<uint64_t>()) == false);
305     }
306 }
307 
308 /////////////////////////////////////////////////////////////////////////////////////////
309 
310 TEST_CASE("variant::to_uint64() - from int32_t", "[variant]")
311 {
312     SECTION("valid conversion positive")
313     {
314         variant var = int32_t(50);
315         REQUIRE(var.can_convert<uint64_t>() == true);
316         bool ok = false;
317         CHECK(var.to_uint64(&ok) == uint64_t(50));
318         CHECK(ok == true);
319 
320         REQUIRE(var.convert(type::get<uint64_t>()) == true);
321         CHECK(var.get_value<uint64_t>() == uint64_t(50));
322     }
323 
324     SECTION("invalid conversion negative")
325     {
326         variant var = int32_t(-60);
327         bool ok = false;
328         CHECK(var.to_uint64(&ok) == 0);
329         CHECK(ok == false);
330         CHECK(var.convert(type::get<uint64_t>()) == false);
331     }
332 }
333 
334 /////////////////////////////////////////////////////////////////////////////////////////
335 
336 TEST_CASE("variant::to_uint64() - from int64_t", "[variant]")
337 {
338     SECTION("valid conversion positive")
339     {
340         variant var = int64_t(50);
341         REQUIRE(var.can_convert<uint64_t>() == true);
342         bool ok = false;
343         CHECK(var.to_uint64(&ok) == uint64_t(50));
344         CHECK(ok == true);
345 
346         REQUIRE(var.convert(type::get<uint64_t>()) == true);
347         CHECK(var.get_value<uint64_t>() == uint64_t(50));
348     }
349 
350     SECTION("invalid conversion negative")
351     {
352         variant var = int64_t(-60);
353         bool ok = false;
354         CHECK(var.to_uint64(&ok) == 0);
355         CHECK(ok == false);
356         CHECK(var.convert(type::get<uint64_t>()) == false);
357     }
358 }
359 
360 /////////////////////////////////////////////////////////////////////////////////////////
361 
362 TEST_CASE("variant::to_uint64() - from uint8_t", "[variant]")
363 {
364     SECTION("valid conversion positive")
365     {
366         variant var = uint8_t(50);
367         REQUIRE(var.can_convert<uint64_t>() == true);
368         bool ok = false;
369         CHECK(var.to_uint64(&ok) == 50);
370         CHECK(ok == true);
371 
372         REQUIRE(var.convert(type::get<uint64_t>()) == true);
373         CHECK(var.get_value<uint64_t>() == 50);
374     }
375 }
376 
377 /////////////////////////////////////////////////////////////////////////////////////////
378 
379 TEST_CASE("variant::to_uint64() - from uint16_t", "[variant]")
380 {
381     SECTION("valid conversion positive")
382     {
383         variant var = uint16_t(50);
384         REQUIRE(var.can_convert<uint64_t>() == true);
385         bool ok = false;
386         CHECK(var.to_uint64(&ok) == 50);
387         CHECK(ok == true);
388 
389         REQUIRE(var.convert(type::get<uint64_t>()) == true);
390         CHECK(var.get_value<uint64_t>() == 50);
391     }
392 }
393 
394 /////////////////////////////////////////////////////////////////////////////////////////
395 
396 TEST_CASE("variant::to_uint64() - from uint32_t", "[variant]")
397 {
398     SECTION("valid conversion positive")
399     {
400         variant var = uint32_t(50);
401         REQUIRE(var.can_convert<uint64_t>() == true);
402         bool ok = false;
403         CHECK(var.to_uint64(&ok) == 50);
404         CHECK(ok == true);
405 
406         REQUIRE(var.convert(type::get<uint64_t>()) == true);
407         CHECK(var.get_value<uint64_t>() == 50);
408     }
409 }
410 
411 /////////////////////////////////////////////////////////////////////////////////////////
412 
413 TEST_CASE("variant::to_uint64() - from uint64_t", "[variant]")
414 {
415     SECTION("valid conversion positive")
416     {
417         variant var = uint64_t(3147483640);
418         REQUIRE(var.can_convert<uint64_t>() == true);
419         bool ok = false;
420         CHECK(var.to_uint64(&ok) == 3147483640u);
421         CHECK(ok == true);
422 
423         REQUIRE(var.convert(type::get<uint64_t>()) == true);
424         CHECK(var.get_value<uint64_t>() == 3147483640u);
425     }
426 }
427 
428 /////////////////////////////////////////////////////////////////////////////////////////
429 
430 TEST_CASE("variant::to_uint64() - from enum", "[variant]")
431 {
432     SECTION("valid conversion positive")
433     {
434         variant var = enum_uint64_t::VALUE_1;
435         REQUIRE(var.can_convert<uint64_t>() == true);
436         bool ok = false;
437         CHECK(var.to_uint64(&ok) == 17446744073709551615U);
438         CHECK(ok == true);
439 
440         REQUIRE(var.convert(type::get<uint64_t>()) == true);
441         CHECK(var.get_value<uint64_t>() == 17446744073709551615U);
442     }
443 
444     SECTION("too small")
445     {
446         variant var = enum_int8_t::VALUE_NEG;
447         bool ok = false;
448         CHECK(var.to_uint64(&ok) == 0);
449         CHECK(ok == false);
450         CHECK(var.convert(type::get<uint64_t>()) == false);
451     }
452 }
453 
454 /////////////////////////////////////////////////////////////////////////////////////////
455