added unit tests to convert from char to all other basic types.

rttrorg · Feb 10, 2016 · cb48f31 · cb48f31
1 parent f21c0c1
commit cb48f31
Show file tree

Hide file tree

Showing 15 changed files with 370 additions and 34 deletions.
diff --git a/src/rttr/detail/variant/variant_data_converter.h b/src/rttr/detail/variant/variant_data_converter.h
@@ -329,26 +329,22 @@ struct RTTR_API convert_from<char>
 
     static RTTR_INLINE bool to(const char& from, uint8_t& to)
     {
-        to = static_cast<uint8_t>(from);
-        return true;
+        return convert_to(from, to);
     }
 
     static RTTR_INLINE bool to(const char& from, uint16_t& to)
     {
-        to = static_cast<uint16_t>(from);
-        return true;
+        return convert_to(from, to);
     }
 
     static RTTR_INLINE bool to(const char& from, uint32_t& to)
     {
-        to = static_cast<uint32_t>(from);
-        return true;
+        return convert_to(from, to);
     }
 
     static RTTR_INLINE bool to(const char& from, uint64_t& to)
     {
-        to = static_cast<uint64_t>(from);
-        return true;
+        return convert_to(from, to);
     }
 
     static RTTR_INLINE bool to(const char& from, float& to)

diff --git a/src/unit_tests/variant/variant_cmp_equal_test.cpp b/src/unit_tests/variant/variant_cmp_equal_test.cpp
@@ -104,6 +104,24 @@ TEST_CASE("variant::operator==() - basic", "[variant]")
         CHECK((a != b) == false);
     }
 
