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