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_int64() - from empty", "[variant]")
38 {
39     variant var;
40     bool ok = false;
41     CHECK(var.to_int64(&ok) == 0);
42     CHECK(ok == false);
43 }
44 
45 /////////////////////////////////////////////////////////////////////////////////////////
46 
47 TEST_CASE("variant::to_int64() - from bool", "[variant]")
48 {
49     variant var = true;
50     REQUIRE(var.is_valid() == true);
51     REQUIRE(var.can_convert<int64_t>() == true);
52 
53     // true case
54     bool ok = false;
55     CHECK(var.to_int64(&ok) == 1);
56     CHECK(ok == true);
57 
58     CHECK(var.convert<int64_t>(&ok) == 1);
59     CHECK(ok == true);
60     REQUIRE(var.convert(type::get<int64_t>()) == true);
61     CHECK(var.get_value<int64_t>() == 1);
62 
63     // false case
64     var = false;
65     CHECK(var.to_int64(&ok) == 0);
66     CHECK(ok == true);
67 
68     CHECK(var.convert<int64_t>(&ok) == 0);
69     CHECK(ok == true);
70     REQUIRE(var.convert(type::get<int64_t>()) == true);
71     CHECK(var.get_value<int64_t>() == 0);
72 }
73 
74 /////////////////////////////////////////////////////////////////////////////////////////
75 
76 TEST_CASE("variant::to_int64() - from char", "[variant]")
77 {
78     SECTION("valid conversion")
79     {
80         variant var = char('A');
81         REQUIRE(var.can_convert<int64_t>() == true);
82         bool ok = false;
83         CHECK(var.to_int64(&ok) == 65);
84         CHECK(ok == true);
85 
86         REQUIRE(var.convert(type::get<int64_t>()) == true);
87         CHECK(var.get_value<int64_t>() == 65);
88     }
89 
90 RTTR_BEGIN_DISABLE_CONDITIONAL_EXPR_WARNING
91 
92     if (std::numeric_limits<char>::is_signed)
93     {
94         SECTION("valid conversion negative")
95         {
96             variant var = char(-60);
97             bool ok = false;
98             CHECK(var.to_int64(&ok) == -60);
99             CHECK(ok == true);
100             CHECK(var.convert(type::get<int64_t>()) == true);
101         }
102     }
103 
104 RTTR_END_DISABLE_CONDITIONAL_EXPR_WARNING
105 
106 }
107 
108 /////////////////////////////////////////////////////////////////////////////////////////
109 
110 TEST_CASE("variant::to_int64() - from std::string", "[variant]")
111 {
112     SECTION("valid conversion positive")
113     {
114         variant var = std::string("5000000000");
115         REQUIRE(var.can_convert<int64_t>() == true);
116         bool ok = false;
117         CHECK(var.to_int64(&ok) == 5000000000);
118         CHECK(ok == true);
119 
120         REQUIRE(var.convert(type::get<int64_t>()) == true);
121         CHECK(var.get_value<int64_t>() == 5000000000);
122     }
123 
124     SECTION("valid conversion negative")
125     {
126         variant var = std::string("-5000000000");
127         bool ok = false;
128         CHECK(var.to_int64(&ok) == -5000000000);
129         CHECK(ok == true);
130         CHECK(var.convert(type::get<int64_t>()) == true);
131     }
132 
133     SECTION("too big")
134     {
135         variant var = std::string("10000000000000000000");
136         bool ok = false;
137         CHECK(var.to_int64(&ok) == 0);
138         CHECK(ok == false);
139         CHECK(var.convert(type::get<int64_t>()) == false);
140     }
141 
142     SECTION("too small")
143     {
144         variant var = std::string("-10000000000000000000");
145         bool ok = false;
146         CHECK(var.to_int64(&ok) == 0);
147         CHECK(ok == false);
148         CHECK(var.convert(type::get<int64_t>()) == false);
149     }
150 
151     SECTION("invalid conversion")
152     {
153         variant var = std::string("text 34 and text");
154         bool ok = false;
155         CHECK(var.to_int64(&ok) == 0);
156         CHECK(ok == false);
157         CHECK(var.convert(type::get<int64_t>()) == false);
158 
159         var = std::string("34 and text");
160         ok = false;
161         CHECK(var.to_int64(&ok) == 0);
162         CHECK(ok == false);
163         CHECK(var.convert(type::get<int64_t>()) == false);
164     }
165 }
166 
167 /////////////////////////////////////////////////////////////////////////////////////////
168 
169 TEST_CASE("variant::to_int64() - from int", "[variant]")
170 {
171     SECTION("valid conversion positive")
172     {
173         variant var = 2147483640;
174         REQUIRE(var.can_convert<int64_t>() == true);
175         bool ok = false;
176         CHECK(var.to_int64(&ok) == 2147483640);
177 
178         CHECK(ok == true);
179         REQUIRE(var.convert(type::get<int64_t>()) == true);
180         CHECK(var.get_value<int64_t>() == 2147483640);
181     }
182 
183     SECTION("valid conversion negative")
184     {
185         variant var = -2147483640;
186         bool ok = false;
187         CHECK(var.to_int64(&ok) == -2147483640);
188         CHECK(ok == true);
189         CHECK(var.convert(type::get<int64_t>()) == true);
190     }
191 }
192 
193 /////////////////////////////////////////////////////////////////////////////////////////
194 
195 TEST_CASE("variant::to_int64() - from float", "[variant]")
196 {
197     SECTION("valid conversion positive")
198     {
199         variant var = 214748.9f;
200         REQUIRE(var.can_convert<int64_t>() == true);
201         bool ok = false;
202         CHECK(var.to_int64(&ok) == 214748);
203         CHECK(ok == true);
204 
205         REQUIRE(var.convert(type::get<int64_t>()) == true);
206         CHECK(var.get_value<int64_t>() == 214748);
207     }
208 
209     SECTION("valid conversion negative")
210     {
211         variant var = -214748.9f;
212         bool ok = false;
213         CHECK(var.to_int64(&ok) == -214748);
214         CHECK(ok == true);
215         CHECK(var.convert(type::get<int64_t>()) == true);
216     }
217 
218     SECTION("too big")
219     {
220         variant var = 3.40282e+37f;
221         bool ok = false;
222         CHECK(var.to_int64(&ok) == 0);
223         CHECK(ok == false);
224         CHECK(var.convert(type::get<int64_t>()) == false);
225     }
226 
227     SECTION("too small")
228     {
229         variant var = -3.40282e+37f;
230         bool ok = false;
231         CHECK(var.to_int64(&ok) == 0);
232         CHECK(ok == false);
233         CHECK(var.convert(type::get<int64_t>()) == false);
234     }
235 }
236 
237 /////////////////////////////////////////////////////////////////////////////////////////
238 
239 TEST_CASE("variant::to_int64() - from double", "[variant]")
240 {
241     SECTION("valid conversion positive")
242     {
243         variant var = 5000000000.9;
244         REQUIRE(var.can_convert<int64_t>() == true);
245         bool ok = false;
246         CHECK(var.to_int64(&ok) == 5000000000);
247         CHECK(ok == true);
248 
249         REQUIRE(var.convert(type::get<int64_t>()) == true);
250         CHECK(var.get_value<int64_t>() == 5000000000);
251     }
252 
253     SECTION("valid conversion negative")
254     {
255         variant var = -5000000000.9;
256         bool ok = false;
257         CHECK(var.to_int64(&ok) == -5000000000);
258         CHECK(ok == true);
259         CHECK(var.convert(type::get<int64_t>()) == true);
260     }
261 
262     SECTION("too big")
263     {
264         variant var = 10000000000000000000.2;
265         bool ok = false;
266         CHECK(var.to_int64(&ok) == 0);
267         CHECK(ok == false);
268         CHECK(var.convert(type::get<int64_t>()) == false);
269     }
270 
271     SECTION("too small")
272     {
273         variant var = -10000000000000000000.2;
274         bool ok = false;
275         CHECK(var.to_int64(&ok) == 0);
276         CHECK(ok == false);
277         CHECK(var.convert(type::get<int64_t>()) == false);
278     }
279 }
280 
281 /////////////////////////////////////////////////////////////////////////////////////////
282 
283 TEST_CASE("variant::to_int64() - from int8_t", "[variant]")
284 {
285     SECTION("valid conversion positive")
286     {
287         variant var = int8_t(50);
288         REQUIRE(var.can_convert<int64_t>() == true);
289         bool ok = false;
290         CHECK(var.to_int64(&ok) == 50);
291         CHECK(ok == true);
292 
293         REQUIRE(var.convert(type::get<int64_t>()) == true);
294         CHECK(var.get_value<int64_t>() == 50);
295     }
296 
297     SECTION("valid conversion negative")
298     {
299         variant var = int8_t(-60);
300         bool ok = false;
301         CHECK(var.to_int64(&ok) == int64_t(-60));
302         CHECK(ok == true);
303         CHECK(var.convert(type::get<int64_t>()) == true);
304     }
305 }
306 
307 /////////////////////////////////////////////////////////////////////////////////////////
308 
309 TEST_CASE("variant::to_int64() - from int16_t", "[variant]")
310 {
311     SECTION("valid conversion positive")
312     {
313         variant var = int16_t(32760);
314         REQUIRE(var.can_convert<int64_t>() == true);
315         bool ok = false;
316         CHECK(var.to_int64(&ok) == int64_t(32760));
317         CHECK(ok == true);
318 
319         REQUIRE(var.convert(type::get<int64_t>()) == true);
320         CHECK(var.get_value<int64_t>() == int64_t(32760));
321     }
322 
323     SECTION("valid conversion negative")
324     {
325         variant var = int16_t(-32760);
326         bool ok = false;
327         CHECK(var.to_int64(&ok) == int64_t(-32760));
328         CHECK(ok == true);
329         CHECK(var.convert(type::get<int64_t>()) == true);
330     }
331 }
332 
333 /////////////////////////////////////////////////////////////////////////////////////////
334 
335 TEST_CASE("variant::to_int64() - from int32_t", "[variant]")
336 {
337     SECTION("valid conversion positive")
338     {
339         variant var = int32_t(2147483640);
340         REQUIRE(var.can_convert<int64_t>() == true);
341         bool ok = false;
342         CHECK(var.to_int64(&ok) == int64_t(2147483640));
343         CHECK(ok == true);
344 
345         REQUIRE(var.convert(type::get<int64_t>()) == true);
346         CHECK(var.get_value<int64_t>() == int64_t(2147483640));
347     }
348 
349     SECTION("valid conversion negative")
350     {
351         variant var = int32_t(-2147483640);
352         bool ok = false;
353         CHECK(var.to_int64(&ok) == int64_t(-2147483640));
354         CHECK(ok == true);
355         CHECK(var.convert(type::get<int64_t>()) == true);
356     }
357 }
358 
359 /////////////////////////////////////////////////////////////////////////////////////////
360 
361 TEST_CASE("variant::to_int64() - from int64_t", "[variant]")
362 {
363     SECTION("valid conversion positive")
364     {
365         variant var = int64_t(5000000000L);
366         REQUIRE(var.can_convert<int64_t>() == true);
367         bool ok = false;
368         CHECK(var.to_int64(&ok) == int64_t(5000000000L));
369         CHECK(ok == true);
370 
371         REQUIRE(var.convert(type::get<int64_t>()) == true);
372         CHECK(var.get_value<int64_t>() == int64_t(5000000000L));
373     }
374 
375     SECTION("valid conversion negative")
376     {
377         variant var = int64_t(-5000000000L);
378         bool ok = false;
379         CHECK(var.to_int64(&ok) == int64_t(-5000000000L));
380         CHECK(ok == true);
381         CHECK(var.convert(type::get<int64_t>()) == true);
382     }
383 }
384 
385 /////////////////////////////////////////////////////////////////////////////////////////
386 
387 TEST_CASE("variant::to_int64() - from uint8_t", "[variant]")
388 {
389     SECTION("valid conversion positive")
390     {
391         variant var = uint8_t(50);
392         REQUIRE(var.can_convert<uint8_t>() == true);
393         bool ok = false;
394         CHECK(var.to_int64(&ok) == 50);
395         CHECK(ok == true);
396 
397         REQUIRE(var.convert(type::get<int64_t>()) == true);
398         CHECK(var.get_value<int64_t>() == int64_t(50));
399     }
400 }
401 
402 /////////////////////////////////////////////////////////////////////////////////////////
403 
404 TEST_CASE("variant::to_int64() - from uint16_t", "[variant]")
405 {
406     SECTION("valid conversion positive")
407     {
408         variant var = uint16_t(32760);
409         REQUIRE(var.can_convert<uint16_t>() == true);
410         bool ok = false;
411         CHECK(var.to_int64(&ok) == int64_t(32760));
412         CHECK(ok == true);
413 
414         REQUIRE(var.convert(type::get<int64_t>()) == true);
415         CHECK(var.get_value<int64_t>() == int64_t(32760));
416     }
417 }
418 
419 /////////////////////////////////////////////////////////////////////////////////////////
420 
421 TEST_CASE("variant::to_int64() - from uint32_t", "[variant]")
422 {
423     SECTION("valid conversion positive")
424     {
425         variant var = uint32_t(32760);
426         REQUIRE(var.can_convert<uint32_t>() == true);
427         bool ok = false;
428         CHECK(var.to_int64(&ok) == int64_t(32760));
429         CHECK(ok == true);
430 
431         REQUIRE(var.convert(type::get<int64_t>()) == true);
432         CHECK(var.get_value<int64_t>() == int64_t(32760));
433     }
434 }
435 
436 /////////////////////////////////////////////////////////////////////////////////////////
437 
438 TEST_CASE("variant::to_int64() - from uint64_t", "[variant]")
439 {
440     SECTION("valid conversion positive")
441     {
442         variant var = uint64_t(2147483640);
443         REQUIRE(var.can_convert<uint64_t>() == true);
444         bool ok = false;
445         CHECK(var.to_int64(&ok) == int64_t(2147483640));
446         CHECK(ok == true);
447 
448         REQUIRE(var.convert(type::get<int64_t>()) == true);
449         CHECK(var.get_value<int64_t>() == int64_t(2147483640));
450     }
451 
452     SECTION("too big")
453     {
454         variant var = uint64_t(10000000000000000000UL);
455         bool ok = false;
456         CHECK(var.to_int64(&ok) == 0);
457         CHECK(ok == false);
458         REQUIRE(var.convert(type::get<int64_t>()) == false);
459         CHECK(var.get_value<uint64_t>() == uint64_t(10000000000000000000UL));
460     }
461 }
462 
463 /////////////////////////////////////////////////////////////////////////////////////////
464 
465 TEST_CASE("variant::to_int64() - from enum", "[variant]")
466 {
467     SECTION("valid conversion positive")
468     {
469         variant var = enum_int64_t::VALUE_1;
470         REQUIRE(var.can_convert<int64_t>() == true);
471         bool ok = false;
472         CHECK(var.to_int64(&ok) == 8223372036854775807L);
473         CHECK(ok == true);
474 
475         REQUIRE(var.convert(type::get<int64_t>()) == true);
476         CHECK(var.get_value<int64_t>() == 8223372036854775807L);
477     }
478 
479     SECTION("valid conversion negative")
480     {
481         variant var = enum_int64_t::VALUE_NEG;
482         bool ok = false;
483         CHECK(var.to_int64(&ok) == -8223372036854775807L);
484         CHECK(ok == true);
485         CHECK(var.convert(type::get<int64_t>()) == true);
486     }
487 
488     SECTION("too big")
489     {
490         variant var = enum_uint64_t::VALUE_1;
491         bool ok = false;
492         CHECK(var.to_int64(&ok) == 0);
493         CHECK(ok == false);
494         CHECK(var.convert(type::get<int64_t>()) == false);
495     }
496 }
497 
498 /////////////////////////////////////////////////////////////////////////////////////////
499