+    SECTION("int[neg] - uint8_t")
+    {
+        variant a = -12;
+        variant b = static_cast<uint8_t>(12);
+
+        CHECK((a == b) == false);
+        CHECK((a != b) == true);
+    }
+
+     SECTION("uint8_t - int[neg]")
+    {
+        variant a = static_cast<uint8_t>(12);
+        variant b = -12;
+
+        CHECK((a == b) == false);
+        CHECK((a != b) == true);
+    }
+
     SECTION("double - float")
     {
         variant a = 12.5f;

diff --git a/src/unit_tests/variant/variant_conv_to_bool.cpp b/src/unit_tests/variant/variant_conv_to_bool.cpp
@@ -67,35 +67,23 @@ TEST_CASE("variant::to_bool() - from bool", "[variant]")
 
 TEST_CASE("variant::to_bool() - from char", "[variant]")
 {
-    variant var = "true";
-    REQUIRE(var.is_valid() == true);
-    REQUIRE(var.can_convert<bool>() == true);
-
-    CHECK(var.to_bool() == true);
-    CHECK(var.convert<bool>() == true);
-    CHECK(var.convert(type::get<bool>()) == true);
-    CHECK(var.get_value<bool>() == true);
+    SECTION("valid conversion")
+    {
+        // true
+        variant var = char('A');
+        REQUIRE(var.can_convert<bool>() == true);
+        CHECK(var.to_bool() == true);
 
-    var = "fdsfsdf";
-    CHECK(var.to_bool() == true);
-    CHECK(var.convert<bool>() == true);
-    CHECK(var.convert(type::get<bool>()) == true);
-    CHECK(var.get_value<bool>() == true);
+        CHECK(var.convert(type::get<bool>()) == true);
+        CHECK(var.get_value<bool>() == true);
 
-    var = "false";
-    CHECK(var.to_bool() == false);
-    var = "false   ";
-    CHECK(var.to_bool() == false);
-    var = "   false   ";
-    CHECK(var.to_bool() == false);
-    var = "   FALSE   ";
-    CHECK(var.to_bool() == false);
-    var = " \n  FALSE\n";
-    CHECK(var.to_bool() == false);
+        // false
+        var = char('\0');
+        CHECK(var.to_bool() == false);
 
-    CHECK(var.convert<bool>() == false);
-    CHECK(var.convert(type::get<bool>()) == true);
-    CHECK(var.get_value<bool>() == false);
+        REQUIRE(var.convert(type::get<bool>()) == true);
+        CHECK(var.get_value<bool>() == false);
+    }
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
@@ -434,6 +422,15 @@ TEST_CASE("variant::to_bool() - from enum", "[variant]")
 
         CHECK(var.convert(type::get<bool>()) == true);
         CHECK(var.get_value<bool>() == true);
+
+        // test with non-bool enum
+        var = variant_enum_test::VALUE_0;
+        CHECK(var.to_bool() == false);
+        CHECK(var.convert(type::get<bool>()) == true);
+
+        var = variant_enum_test::VALUE_1;
+        CHECK(var.to_bool() == true);
+        CHECK(var.convert(type::get<bool>()) == true);
     }
 
     SECTION("invalid conversion")

diff --git a/src/unit_tests/variant/variant_conv_to_double.cpp b/src/unit_tests/variant/variant_conv_to_double.cpp
@@ -73,6 +73,32 @@ TEST_CASE("variant::to_double() - from bool", "[variant]")
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
+TEST_CASE("variant::to_double() - from char", "[variant]")
+{
+    SECTION("valid conversion")
+    {
+        variant var = char('A');
+        REQUIRE(var.can_convert<double>() == true);
+        bool ok = false;
+        CHECK(var.to_double(&ok) == 65.0);
+        CHECK(ok == true);
+
+        REQUIRE(var.convert(type::get<double>()) == true);
+        CHECK(var.get_value<double>() == 65.0);
+    }
+
+    SECTION("valid conversion negative")
+    {
+        variant var = char(-60);
+        bool ok = false;
+        CHECK(var.to_double(&ok) == -60.0);
+        CHECK(ok == true);
+        CHECK(var.convert(type::get<double>()) == true);
+    }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
 TEST_CASE("variant::to_double() - from std::string", "[variant]")
 {
     SECTION("valid conversion positive")

diff --git a/src/unit_tests/variant/variant_conv_to_enum.cpp b/src/unit_tests/variant/variant_conv_to_enum.cpp
@@ -47,6 +47,15 @@ RTTR_REGISTRATION
         value("VALUE_1", variant_enum_test_big::VALUE_1),
         value("VALUE_2", variant_enum_test_big::VALUE_2)
     );
+
+    registration::enumeration<enum_int8_t>("enum_int8_t")
+    (
+        value("VALUE_1", enum_int8_t::VALUE_1),
+        value("VALUE_2", enum_int8_t::VALUE_2),
+        value("VALUE_3", enum_int8_t::VALUE_3),
+        value("VALUE_4", enum_int8_t::VALUE_4),
+        value("VALUE_NEG", enum_int8_t::VALUE_NEG)
+    );
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
@@ -105,6 +114,36 @@ TEST_CASE("variant:to enum - from bool", "[variant]")
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
+TEST_CASE("variant:to enum - from char", "[variant]")
+{
+    SECTION("valid conversion positive")
+    {
+        variant var = char('d'); // the dec value for ACII char 'd' is 100
+        REQUIRE(var.can_convert<enum_int8_t>() == true);
+        bool ok = false;
+        CHECK(var.convert<enum_int8_t>(&ok) == enum_int8_t::VALUE_1);
+        CHECK(ok == true);
+
+        CHECK(var.convert(type::get<enum_int8_t>()) == true);
+        REQUIRE(var.is_type<enum_int8_t>() == true);
+        CHECK(var.get_value<enum_int8_t>() == enum_int8_t::VALUE_1);
+    }
+
+    SECTION("invalid conversion")
+    {
+        variant var = char('+');
+        REQUIRE(var.can_convert<enum_int8_t>() == true);
+        bool ok = false;
+        var.convert<enum_int8_t>(&ok); // undefined return value.. thats why no compare is done.
+        CHECK(ok == false);
+
+        CHECK(var.convert(type::get<enum_int8_t>()) == false);
+        CHECK(var.is_type<char>() == true);
+    }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
 TEST_CASE("variant:to enum - from std::string", "[variant]")
 {
     SECTION("valid conversion")

diff --git a/src/unit_tests/variant/variant_conv_to_float.cpp b/src/unit_tests/variant/variant_conv_to_float.cpp
@@ -73,6 +73,32 @@ TEST_CASE("variant::to_float() - from bool", "[variant]")
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
+TEST_CASE("variant::to_float() - from char", "[variant]")
+{
+    SECTION("valid conversion")
+    {
+        variant var = char('A');
+        REQUIRE(var.can_convert<float>() == true);
+        bool ok = false;
+        CHECK(var.to_float(&ok) == 65.0);
+        CHECK(ok == true);
+
+        CHECK(var.convert(type::get<float>()) == true);
+        CHECK(var.get_value<float>() == 65.0);
+    }
+
+    SECTION("valid conversion negative")
+    {
+        variant var = char(-60);
+        bool ok = false;
+        CHECK(var.to_float(&ok) == -60.0);
+        CHECK(ok == true);
+        CHECK(var.convert(type::get<float>()) == true);
+    }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
 TEST_CASE("variant::to_float() - from std::string", "[variant]")
 {
     SECTION("valid conversion positive")

diff --git a/src/unit_tests/variant/variant_conv_to_int16.cpp b/src/unit_tests/variant/variant_conv_to_int16.cpp
@@ -73,6 +73,32 @@ TEST_CASE("variant::to_int16() - from bool", "[variant]")
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
+TEST_CASE("variant::to_int16() - from char", "[variant]")
+{
+    SECTION("valid conversion")
+    {
+        variant var = char('A');
+        REQUIRE(var.can_convert<int16_t>() == true);
+        bool ok = false;
+        CHECK(var.to_int16(&ok) == 65);
+        CHECK(ok == true);
+
+        REQUIRE(var.convert(type::get<int16_t>()) == true);
+        CHECK(var.get_value<int16_t>() == 65);
+    }
+
+    SECTION("valid conversion negative")
+    {
+        variant var = char(-60);
+        bool ok = false;
+        CHECK(var.to_int16(&ok) == -60);
+        CHECK(ok == true);
+        CHECK(var.convert(type::get<int16_t>()) == true);
+    }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
 TEST_CASE("variant::to_int16() - from std::string", "[variant]")
 {
     SECTION("valid conversion positive")

diff --git a/src/unit_tests/variant/variant_conv_to_int32.cpp b/src/unit_tests/variant/variant_conv_to_int32.cpp
@@ -73,6 +73,32 @@ TEST_CASE("variant::to_int32() - from bool", "[variant]")
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
+TEST_CASE("variant::to_int32() - from char", "[variant]")
+{
+    SECTION("valid conversion")
+    {
+        variant var = char('A');
+        REQUIRE(var.can_convert<int32_t>() == true);
+        bool ok = false;
+        CHECK(var.to_int32(&ok) == 65);
+        CHECK(ok == true);
+
+        REQUIRE(var.convert(type::get<int32_t>()) == true);
+        CHECK(var.get_value<int32_t>() == 65);
+    }
+
+    SECTION("valid conversion negative")
+    {
+        variant var = char(-60);
+        bool ok = false;
+        CHECK(var.to_int32(&ok) == -60);
+        CHECK(ok == true);
+        CHECK(var.convert(type::get<int32_t>()) == true);
+    }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
 TEST_CASE("variant::to_int32() - from std::string", "[variant]")
 {
     SECTION("valid conversion positive")

diff --git a/src/unit_tests/variant/variant_conv_to_int64.cpp b/src/unit_tests/variant/variant_conv_to_int64.cpp
@@ -73,6 +73,32 @@ TEST_CASE("variant::to_int64() - from bool", "[variant]")
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
+TEST_CASE("variant::to_int64() - from char", "[variant]")
+{
+    SECTION("valid conversion")
+    {
+        variant var = char('A');
+        REQUIRE(var.can_convert<int64_t>() == true);
+        bool ok = false;
+        CHECK(var.to_int64(&ok) == 65);
+        CHECK(ok == true);
+
+        REQUIRE(var.convert(type::get<int64_t>()) == true);
+        CHECK(var.get_value<int64_t>() == 65);
+    }
+
+    SECTION("valid conversion negative")
+    {
+        variant var = char(-60);
+        bool ok = false;
+        CHECK(var.to_int64(&ok) == -60);
+        CHECK(ok == true);
+        CHECK(var.convert(type::get<int64_t>()) == true);
+    }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
 TEST_CASE("variant::to_int64() - from std::string", "[variant]")
 {
     SECTION("valid conversion positive")

diff --git a/src/unit_tests/variant/variant_conv_to_int8.cpp b/src/unit_tests/variant/variant_conv_to_int8.cpp
@@ -73,6 +73,32 @@ TEST_CASE("variant::to_int8() - from bool", "[variant]")
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
+TEST_CASE("variant::to_int8() - from char", "[variant]")
+{
+    SECTION("valid conversion")
+    {
+        variant var = char('A');
+        REQUIRE(var.can_convert<int8_t>() == true);
+        bool ok = false;
+        CHECK(var.to_int8(&ok) == 65);
+        CHECK(ok == true);
+
+        REQUIRE(var.convert(type::get<int8_t>()) == true);
+        CHECK(var.get_value<int8_t>() == 65);
+    }
+
+    SECTION("valid conversion negative")
+    {
+        variant var = char(-60);
+        bool ok = false;
+        CHECK(var.to_int8(&ok) == -60);
+        CHECK(ok == true);
+        CHECK(var.convert(type::get<int8_t>()) == true);
+    }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
 TEST_CASE("variant::to_int8() - from std::string", "[variant]")
 {
     SECTION("valid conversion positive")