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