tests; human to raw

src/Business/StringUtils.cpp

 
 #include "StringUtils.h"
 
-const char* StringUtils::hex = "0123456789abcdef";
+const std::string StringUtils::hex = "0123456789abcdef";
 
 std::string StringUtils::rawToHuman(unsigned char c)
 {
 
 ResultString StringUtils::humanToRaw(std::string human)
 {
+    if (human.size() % 2 != 0) {
+        return ResultString::error("Malformed hex data: invalid length");
+    }
     std::string raw;
+    for (size_t i = 0; i < human.size(); i += 2) {
+        char c1 = toLower(human[i]);
+        char c2 = toLower(human[i + 1]);
+        size_t i1 = hex.find(c1);
+        size_t i2 = hex.find(c2);
+        if (i1 == std::string::npos || i2 == std::string::npos) {
+            return ResultString::error("Malformed hex data at char " + std::to_string(i));
+        }
+        raw += std::string(1, (char)((i1 << 4) + i2));
+    }
     return ResultString::ok(raw);
 }
+
+std::string StringUtils::toLower(std::string str)
+{
+    std::string lower;
+    for (size_t i = 0; i < str.size(); ++i) {
+        lower += tolower(str[i]);
+    }
+    return lower;
+}
+
+char StringUtils::toLower(char c)
+{
+    if (c >= 'A' && c <= 'Z') {
+        return c + ('a' - 'A');
+    }
+    return c;
+}
+
+std::string StringUtils::toUpper(std::string str)
+{
+    std::string upper;
+    for (size_t i = 0; i < str.size(); ++i) {
+        upper += toUpper(str[i]);
+    }
+    return upper;
+}
+
+char StringUtils::toUpper(char c)
+{
+    if (c >= 'a' && c <= 'z') {
+        return c - ('a' - 'A');
+    }
+    return c;
+}

src/Business/StringUtils.h

 class StringUtils
 {
 public:
-    static const char* hex;
+    static const std::string hex;
 
     static std::string rawToHuman(unsigned char c);
     static std::string rawToHuman(char c);
     static std::string rawToHuman(std::string raw);
 
     static ResultString humanToRaw(std::string human);
+
+    static std::string toLower(std::string str);
+    static char toLower(char c);
+
+    static std::string toUpper(std::string str);
+    static char toUpper(char c);
 };
 
 

tests/test-main.cpp

             "000102030405060708090a0b0c0d0e0f");
 }
 
+TEST(StringUtils, toLower)
+{
+  ASSERT_EQ(StringUtils::toLower('a'), 'a');
+  ASSERT_EQ(StringUtils::toLower('z'), 'z');
+  ASSERT_EQ(StringUtils::toLower('A'), 'a');
+  ASSERT_EQ(StringUtils::toLower('Z'), 'z');
+  ASSERT_EQ(StringUtils::toLower('1'), '1');
+  ASSERT_EQ(StringUtils::toLower('@'), '@');
+}
+
+TEST(StringUtils, toUpper)
+{
+  ASSERT_EQ(StringUtils::toUpper('a'), 'A');
+  ASSERT_EQ(StringUtils::toUpper('z'), 'Z');
+  ASSERT_EQ(StringUtils::toUpper('A'), 'A');
+  ASSERT_EQ(StringUtils::toUpper('Z'), 'Z');
+  ASSERT_EQ(StringUtils::toUpper('1'), '1');
+  ASSERT_EQ(StringUtils::toUpper('@'), '@');
+}
+
+TEST(StringUtils, humanToRaw)
+{
+  ASSERT_EQ(StringUtils::humanToRaw("0f00").getData(), std::string({0x0f, 0x00}));
+  ASSERT_EQ(StringUtils::humanToRaw("000f").getData(), std::string({0x00, 0x0f}));
+  ASSERT_EQ(StringUtils::humanToRaw("0a0a").getData(), std::string({0x0a, 0x0a}));
+  ASSERT_EQ(StringUtils::humanToRaw("1a0f").getData(), std::string({0x1a, 0x0f}));
+  ASSERT_EQ(StringUtils::humanToRaw("1a00f").getError(), "Malformed hex data: invalid length");
+  ASSERT_EQ(StringUtils::humanToRaw("1a\n00f").getError(), "Malformed hex data at char 2");
+}
+
 int main(int argc, char* argv[])
 {
     std::cout << "LibNfc version: " << LibNfc::getVersion() << std::endl;