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