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