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