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