Merge pull request #2 from vSEK1RO/v1.0.2

V1.0.2

.github/workflows/docs.yml

@@ -1,10 +1,8 @@
 name: Deploy documentation
 
 on:
-  push:
+  release:
-    branches: ["main"]
+    types: [published]
-
-  workflow_dispatch:
 
 permissions:
   contents: read

.gitignore

@@ -43,6 +43,7 @@ bin
 obj
 lib
 doc
+cov
 
 # IDE
 .vscode

Makefile

@@ -5,7 +5,7 @@ DEBUG ?= false
 USRDIR ?= /usr
 
 .PHONY: build i install uni uninstall\
-		tools library tests docs clean
+		tools library tests docs cov clean
 
 LIB = basen
 OBJS =\
@@ -59,6 +59,8 @@ DIRS =\
 	${OBJDIR}\
 	${OBJDIR}/hash\
 	${LIBDIR}\
+	doc\
+	cov
 
 build: library tools
 
@@ -80,8 +82,19 @@ uninstall:
 docs:
 	doxygen Doxyfile
 
+cover: ${DIRS} ${patsubst %, ${BINDIR}/%${-g}-cov, ${TESTS}}
+	rm -f **/*.gcda
+	${patsubst %, ./${BINDIR}/%${-g}-cov;, ${TESTS}}
+	gcovr --html-nested cov/index.html --txt --exclude-throw-branches
+
+${OBJDIR}/%${-g}-cov.o: ${SRCDIR}/%.cpp ${INCDIR}/${LIB}/%.hpp
+	${CC} -o $@ -c $< -I${INCDIR} ${-l} ${CFLAGS} --coverage
+
+${BINDIR}/%${-g}-cov: ${TESTDIR}/%.cpp ${patsubst %, ${OBJDIR}/%${-g}-cov.o, ${OBJS}}
+	${CC} -o $@ $^ -I${INCDIR} ${-l} -lgtest ${CFLAGS} --coverage
+
 clean:
-	rm -rf ${OBJDIR}/* ${LIBDIR}/* ${BINDIR}/*
+	rm -rf ${DIRS}
 
 ifneq (${OBJS},)
 

README.md

@@ -30,18 +30,6 @@ Uninstall:
 ```
 sudo make uni USRDIR=(Your installation dir)
 ```
-For build with with debug flags:
-```
-make -j $(nproc) DEBUG=
-```
-For build tests (needed gtest package as dependency):
-```
-make tests -j $(nproc) DEBUG=
-```
-And also flag for dynamic linking (if possible):
-```
-make tools -j $(nproc) SHARED=
-```
 
 ## Documentation
 
@@ -56,4 +44,17 @@ Now we would like to implement the following features:
 - BCH
 - Bech32
 
+For build with with debug flags:
+```
+make -j $(nproc) DEBUG=
+```
+For build tests (needed gtest package as dependency):
+```
+make tests -j $(nproc) DEBUG=
+```
+For generating coverage:
+```
+make cover -j $(nproc) DEBUG=
+```
+
 [⬆️ Contents](#contents)

src/base64.cpp

@@ -74,25 +74,22 @@ namespace base64
             str[i * 4 + 3] = digits[data[i * 3 + 2] & 0x3F];
         }
         uint64_t last_idx = data_size / 3 * 4;
-        if (last_idx + 3 < str_size)
+        switch (data_size % 3)
         {
-            switch (data_size % 3)
+        case 1:
-            {
+            str[last_idx] = digits[data[data_size - 1] >> 2];
-            case 1:
+            str[last_idx + 1] = digits[data[data_size - 1] << 4 & 0x30];
-                str[last_idx] = digits[data[data_size - 1] >> 2];
+            str[last_idx + 2] = '=';
-                str[last_idx + 1] = digits[data[data_size - 1] << 4 & 0x30];
+            str[last_idx + 3] = '=';
-                str[last_idx + 2] = '=';
+            break;
-                str[last_idx + 3] = '=';
+        case 2:
-                break;
+            str[last_idx] = digits[data[data_size - 2] >> 2];
-            case 2:
+            str[last_idx + 1] = digits[(data[data_size - 2] << 4 | data[data_size - 1] >> 4) & 0x3F];
-                str[last_idx] = digits[data[data_size - 2] >> 2];
+            str[last_idx + 2] = digits[data[data_size - 1] & 0x0F];
-                str[last_idx + 1] = digits[(data[data_size - 2] << 4 | data[data_size - 1] >> 4) & 0x3F];
+            str[last_idx + 3] = '=';
-                str[last_idx + 2] = digits[data[data_size - 1] & 0x0F];
+            break;
-                str[last_idx + 3] = '=';
+        default:
-                break;
+            break;
-            default:
-                break;
-            }
         }
     }
     std::string encode(std::span<const uint8_t> data) noexcept

test/test-base64.cpp

@@ -28,6 +28,12 @@ TEST(base64, encode)
 {
     for (auto it : tests)
         EXPECT_EQ(it.first, encode(hex::decode(it.second)));
+
+    std::vector<uint8_t> data = {0x74, 0x65, 0x73, 0x74};
+    std::string str = "";
+    EXPECT_THROW(encode(data.data(), std::numeric_limits<uint64_t>::max(), str.data(), str.size()), std::overflow_error);
+    EXPECT_THROW(encode(data.data(), data.size(), str.data(), str.size()), std::length_error);
+    EXPECT_NO_THROW(encode(data.data(), 0, str.data(), str.size()));
 }
 TEST(base64, encode_1e7)
 {
@@ -38,6 +44,12 @@ TEST(base64, decode)
 {
     for (auto it : tests)
         EXPECT_EQ(hex::encode(decode(it.first)), it.second);
+
+    std::vector<uint8_t> data = {0x61, 0x6e, 0x6f};
+    EXPECT_THROW(decode("FFF", 3, data.data(), data.size()), std::logic_error);
+    EXPECT_THROW(decode("!@#!", 4, data.data(), data.size()), std::logic_error);
+    EXPECT_THROW(decode("FF==", 2, data.data(), 0), std::length_error);
+    EXPECT_NO_THROW(decode(""       , 0, data.data(), 0));
 }
 TEST(base64, decode_1e7)
 {

test/test-hex.cpp

@@ -1,21 +1,28 @@
+#include <utility>
+
 #include <basen/hex.hpp>
 #include <gtest/gtest.h>
 
 using namespace hex;
 
+TEST(hex, isValid)
+{
+    std::vector<std::pair<bool, std::string>> tests = {
+        {true, "1234"},
+        {false, "!@/"},
+    };
+    for (auto it : tests)
+        EXPECT_EQ(it.first, isValid(it.second));
+}
 TEST(hex, encode)
 {
     std::vector<uint8_t> data = {0x74, 0x65, 0x73, 0x74};
     EXPECT_EQ("74657374", encode(data));
-    try
+
-    {
+    std::string str = "";
-        std::string str = "";
+    EXPECT_THROW(encode(data.data(), std::numeric_limits<uint64_t>::max(), str.data(), str.size()), std::overflow_error);
-        encode(data.data(), data.size(), str.data(), str.size());
+    EXPECT_THROW(encode(data.data(), data.size(), str.data(), str.size()), std::length_error);
-    }
+    EXPECT_NO_THROW(encode(data.data(), 0, str.data(), str.size()));
-    catch (const std::exception &e)
-    {
-        EXPECT_STREQ(e.what(), "hex::encode: not enough allocated length");
-    }
 }
 TEST(hex, encode_1e7)
 {
@@ -26,15 +33,11 @@ TEST(hex, decode)
 {
     std::vector<uint8_t> data = {0x61, 0x6e, 0x6f};
     EXPECT_EQ(decode("616e6f"), data);
-    try
+
-    {
+    EXPECT_THROW(decode("FFF", 3, data.data(), data.size()), std::logic_error);
-        std::string str = "";
+    EXPECT_THROW(decode("!@#!", 4, data.data(), data.size()), std::logic_error);
-        decode("616", 3, data.data(), data.size());
+    EXPECT_THROW(decode("FF", 2, data.data(), 0), std::length_error);
-    }
+    EXPECT_NO_THROW(decode("", 0, data.data(), 0));
-    catch (const std::exception &e)
-    {
-        EXPECT_STREQ(e.what(), "hex::decode: isn't hex");
-    }
 }
 TEST(hex, decode_1e7)
 {