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