Added tests for wide character construction for string class

Author: jonjondev

engine/utils/String.cpp

@@ -123,9 +123,8 @@ String::String(const wchar_t* string) : memory()
 {
     size_t size = std::wcslen(string) + 1;
     char* convertedStr = static_cast<char*>(alloca(size));
-    memset(convertedStr, 0, size + 1);
     std::wcstombs(convertedStr, string, size);
-    convertedStr[size] = '\0';
+    convertedStr[size - 1] = '\0';
     Assign(convertedStr);
 }
 
@@ -232,9 +231,8 @@ String& String::operator+=(const wchar_t* rhs)
 {
     size_t size = std::wcslen(rhs) + 1;
     char* convertedStr = static_cast<char*>(alloca(size));
-    memset(convertedStr, 0, size + 1);
     std::wcstombs(convertedStr, rhs, size);
-    convertedStr[size] = '\0';
+    convertedStr[size - 1] = '\0';
 
     Append(convertedStr);
     return *this;
@@ -723,6 +721,18 @@ String operator+(const char* lhs, const String& rhs)
     return {cstr};
 }
 
+String operator+(const wchar_t* lhs, const String& rhs)
+{
+    size_t lhsLength = std::wcslen(lhs);
+    size_t rhsLength = rhs.Size();
+
+    char* cstr = static_cast<char*>(alloca(lhsLength + rhsLength + 1));
+    std::wcstombs(cstr, lhs, lhsLength);
+    strcpy(cstr + lhsLength, rhs.Str());
+
+    return {cstr};
+}
+
 String operator+(char lhs, const String& rhs)
 {
     size_t rhsLength = rhs.Size();

engine/utils/String.h

@@ -656,6 +656,14 @@ bool operator!=(const char* lhs, const String& rhs);
  */
 String operator+(const char* lhs, const String& rhs);
 
+/**
+ * Reversed wide c-string addition operator overload for prepending strings
+ * @param lhs - the string to append to
+ * @param rhs - the string to append
+ * @return a new string object with the appended value
+ */
+String operator+(const wchar_t* lhs, const String& rhs);
+
 /**
  * Reversed character addition operator overload for prepending characters
  * @param lhs - the character to append to

tests/src/utils/test_String.cpp

@@ -37,6 +37,13 @@ UTEST(test_String, DefaultConstruct)
     ASSERT_EQ(5, s.Size());
     ASSERT_STREQ("hello", s.Str());
     ASSERT_EQ(0, std::strcmp(s.Str(), "hello"));
+
+    // Assignment of wide c-strings via assignment operator should apply
+    s = L"hello";
+    ASSERT_FALSE(s.IsEmpty());
+    ASSERT_EQ(5, s.Size());
+    ASSERT_STREQ("hello", s.Str());
+    ASSERT_EQ(0, std::strcmp(s.Str(), "hello"));
 }
 
 UTEST(test_String, CopyConstruct)
@@ -148,6 +155,16 @@ UTEST(test_String, Append)
     ASSERT_STREQ("goodbyehellogoodbye", s2.Str());
     ASSERT_EQ(19, s2.Size());
 
+    // The string should correctly append wide c-strings
+    Siege::String s6;
+    s6 += L"hello";
+    ASSERT_STREQ("hello", s6.Str());
+    Siege::String s7 = L"goodbye" + s6;
+    ASSERT_STREQ("goodbyehello", s7.Str());
+    s7.Append(L"goodbye");
+    ASSERT_STREQ("goodbyehellogoodbye", s7.Str());
+    ASSERT_EQ(19, s7.Size());
+
     // The string should correctly append characters
     Siege::String s5;
     s5 += 'h';