Add tests for base64 (KF-25, #41)

* add tests for base64

* refactoring

---------

Co-authored-by: Vlada Kanivets <vlada.kanivets@apriorit.com>

Author: Kellesi

include/kf/Base64.h

@@ -8,6 +8,11 @@ namespace kf
 
     // original implementation is taken from https://github.com/adamvr/arduino-base64/blob/master/Base64.cpp
 
+    //////////////////////////////////////////////////////////////////////////////////
+    // Base64 is utility for decoding Base64-encoded strings.
+    // Only ASCII-compatible Base64 is supported.
+    // Decoded buffer contains bytes as 'char', not 'WCHAR'.
+    // If the string contains many '=' characters, the decoded length may be negative.
     class Base64
     {
     public:
@@ -20,7 +25,7 @@ namespace kf
 
             int numEq = 0;
 
-            for (int i = input.charLength() - 1; static_cast<char>(input.charAt(i)) == '='; --i)
+            for (int i = input.charLength() - 1; i >= 0 && static_cast<char>(input.charAt(i)) == '='; --i)
             {
                 numEq++;
             }
@@ -36,6 +41,12 @@ namespace kf
             uint8_t a3[3];
             uint8_t a4[4];
 
+            int decodedLen = decodeLen(input);
+            if (decodedLen < 0 || output.size() < decodedLen)
+            {
+                return -1;
+            }
+
             while (inputIdx < input.charLength()) 
             {
                 auto ch = static_cast<char>(input.charAt(inputIdx++));

test/Base64Test.cpp

@@ -0,0 +1,140 @@
+#include "pch.h"
+#include <kf/Base64.h>
+#include <string_view>
+
+SCENARIO("Base64::decodeLen")
+{
+    WHEN("Encoded string is empty")
+    {
+        THEN("Decode length is 0")
+        {
+            REQUIRE(kf::Base64::decodeLen(L"") == 0);
+        }
+    }
+
+    WHEN("Encoded string is VA==")
+    {
+        THEN("Decode length is 1")
+        {
+            REQUIRE(kf::Base64::decodeLen(L"VA==") == 1); // "T"
+        }
+    }
+
+    WHEN("Encoded string is VGU=")
+    {
+        THEN("Decode length is 2")
+        {
+            REQUIRE(kf::Base64::decodeLen(L"VGU=") == 2); // "Te"
+        }
+    }
+
+    WHEN("Encoded string is VGVz")
+    {
+        THEN("Decode length is 3")
+        {
+            REQUIRE(kf::Base64::decodeLen(L"VGVz") == 3); // "Tes"
+        }
+    }
+
+    WHEN("Encoded string is VGVzdA==")
+    {
+        THEN("Decode length is 4")
+        {
+            REQUIRE(kf::Base64::decodeLen(L"VGVzdA==") == 4); // "Test"
+        }
+    }
+
+    WHEN("Encoded string is ==")
+    {
+        THEN("Decode length is -1")
+        {
+            REQUIRE(kf::Base64::decodeLen(L"==") == -1);
+        }
+    }
+}
+
+
+SCENARIO("Base64::decode")
+{
+    GIVEN("Encoded string 'VA=='")
+    {
+        kf::USimpleString input(L"VA=="); // "T"
+        constexpr std::wstring_view kExpectedOutput = L"T";
+        constexpr size_t kExpectedLength = kExpectedOutput.size();
+        std::array<wchar_t, kExpectedLength> output;
+
+        THEN("Decoded symbol is 'T' and decoded length is 1")
+        {
+            int written = kf::Base64::decode(input, std::as_writable_bytes(std::span{ output }));
+            REQUIRE(written == kExpectedLength);
+
+            REQUIRE(std::wstring_view(output.data(), written) == kExpectedOutput);
+        }
+    }
+
+    GIVEN("Encoded string 'VGU='")
+    {
+        kf::USimpleString input(L"VGU="); // "Te"
+        constexpr std::string_view kExpectedOutput = "Te";
+        constexpr size_t kExpectedLength = kExpectedOutput.size();
+        std::array<char, kExpectedLength> output;
+
+        THEN("Decoded symbols are 'Te' and decoded length is 2")
+        {
+            int written = kf::Base64::decode(input, std::as_writable_bytes(std::span{ output }));
+            REQUIRE(written == kExpectedLength);
+            REQUIRE(std::string_view(output.data(), written) == kExpectedOutput);
+        }
+    }
+
+    GIVEN("Encoded string 'VGhpcyBpcyBhIGxvbmcgdGVzdCBzdHJpbmcgZm9yIHVuaXQgdGVzdGluZw=='")
+    {
+        kf::USimpleString input(L"VGhpcyBpcyBhIGxvbmcgdGVzdCBzdHJpbmcgZm9yIHVuaXQgdGVzdGluZw==");
+        constexpr std::string_view kExpectedOutput = "This is a long test string for unit testing";
+        constexpr size_t kExpectedLength = kExpectedOutput.size();
+        std::array<char, kExpectedLength> output;
+
+        THEN("Decoded symbols are 'This is a long test string for unit testing' and decoded length is correct")
+        {
+            int written = kf::Base64::decode(input, std::as_writable_bytes(std::span{ output }));
+            REQUIRE(written == kExpectedLength);
+            REQUIRE(std::string_view(output.data(), written) == kExpectedOutput);
+        }
+    }
+
+    GIVEN("Empty string")
+    {
+        kf::USimpleString input;
+        std::array<char, 2> output;
+
+        THEN("Decoded length is 0")
+        {
+            int written = kf::Base64::decode(input, std::as_writable_bytes(std::span{ output }));
+            REQUIRE(written == 0);
+        }
+    }
+
+    GIVEN("Output buffer isn't big enough")
+    {
+        kf::USimpleString input(L"VGVzdA==");
+        std::array<char, 2> output;
+
+        THEN("Decode returns -1")
+        {
+            int written = kf::Base64::decode(input, std::as_writable_bytes(std::span{ output }));
+            REQUIRE(written == -1);
+        }
+    }
+
+    GIVEN("Encoded string with negative decode length")
+    {
+        kf::USimpleString input(L"==");
+        std::array<char, 2> output;
+
+        THEN("Decode returns -1")
+        {
+            int written = kf::Base64::decode(input, std::as_writable_bytes(std::span{ output }));
+            REQUIRE(written == -1);
+        }
+    }
+}

test/CMakeLists.txt

@@ -44,6 +44,7 @@ wdk_add_driver(kf-test WINVER NTDDI_WIN10 STL
     HexTest.cpp
     MapTest.cpp
     Vector.cpp
+    Base64Test.cpp
 )
 
 target_link_libraries(kf-test kf::kf kmtest::kmtest)