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_int8() - from empty", "[variant]")
38 {
39     variant var;
40     bool ok = false;
41     CHECK(var.to_int8(&ok) == 0);
42     CHECK(ok == false);
43 }
44 
45 /////////////////////////////////////////////////////////////////////////////////////////
46 
47 TEST_CASE("variant::to_int8() - from bool", "[variant]")
48 {
49     variant var = true;
50     REQUIRE(var.is_valid() == true);
51     REQUIRE(var.can_convert<int8_t>() == true);
52 
53     // true case
54     bool ok = false;
55     CHECK(var.to_int8(&ok) == 1);
56     CHECK(ok == true);
57 
58     CHECK(var.convert<int8_t>(&ok) == 1);
59     CHECK(ok == true);
60     REQUIRE(var.convert(type::get<int8_t>()) == true);
61     CHECK(var.get_value<int8_t>() == 1);
62 
63     // false case
64     var = false;
65     CHECK(var.to_int8(&ok) == 0);
66     CHECK(ok == true);
67 
68     CHECK(var.convert<int8_t>(&ok) == 0);
69     CHECK(ok == true);
70     REQUIRE(var.convert(type::get<int8_t>()) == true);
71     CHECK(var.get_value<int8_t>() == 0);
72 }
73 
74 /////////////////////////////////////////////////////////////////////////////////////////
75 
76 TEST_CASE("variant::to_int8() - from char", "[variant]")
77 {
78     SECTION("valid conversion")
79     {
80         variant var = char('A');
81         REQUIRE(var.can_convert<int8_t>() == true);
82         bool ok = false;
83         CHECK(var.to_int8(&ok) == 65);
84         CHECK(ok == true);
85 
86         REQUIRE(var.convert(type::get<int8_t>()) == true);
87         CHECK(var.get_value<int8_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_int8(&ok) == -60);
99             CHECK(ok == true);
100             CHECK(var.convert(type::get<int8_t>()) == true);
101         }
102     }
103 
104 RTTR_END_DISABLE_CONDITIONAL_EXPR_WARNING
105 }
106 
107 /////////////////////////////////////////////////////////////////////////////////////////
108 
109 TEST_CASE("variant::to_int8() - from std::string", "[variant]")
110 {
111     SECTION("valid conversion positive")
112     {
113         variant var = std::string("23");
114         REQUIRE(var.can_convert<int8_t>() == true);
115         bool ok = false;
116         CHECK(var.to_int8(&ok) == 23);
117         CHECK(ok == true);
118 
119         REQUIRE(var.convert(type::get<int8_t>()) == true);
120         CHECK(var.get_value<int8_t>() == 23);
121     }
122 
123     SECTION("valid conversion negative")
124     {
125         variant var = std::string("-12");
126         bool ok = false;
127         CHECK(var.to_int8(&ok) == -12);
128         CHECK(ok == true);
129         CHECK(var.convert(type::get<int8_t>()) == true);
130     }
131 
132     SECTION("too big")
133     {
134         variant var = std::string("512");
135         bool ok = false;
136         CHECK(var.to_int8(&ok) == 0);
137         CHECK(ok == false);
138         CHECK(var.convert(type::get<int8_t>()) == false);
139     }
140 
141     SECTION("too small")
142     {
143         variant var = std::string("-512");
144         bool ok = false;
145         CHECK(var.to_int8(&ok) == 0);
146         CHECK(ok == false);
147         CHECK(var.convert(type::get<int8_t>()) == false);
148     }
149 
150     SECTION("invalid conversion")
151     {
152         variant var = std::string("text 34 and text");
153         bool ok = false;
154         CHECK(var.to_int8(&ok) == 0);
155         CHECK(ok == false);
156         CHECK(var.convert(type::get<int8_t>()) == false);
157 
158         var = std::string("34 and text");
159         ok = false;
160         CHECK(var.to_int8(&ok) == 0);
161         CHECK(ok == false);
162         CHECK(var.convert(type::get<int8_t>()) == false);
163     }
164 }
165 
166 /////////////////////////////////////////////////////////////////////////////////////////
167 
168 TEST_CASE("variant::to_int8() - from int", "[variant]")
169 {
170     SECTION("valid conversion positive")
171     {
172         variant var = 50;
173         REQUIRE(var.can_convert<int8_t>() == true);
174         bool ok = false;
175         CHECK(var.to_int8(&ok) == 50);
176         CHECK(ok == true);
177 
178         REQUIRE(var.convert(type::get<int8_t>()) == true);
179         CHECK(var.get_value<int8_t>() == 50);
180     }
181 
182     SECTION("valid conversion negative")
183     {
184         variant var = -60;
185         bool ok = false;
186         CHECK(var.to_int8(&ok) == -60);
187         CHECK(ok == true);
188         CHECK(var.convert(type::get<int8_t>()) == true);
189     }
190 
191     SECTION("too big")
192     {
193         variant var = 512;
194         bool ok = false;
195         CHECK(var.to_int8(&ok) == 0);
196         CHECK(ok == false);
197         CHECK(var.convert(type::get<int8_t>()) == false);
198     }
199 
200     SECTION("too small")
201     {
202         variant var = -512;
203         bool ok = false;
204         CHECK(var.to_int8(&ok) == 0);
205         CHECK(ok == false);
206         CHECK(var.convert(type::get<int8_t>()) == false);
207     }
208 }
209 
210 /////////////////////////////////////////////////////////////////////////////////////////
211 
212 TEST_CASE("variant::to_int8() - from float", "[variant]")
213 {
214     SECTION("valid conversion positive")
215     {
216         variant var = 1.5f;
217         REQUIRE(var.can_convert<int8_t>() == true);
218         bool ok = false;
219         CHECK(var.to_int8(&ok) == 1);
220         CHECK(ok == true);
221 
222         REQUIRE(var.convert(type::get<int8_t>()) == true);
223         CHECK(var.get_value<int8_t>() == 1);
224     }
225 
226     SECTION("valid conversion negative")
227     {
228         variant var = -21.9f;
229         bool ok = false;
230         CHECK(var.to_int8(&ok) == -21);
231         CHECK(ok == true);
232         CHECK(var.convert(type::get<int8_t>()) == true);
233     }
234 
235     SECTION("too big")
236     {
237         variant var = 512.2f;
238         bool ok = false;
239         CHECK(var.to_int8(&ok) == 0);
240         CHECK(ok == false);
241         CHECK(var.convert(type::get<int8_t>()) == false);
242     }
243 
244     SECTION("too small")
245     {
246         variant var = -512.2f;
247         bool ok = false;
248         CHECK(var.to_int8(&ok) == 0);
249         CHECK(ok == false);
250         CHECK(var.convert(type::get<int8_t>()) == false);
251     }
252 }
253 
254 /////////////////////////////////////////////////////////////////////////////////////////
255 
256 TEST_CASE("variant::to_int8() - from double", "[variant]")
257 {
258     SECTION("valid conversion positive")
259     {
260         variant var = 1.5;
261         REQUIRE(var.can_convert<int8_t>() == true);
262         bool ok = false;
263         CHECK(var.to_int8(&ok) == 1);
264 
265         CHECK(ok == true);
266         REQUIRE(var.convert(type::get<int8_t>()) == true);
267         CHECK(var.get_value<int8_t>() == 1);
268     }
269 
270     SECTION("valid conversion negative")
271     {
272         variant var = -21.9;
273         bool ok = false;
274         CHECK(var.to_int8(&ok) == -21);
275         CHECK(ok == true);
276         CHECK(var.convert(type::get<int8_t>()) == true);
277     }
278 
279     SECTION("too big")
280     {
281         variant var = 512.2;
282         bool ok = false;
283         CHECK(var.to_int8(&ok) == 0);
284         CHECK(ok == false);
285         CHECK(var.convert(type::get<int8_t>()) == false);
286     }
287 
288     SECTION("too small")
289     {
290         variant var = -512.2;
291         bool ok = false;
292         CHECK(var.to_int8(&ok) == 0);
293         CHECK(ok == false);
294         CHECK(var.convert(type::get<int8_t>()) == false);
295     }
296 }
297 
298 /////////////////////////////////////////////////////////////////////////////////////////
299 
300 TEST_CASE("variant::to_int8() - from int8_t", "[variant]")
301 {
302     SECTION("valid conversion positive")
303     {
304         variant var = int8_t(50);
305         REQUIRE(var.can_convert<int8_t>() == true);
306         bool ok = false;
307         CHECK(var.to_int8(&ok) == 50);
308         CHECK(ok == true);
309 
310         REQUIRE(var.convert(type::get<int8_t>()) == true);
311         CHECK(var.get_value<int8_t>() == 50);
312     }
313 
314     SECTION("valid conversion negative")
315     {
316         variant var = int8_t(-60);
317         bool ok = false;
318         CHECK(var.to_int8(&ok) == int8_t(-60));
319         CHECK(ok == true);
320         CHECK(var.convert(type::get<int8_t>()) == true);
321     }
322 }
323 
324 /////////////////////////////////////////////////////////////////////////////////////////
325 
326 TEST_CASE("variant::to_int8() - from int16_t", "[variant]")
327 {
328     SECTION("valid conversion positive")
329     {
330         variant var = int16_t(50);
331         REQUIRE(var.can_convert<int8_t>() == true);
332         bool ok = false;
333         CHECK(var.to_int8(&ok) == int16_t(50));
334         CHECK(ok == true);
335 
336         REQUIRE(var.convert(type::get<int8_t>()) == true);
337         CHECK(var.get_value<int8_t>() == int8_t(50));
338     }
339 
340     SECTION("valid conversion negative")
341     {
342         variant var = int16_t(-60);
343         bool ok = false;
344         CHECK(var.to_int8(&ok) == int8_t(-60));
345         CHECK(ok == true);
346         CHECK(var.convert(type::get<int8_t>()) == true);
347     }
348 
349     SECTION("too big")
350     {
351         variant var = int16_t(512);
352         bool ok = false;
353         CHECK(var.to_int8(&ok) == 0);
354         CHECK(ok == false);
355         CHECK(var.convert(type::get<int8_t>()) == false);
356     }
357 
358     SECTION("too small")
359     {
360         variant var = int16_t(-512);
361         bool ok = false;
362         CHECK(var.to_int8(&ok) == 0);
363         CHECK(ok == false);
364         CHECK(var.convert(type::get<int8_t>()) == false);
365     }
366 }
367 
368 /////////////////////////////////////////////////////////////////////////////////////////
369 
370 TEST_CASE("variant::to_int8() - from int32_t", "[variant]")
371 {
372     SECTION("valid conversion positive")
373     {
374         variant var = int32_t(50);
375         REQUIRE(var.can_convert<int8_t>() == true);
376         bool ok = false;
377         CHECK(var.to_int8(&ok) == int8_t(50));
378         CHECK(ok == true);
379 
380         REQUIRE(var.convert(type::get<int8_t>()) == true);
381         CHECK(var.get_value<int8_t>() == int8_t(50));
382     }
383 
384     SECTION("valid conversion negative")
385     {
386         variant var = int32_t(-60);
387         bool ok = false;
388         CHECK(var.to_int8(&ok) == int32_t(-60));
389         CHECK(ok == true);
390         CHECK(var.convert(type::get<int8_t>()) == true);
391     }
392 
393     SECTION("too big")
394     {
395         variant var = int32_t(512);
396         bool ok = false;
397         CHECK(var.to_int8(&ok) == 0);
398         CHECK(ok == false);
399         CHECK(var.convert(type::get<int8_t>()) == false);
400     }
401 
402     SECTION("too small")
403     {
404         variant var = int32_t(-512);
405         bool ok = false;
406         CHECK(var.to_int8(&ok) == 0);
407         CHECK(ok == false);
408         CHECK(var.convert(type::get<int8_t>()) == false);
409     }
410 }
411 
412 /////////////////////////////////////////////////////////////////////////////////////////
413 
414 TEST_CASE("variant::to_int8() - from int64_t", "[variant]")
415 {
416     SECTION("valid conversion positive")
417     {
418         variant var = int64_t(50);
419         REQUIRE(var.can_convert<int8_t>() == true);
420         bool ok = false;
421         CHECK(var.to_int8(&ok) == int64_t(50));
422         CHECK(ok == true);
423 
424         REQUIRE(var.convert(type::get<int8_t>()) == true);
425         CHECK(var.get_value<int8_t>() == int8_t(50));
426     }
427 
428     SECTION("valid conversion negative")
429     {
430         variant var = int64_t(-60);
431         bool ok = false;
432         CHECK(var.to_int8(&ok) == int8_t(-60));
433         CHECK(ok == true);
434         CHECK(var.convert(type::get<int8_t>()) == true);
435     }
436 
437     SECTION("too big")
438     {
439         variant var = int64_t(512);
440         bool ok = false;
441         CHECK(var.to_int8(&ok) == 0);
442         CHECK(ok == false);
443         CHECK(var.convert(type::get<int8_t>()) == false);
444     }
445 
446     SECTION("too small")
447     {
448         variant var = int64_t(-512);
449         bool ok = false;
450         CHECK(var.to_int8(&ok) == 0);
451         CHECK(ok == false);
452         CHECK(var.convert(type::get<int8_t>()) == false);
453     }
454 }
455 
456 /////////////////////////////////////////////////////////////////////////////////////////
457 
458 TEST_CASE("variant::to_int8() - from uint8_t", "[variant]")
459 {
460     SECTION("valid conversion positive")
461     {
462         variant var = uint8_t(50);
463         REQUIRE(var.can_convert<uint8_t>() == true);
464         bool ok = false;
465         CHECK(var.to_int8(&ok) == int8_t(50));
466         CHECK(ok == true);
467 
468         REQUIRE(var.convert(type::get<int8_t>()) == true);
469         CHECK(var.get_value<int8_t>() == int8_t(50));
470     }
471 
472     SECTION("too big")
473     {
474         variant var = uint8_t(200);
475         bool ok = false;
476         CHECK(var.to_int8(&ok) == 0);
477         CHECK(ok == false);
478         CHECK(var.convert(type::get<int8_t>()) == false);
479     }
480 }
481 
482 /////////////////////////////////////////////////////////////////////////////////////////
483 
484 TEST_CASE("variant::to_int8() - from uint16_t", "[variant]")
485 {
486     SECTION("valid conversion positive")
487     {
488         variant var = uint16_t(50);
489         REQUIRE(var.can_convert<uint16_t>() == true);
490         bool ok = false;
491         CHECK(var.to_int8(&ok) == int8_t(50));
492         CHECK(ok == true);
493 
494         REQUIRE(var.convert(type::get<int8_t>()) == true);
495         CHECK(var.get_value<int8_t>() == int8_t(50));
496     }
497 
498     SECTION("too big")
499     {
500         variant var = uint16_t(1000);
501         bool ok = false;
502         CHECK(var.to_int8(&ok) == 0);
503         CHECK(ok == false);
504         CHECK(var.convert(type::get<int8_t>()) == false);
505     }
506 }
507 
508 /////////////////////////////////////////////////////////////////////////////////////////
509 
510 TEST_CASE("variant::to_int8() - from uint32_t", "[variant]")
511 {
512     SECTION("valid conversion positive")
513     {
514         variant var = uint32_t(50);
515         REQUIRE(var.can_convert<uint32_t>() == true);
516         bool ok = false;
517         CHECK(var.to_int8(&ok) == 50);
518         CHECK(ok == true);
519 
520         REQUIRE(var.convert(type::get<int8_t>()) == true);
521         CHECK(var.get_value<int8_t>() == int8_t(50));
522     }
523 
524     SECTION("too big")
525     {
526         variant var = uint32_t(1000);
527         bool ok = false;
528         CHECK(var.to_int8(&ok) == 0);
529         CHECK(ok == false);
530         CHECK(var.convert(type::get<int8_t>()) == false);
531     }
532 }
533 
534 /////////////////////////////////////////////////////////////////////////////////////////
535 
536 TEST_CASE("variant::to_int8() - from uint64_t", "[variant]")
537 {
538     SECTION("valid conversion positive")
539     {
540         variant var = uint64_t(50);
541         REQUIRE(var.can_convert<uint64_t>() == true);
542         bool ok = false;
543         CHECK(var.to_int8(&ok) == 50);
544         CHECK(ok == true);
545 
546         REQUIRE(var.convert(type::get<int8_t>()) == true);
547         CHECK(var.get_value<int8_t>() == int8_t(50));
548     }
549 
550     SECTION("too big")
551     {
552         variant var = uint64_t(1000);
553         bool ok = false;
554         CHECK(var.to_int8(&ok) == 0);
555         CHECK(ok == false);
556         REQUIRE(var.convert(type::get<int8_t>()) == false);
557         CHECK(var.get_value<uint64_t>() == uint64_t(1000));
558     }
559 }
560 
561 /////////////////////////////////////////////////////////////////////////////////////////
562 
563 TEST_CASE("variant::to_int8() - from enum", "[variant]")
564 {
565     SECTION("valid conversion positive")
566     {
567         variant var = enum_int8_t::VALUE_1;
568         REQUIRE(var.can_convert<int8_t>() == true);
569         bool ok = false;
570         CHECK(var.to_int8(&ok) == 100);
571         CHECK(ok == true);
572 
573         REQUIRE(var.convert(type::get<int8_t>()) == true);
574         CHECK(var.get_value<int8_t>() == 100);
575     }
576 
577     SECTION("valid conversion negative")
578     {
579         variant var = enum_int8_t::VALUE_NEG;
580         bool ok = false;
581         CHECK(var.to_int8(&ok) == -100);
582         CHECK(ok == true);
583         CHECK(var.convert(type::get<int8_t>()) == true);
584     }
585 
586     SECTION("too big")
587     {
588         variant var = enum_int16_t::VALUE_1;
589         bool ok = false;
590         CHECK(var.to_int8(&ok) == 0);
591         CHECK(ok == false);
592         CHECK(var.convert(type::get<int8_t>()) == false);
593     }
594 
595     SECTION("too small")
596     {
597         variant var = enum_int16_t::VALUE_NEG;
598         bool ok = false;
599         CHECK(var.to_int8(&ok) == 0);
600         CHECK(ok == false);
601         CHECK(var.convert(type::get<int8_t>()) == false);
602     }
603 }
604 
605 /////////////////////////////////////////////////////////////////////////////////////////
606