New version 8.1.0

Add Codecov badge to README

.codecov.yml

@@ -0,0 +1,12 @@
+codecov:
+  notify:
+    require_ci_to_pass: yes
+
+coverage:
+  status:
+    project:
+      default:
+        threshold: 1%
+
+ignore:
+  - "test"

.travis.yml

@@ -31,6 +31,11 @@ addons:
       - gcc-mingw-w64-i686
       - gcc-mingw-w64-base
       - mingw-w64-tools
+      - gcovr
+  homebrew:
+    update: true
+    packages:
+      - gcovr
 matrix:
   include:
     - env: PLATFORM="native_dyn"

ChangeLog

@@ -1,3 +1,11 @@
+kiwix-lib 8.1.0
+===============
+
+ * Fix pathTools manipulation.
+ * Add missing implementation of getArticleCount and getMediaCount on android.
+ * Correctly convert windows path to utf8.
+ * Add code coverage in the CI
+
 kiwix-lib 8.0.1
 ===============
 

README.md

@@ -9,6 +9,7 @@ GNU/Linux, macOS, Android, iOS, ...).
 [![AUR version](https://img.shields.io/aur/version/kiwix-lib)](https://aur.archlinux.org/packages/kiwix-lib/)
 [![Build Status](https://travis-ci.org/kiwix/kiwix-lib.svg?branch=master)](https://travis-ci.org/kiwix/kiwix-lib)
 [![CodeFactor](https://www.codefactor.io/repository/github/kiwix/kiwix-lib/badge)](https://www.codefactor.io/repository/github/kiwix/kiwix-lib)
+[![Codecov](https://codecov.io/gh/kiwix/kiwix-lib/branch/master/graph/badge.svg)](https://codecov.io/gh/kiwix/kiwix-lib)
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
 
 Disclaimer

android-kiwix-lib-publisher/kiwixLibAndroid/build.gradle

@@ -26,7 +26,7 @@ task writePom {
     project {
         groupId 'org.kiwix.kiwixlib'
         artifactId 'kiwixlib'
-        version '8.0.1' + (System.env.KIWIXLIB_BUILDVERSION == null ? '' : '-'+System.env.KIWIXLIB_BUILDVERSION)
+        version '8.1.0' + (System.env.KIWIXLIB_BUILDVERSION == null ? '' : '-'+System.env.KIWIXLIB_BUILDVERSION)
         packaging 'aar'
         name 'kiwixlib'
         url 'https://github.com/kiwix/kiwix-lib'

include/tools/pathTools.h

@@ -25,9 +25,7 @@
 bool isRelativePath(const std::string& path);
 std::string computeAbsolutePath(const std::string& path, const std::string& relativePath);
 std::string computeRelativePath(const std::string& path, const std::string& absolutePath);
-std::string removeLastPathElement(const std::string& path,
-                                  const bool removePreSeparator = false,
-                                  const bool removePostSeparator = false);
+std::string removeLastPathElement(const std::string& path);
 std::string appendToDirectory(const std::string& directoryPath, const std::string& filename);
 
 unsigned int getFileSize(const std::string& path);

include/tools/stringTools.h

@@ -43,10 +43,7 @@ void loadICUExternalTables();
 std::string urlEncode(const std::string& value, bool encodeReserved = false);
 std::string urlDecode(const std::string& value, bool component = false);
 
-std::vector<std::string> split(const std::string&, const std::string&);
-std::vector<std::string> split(const char*, const char*);
-std::vector<std::string> split(const std::string&, const char*);
-std::vector<std::string> split(const char*, const std::string&);
+std::vector<std::string> split(const std::string&, const std::string&, bool trimEmpty = true);
 std::string join(const std::vector<std::string>& list, const std::string& sep);
 
 std::string ucAll(const std::string& word);

meson.build

@@ -1,5 +1,5 @@
 project('kiwix-lib', 'cpp',
-  version : '8.0.1', # Also change this in android-kiwix-lib-publisher/kiwixLibAndroid/build.gradle
+  version : '8.1.0', # Also change this in android-kiwix-lib-publisher/kiwixLibAndroid/build.gradle
   license : 'GPL',
   default_options : ['c_std=c11', 'cpp_std=c++11', 'werror=true'])
 

src/android/kiwixreader.cpp

@@ -424,6 +424,35 @@ Java_org_kiwix_kiwixlib_JNIKiwixReader_getDescription(JNIEnv* env, jobject obj)
   return description;
 }
 
+JNIEXPORT jint JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getArticleCount(JNIEnv* env, jobject obj)
+{
+  jint articleCount = 0;
+  try {
+    auto cArticleCount = READER->getArticleCount();
+    articleCount = c2jni(cArticleCount);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get article count.");
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+  }
+  return articleCount;
+}
+
+JNIEXPORT jint JNICALL
+Java_org_kiwix_kiwixlib_JNIKiwixReader_getMediaCount(JNIEnv* env, jobject obj)
+{
+  jint mediaCount = 0;
+  try {
+    auto cMediaCount = READER->getMediaCount();
+    mediaCount = c2jni(cMediaCount);
+  } catch (std::exception& e) {
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", "Unable to get media count.");
+    __android_log_print(ANDROID_LOG_ERROR, "kiwix", e.what());
+  }
+  return mediaCount;
+}
+
+
 JNIEXPORT jboolean JNICALL Java_org_kiwix_kiwixlib_JNIKiwixReader_getRandomPage(
     JNIEnv* env, jobject obj, jobject urlObj)
 {

src/aria2.cpp

@@ -49,7 +49,7 @@ Aria2::Aria2():
   m_secret = "token:"+m_secret;
 
   std::string aria2cmd = appendToDirectory(
-    removeLastPathElement(getExecutablePath(true), true, true),
+    removeLastPathElement(getExecutablePath(true)),
     ARIA2_CMD);
   if (fileExists(aria2cmd)) {
     // A local aria2c exe exists (packaged with kiwix-desktop), use it.

src/kiwixserve.cpp

@@ -36,7 +36,7 @@ void KiwixServe::run()
 
     std::vector<const char*> callCmd;
     std::string kiwixServeCmd = appendToDirectory(
-        removeLastPathElement(getExecutablePath(true), true, true),
+        removeLastPathElement(getExecutablePath(true)),
         KIWIXSERVE_CMD);
     if (fileExists(kiwixServeCmd)) {
         // A local kiwix-serve exe exists (packaged with kiwix-desktop), use it.

src/library.cpp

@@ -115,7 +115,7 @@ unsigned int Library::getBookCount(const bool localBooks,
 
 bool Library::writeToFile(const std::string& path)
 {
-  auto baseDir = removeLastPathElement(path, true, false);
+  auto baseDir = removeLastPathElement(path);
   LibXMLDumper dumper(this);
   dumper.setBaseDir(baseDir);
   return writeTextFile(path, dumper.dumpLibXMLContent(getBooksIds()));

src/manager.cpp

@@ -59,7 +59,7 @@ bool Manager::parseXmlDom(const pugi::xml_document& doc,
 
     book.setReadOnly(readOnly);
     book.updateFromXml(bookNode,
-                       removeLastPathElement(libraryPath, true, false));
+                       removeLastPathElement(libraryPath));
 
     /* Update the book properties with the new importer */
     if (libraryVersion.empty()
@@ -177,7 +177,7 @@ std::string Manager::addBookFromPathAndGetId(const std::string& pathToOpen,
     if (pathToSave != pathToOpen) {
       book.setPath(isRelativePath(pathToSave)
                 ? computeAbsolutePath(
-                      removeLastPathElement(writableLibraryPath, true, false),
+                      removeLastPathElement(writableLibraryPath),
                       pathToSave)
                 : pathToSave);
     }

src/tools/pathTools.cpp

@@ -39,11 +39,12 @@
 #include <fstream>
 #include <iomanip>
 #include <iostream>
+#include <algorithm>
 
 #ifdef _WIN32
-const std::string SEPARATOR("\\");
+  #define SEPARATOR "\\"
 #else
-const std::string SEPARATOR("/");
+  #define SEPARATOR "/"
 #include <unistd.h>
 #endif
 
@@ -53,6 +54,25 @@ const std::string SEPARATOR("/");
 #define PATH_MAX 1024
 #endif
 
+
+#ifdef _WIN32
+std::string WideToUtf8(const std::wstring& wstr)
+{
+  auto needed_size = WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr.size(), NULL, 0, NULL, NULL);
+  std::string ret(needed_size, 0);
+  WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr.size(), &ret[0], needed_size, NULL, NULL);
+  return ret;
+}
+
+std::wstring Utf8ToWide(const std::string& str)
+{
+  auto needed_size = MultiByteToWideChar(CP_UTF8, 0, str.data(), str.size(), NULL, 0);
+  std::wstring ret(needed_size, 0);
+  MultiByteToWideChar(CP_UTF8, 0, str.data(), str.size(), &ret[0], needed_size);
+  return ret;
+}
+#endif
+
 bool isRelativePath(const std::string& path)
 {
 #ifdef _WIN32
@@ -62,11 +82,65 @@ bool isRelativePath(const std::string& path)
 #endif
 }
 
+std::vector<std::string> normalizeParts(std::vector<std::string> parts, bool absolute)
+{
+  std::vector<std::string> ret;
+#ifdef _WIN32
+  //Special case if we have a drive directory not at first.
+  //Starts from there.
+  auto it = find_if(parts.rbegin(), parts.rend(),
+                    [](const std::string& p) ->bool
+                      { return p.length() == 2 && p[1] == ':'; });
+  if (it != parts.rend()) {
+    parts.erase(parts.begin(), it.base()-1);
+  }
+#endif
+
+  size_t index = 0;
+  for (auto& part: parts) {
+    index++;
+    if (part == "..") {
+      if (absolute) {
+        // We try to remove as far as possible.
+        if (ret.size() > 1) {
+          ret.pop_back();
+        }
+      } else {
+        // We remove only if we can remove it.
+        // Else we add it.
+        if (!ret.empty() && ret.back() != "..") {
+          ret.pop_back();
+        } else {
+          ret.push_back("..");
+        }
+      }
+      continue;
+    }
+    if (part == "") {
+#ifndef _WIN32
+      if (ret.empty() && (absolute || index<parts.size())) {
+        ret.push_back("");
+      }
+#endif
+      continue;
+    }
+    if (part == ".") {
+      continue;
+    }
+    ret.push_back(part);
+  }
+#ifndef _WIN32
+  if (absolute && ret.size() == 1 && ret.back() == "") {
+    ret.push_back("");
+  }
+#endif
+  return ret;
+}
+
 std::string computeRelativePath(const std::string& path, const std::string& absolutePath)
 {
-  std::vector<std::string> pathParts = kiwix::split(path, SEPARATOR);
-  std::vector<std::string> absolutePathParts
-      = kiwix::split(absolutePath, SEPARATOR);
+  auto pathParts = normalizeParts(kiwix::split(path, SEPARATOR, false), false);
+  auto absolutePathParts = kiwix::split(absolutePath, SEPARATOR, false);
 
   unsigned int commonCount = 0;
   while (commonCount < pathParts.size()
@@ -75,108 +149,60 @@ std::string computeRelativePath(const std::string& path, const std::string& abso
       commonCount++;
   }
 
-  std::string relativePath;
-#ifdef _WIN32
-  /* On Windows you have a token more because the root is represented
-     by a letter */
-  if (commonCount == 0) {
-    relativePath = ".." + SEPARATOR;
-  }
-#endif
-
+  std::vector<std::string> relativeParts;
   for (unsigned int i = commonCount; i < pathParts.size(); i++) {
-    relativePath += ".." + SEPARATOR;
+    relativeParts.push_back("..");
   }
   for (unsigned int i = commonCount; i < absolutePathParts.size(); i++) {
-    relativePath += absolutePathParts[i];
-    relativePath += i + 1 < absolutePathParts.size() ? SEPARATOR : "";
+    relativeParts.push_back(absolutePathParts[i]);
   }
-  return relativePath;
+  auto ret = kiwix::join(normalizeParts(relativeParts, false), SEPARATOR);
+  return ret;
 }
 
-#ifdef _WIN32
-# define STRTOK strtok_s
-#else
-# define STRTOK strtok_r
-#endif
-
-/* Warning: the relative path must be with slashes */
 std::string computeAbsolutePath(const std::string& path, const std::string& relativePath)
 {
-  std::string absolutePath;
-
+  std::string absolutePath = path;
   if (path.empty()) {
-    char* path = NULL;
-    size_t size = 0;
-
-#ifdef _WIN32
-    path = _getcwd(path, size);
-#else
-    path = getcwd(path, size);
-#endif
-
-    absolutePath = std::string(path) + SEPARATOR;
-  } else {
-    absolutePath = path.substr(path.length() - 1, 1) == SEPARATOR
-                       ? path
-                       : path + SEPARATOR;
+    absolutePath = getCurrentDirectory();
   }
 
-#if _WIN32
-  char* cRelativePath = _strdup(relativePath.c_str());
-#else
-  char* cRelativePath = strdup(relativePath.c_str());
-#endif
-  char* saveptr = nullptr;
-  char* token = STRTOK(cRelativePath, "/", &saveptr);
+  auto absoluteParts = normalizeParts(kiwix::split(absolutePath, SEPARATOR, false), true);
+  auto relativeParts = kiwix::split(relativePath, SEPARATOR, false);
 
-  while (token != NULL) {
-    if (std::string(token) == "..") {
-      absolutePath = removeLastPathElement(absolutePath, true, false);
-      token = STRTOK(NULL, "/", &saveptr);
-    } else if (strcmp(token, ".") && strcmp(token, "")) {
-      absolutePath += std::string(token);
-      token = STRTOK(NULL, "/", &saveptr);
-      if (token != NULL) {
-        absolutePath += SEPARATOR;
-      }
-    } else {
-      token = STRTOK(NULL, "/", &saveptr);
-    }
-  }
-  free(cRelativePath);
-
-  return absolutePath;
+  absoluteParts.insert(absoluteParts.end(), relativeParts.begin(), relativeParts.end());
+  auto ret = kiwix::join(normalizeParts(absoluteParts, true), SEPARATOR);
+  return ret;
 }
 
-std::string removeLastPathElement(const std::string& path,
-                                  const bool removePreSeparator,
-                                  const bool removePostSeparator)
+std::string removeLastPathElement(const std::string& path)
 {
-  std::string newPath = path;
-  size_t offset = newPath.find_last_of(SEPARATOR);
-  if (removePreSeparator &&
-#ifndef _WIN32
-      offset != newPath.find_first_of(SEPARATOR) &&
-#endif
-      offset == newPath.length() - 1) {
-    newPath = newPath.substr(0, offset);
-    offset = newPath.find_last_of(SEPARATOR);
+  auto parts = normalizeParts(kiwix::split(path, SEPARATOR, false), false);
+  if (!parts.empty()) {
+    parts.pop_back();
   }
-  newPath = removePostSeparator ? newPath.substr(0, offset)
-                                : newPath.substr(0, offset + 1);
-  return newPath;
+  auto ret = kiwix::join(parts, SEPARATOR);
+  return ret;
 }
 
 std::string appendToDirectory(const std::string& directoryPath, const std::string& filename)
 {
-  std::string newPath = directoryPath + SEPARATOR + filename;
+  std::string newPath = directoryPath;
+  if (!directoryPath.empty() && directoryPath.back() != SEPARATOR[0]) {
+    newPath += SEPARATOR;
+  }
+  newPath += filename;
   return newPath;
 }
 
 std::string getLastPathElement(const std::string& path)
 {
-  return path.substr(path.find_last_of(SEPARATOR) + 1);
+  auto parts = normalizeParts(kiwix::split(path, SEPARATOR), false);
+  if (parts.empty()) {
+    return "";
+  }
+  auto ret = parts.back();
+  return ret;
 }
 
 unsigned int getFileSize(const std::string& path)
@@ -216,7 +242,7 @@ std::string getFileContent(const std::string& path)
 bool fileExists(const std::string& path)
 {
 #ifdef _WIN32
-  return PathFileExists(path.c_str());
+  return PathFileExistsW(Utf8ToWide(path).c_str());
 #else
   bool flag = false;
   std::fstream fin;
@@ -232,7 +258,7 @@ bool fileExists(const std::string& path)
 bool makeDirectory(const std::string& path)
 {
 #ifdef _WIN32
-  int status = _mkdir(path.c_str());
+  int status = _wmkdir(Utf8ToWide(path).c_str());
 #else
   int status = mkdir(path.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
 #endif
@@ -242,15 +268,15 @@ bool makeDirectory(const std::string& path)
 std::string makeTmpDirectory()
 {
 #ifdef _WIN32
-  char cbase[MAX_PATH];
-  char ctmp[MAX_PATH];
-  GetTempPath(MAX_PATH-14, cbase);
+  wchar_t cbase[MAX_PATH];
+  wchar_t ctmp[MAX_PATH];
+  GetTempPathW(MAX_PATH-14, cbase);
   // This create a file for us, ensure it is unique.
   // So we need to delete it and create the directory using the same name.
-  GetTempFileName(cbase, "kiwix", 0, ctmp);
-  DeleteFile(ctmp);
-  _mkdir(ctmp);
-  return std::string(ctmp);
+  GetTempFileNameW(cbase, L"kiwix", 0, ctmp);
+  DeleteFileW(ctmp);
+  _wmkdir(ctmp);
+  return WideToUtf8(ctmp);
 #else
   char _template_array[] = {"/tmp/kiwix-lib_XXXXXX"};
   std::string dir = mkdtemp(_template_array);
@@ -281,34 +307,36 @@ bool copyFile(const std::string& sourcePath, const std::string& destPath)
 
 std::string getExecutablePath(bool realPathOnly)
 {
-  char binRootPath[PATH_MAX];
-
   if (!realPathOnly) {
     char* cAppImage = ::getenv("APPIMAGE");
     if (cAppImage) {
       char* cArgv0 = ::getenv("ARGV0");
       char* cOwd = ::getenv("OWD");
       if (cArgv0 && cOwd) {
-        return appendToDirectory(cOwd, cArgv0);
+        auto ret = appendToDirectory(cOwd, cArgv0);
+        return ret;
       }
     }
   }
 
 #ifdef _WIN32
-  GetModuleFileName(NULL, binRootPath, PATH_MAX);
-  return std::string(binRootPath);
+  std::wstring binRootPath(PATH_MAX, 0);
+  GetModuleFileNameW(NULL, &binRootPath[0], PATH_MAX);
+  std::string ret = WideToUtf8(binRootPath);
+  return ret;
 #elif __APPLE__
+  char binRootPath[PATH_MAX];
   uint32_t max = (uint32_t)PATH_MAX;
   _NSGetExecutablePath(binRootPath, &max);
   return std::string(binRootPath);
 #else
+  char binRootPath[PATH_MAX];
   ssize_t size = readlink("/proc/self/exe", binRootPath, PATH_MAX);
   if (size != -1) {
     return std::string(binRootPath, size);
   }
-#endif
-
   return "";
+#endif
 }
 
 bool writeTextFile(const std::string& path, const std::string& content)
@@ -322,10 +350,16 @@ bool writeTextFile(const std::string& path, const std::string& content)
 
 std::string getCurrentDirectory()
 {
-  char* a_cwd = getcwd(NULL, 0);
-  std::string s_cwd(a_cwd);
+#ifdef _WIN32
+  wchar_t* a_cwd = _wgetcwd(NULL, 0);
+  std::string ret = WideToUtf8(a_cwd);
   free(a_cwd);
-  return s_cwd;
+#else
+  char* a_cwd = getcwd(NULL, 0);
+  std::string ret(a_cwd);
+  free(a_cwd);
+#endif
+  return ret;
 }
 
 std::string getDataDirectory()
@@ -336,8 +370,9 @@ std::string getDataDirectory()
   char* cDataDir = ::getenv("KIWIX_DATA_DIR");
 #endif
   std::string dataDir = cDataDir==nullptr ? "" : cDataDir;
-  if (!dataDir.empty())
+  if (!dataDir.empty()) {
     return dataDir;
+  }
 #ifdef _WIN32
   cDataDir = ::getenv("USERPROFILE");
   dataDir = cDataDir==nullptr ? getCurrentDirectory() : cDataDir;
@@ -351,7 +386,8 @@ std::string getDataDirectory()
     dataDir = appendToDirectory(dataDir, "share");
   }
 #endif
-  return appendToDirectory(dataDir, "kiwix");
+  auto ret = appendToDirectory(dataDir, "kiwix");
+  return ret;
 }
 
 static std::map<std::string, std::string> extMimeTypes = {

src/tools/stringTools.cpp

@@ -267,37 +267,28 @@ std::string kiwix::urlDecode(const std::string& value, bool component)
 
 /* Split string in a token array */
 std::vector<std::string> kiwix::split(const std::string& str,
-                                      const std::string& delims = " *-")
+                                      const std::string& delims,
+                                      bool trimEmpty)
 {
-  std::string::size_type lastPos = str.find_first_not_of(delims, 0);
-  std::string::size_type pos = str.find_first_of(delims, lastPos);
+  std::string::size_type lastPos = 0;
+  std::string::size_type pos = 0;
   std::vector<std::string> tokens;
-
-  while (std::string::npos != pos || std::string::npos != lastPos) {
-    tokens.push_back(str.substr(lastPos, pos - lastPos));
-    lastPos = str.find_first_not_of(delims, pos);
-    pos = str.find_first_of(delims, lastPos);
+  while( (pos = str.find_first_of(delims, lastPos)) < str.length() )
+  {
+    auto token = str.substr(lastPos, pos - lastPos);
+    if (!trimEmpty || !token.empty()) {
+      tokens.push_back(token);
+    }
+    lastPos = pos + 1;
   }
 
+  auto token = str.substr(lastPos);
+  if (!trimEmpty || !token.empty()) {
+    tokens.push_back(token);
+  }
   return tokens;
 }
 
-std::vector<std::string> kiwix::split(const char* lhs, const char* rhs)
-{
-  const std::string m1(lhs), m2(rhs);
-  return split(m1, m2);
-}
-
-std::vector<std::string> kiwix::split(const char* lhs, const std::string& rhs)
-{
-  return split(lhs, rhs.c_str());
-}
-
-std::vector<std::string> kiwix::split(const std::string& lhs, const char* rhs)
-{
-  return split(lhs.c_str(), rhs);
-}
-
 std::string kiwix::join(const std::vector<std::string>& list, const std::string& sep)
 {
   std::stringstream ss;

test/meson.build

@@ -5,7 +5,8 @@ tests = [
     'library',
     'regex',
     'tagParsing',
-    'stringTools'
+    'stringTools',
+    'pathTools'
 ]
 
 

test/pathTools.cpp

@@ -0,0 +1,234 @@
+/*
+ * Copyright (C) 2019 Matthieu Gautier
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and
+ * NON-INFRINGEMENT.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ */
+
+#include "gtest/gtest.h"
+#include <string>
+#include <vector>
+#include "../include/tools/pathTools.h"
+
+#ifdef _WIN32
+# define S "\\"
+# define AS "c:"
+#else
+# define S "/"
+# define AS ""
+#endif
+
+#define P2(a, b) a S b
+#define P3(a, b, c) P2(P2(a, b), c)
+#define P4(a, b, c, d) P2(P3(a, b, c), d)
+#define P5(a, b, c, d, e) P2(P4(a, b, c, d), e)
+#define P6(a, b, c, d, e, f) P2(P5(a, b, c ,d, e), f)
+
+#define A1(a) P2(AS,a)
+#define A2(a, b) A1(P2(a, b))
+#define A3(a, b, c) A1(P3(a, b, c))
+#define A4(a, b, c, d) A1(P4(a, b, c, d))
+#define A5(a, b, c, d, e) A1(P5(a, b, c, d, e))
+
+std::vector<std::string> normalizeParts(std::vector<std::string> parts, bool absolute);
+#ifdef _WIN32
+std::wstring Utf8ToWide(const std::string& str);
+std::string WideToUtf8(const std::wstring& wstr);
+#endif
+
+namespace
+{
+
+#define V std::vector<std::string>
+TEST(pathTools, normalizePartsAbsolute)
+{
+#define N(...) normalizeParts(__VA_ARGS__, true)
+  ASSERT_EQ(N({}), V({}));
+#ifdef _WIN32
+  ASSERT_EQ(N({"c:"}), V({"c:"}));
+#else
+  ASSERT_EQ(N({""}), V({"", ""}));
+#endif
+  ASSERT_EQ(N({AS, "a"}), V({AS, "a"}));
+  ASSERT_EQ(N({AS, "a", "b"}), V({AS, "a", "b"}));
+  ASSERT_EQ(N({AS, "a", "b", ".."}), V({AS, "a"}));
+#ifdef _WIN32
+  ASSERT_EQ(N({AS, "a", "b", "..", ".."}), V({AS}));
+#else
+  ASSERT_EQ(N({AS, "a", "b", "..", ".."}), V({AS, ""}));
+#endif
+  ASSERT_EQ(N({AS, "a", "b", "..", "..", "..", "foo"}), V({AS, "foo"}));
+  ASSERT_EQ(N({AS, "..", "..", "c", "d", ".", "..", "foo"}), V({AS, "c", "foo"}));
+  ASSERT_EQ(N({AS, "a", "b", ".", "c", "d", "..", "foo"}), V({AS, "a", "b", "c", "foo"}));
+
+#ifdef _WIN32
+  ASSERT_EQ(N({"c:", "a", "b", ".", "c", "d:", "..", "foo"}), V({"d:", "foo"}));
+#endif
+#undef N
+}
+
+TEST(pathTools, normalizePartsRelative)
+{
+#define N(...) normalizeParts(__VA_ARGS__, false)
+  ASSERT_EQ(N({}), V({}));
+  ASSERT_EQ(N({""}), V({}));
+  ASSERT_EQ(N({"a"}), V({"a"}));
+  ASSERT_EQ(N({"a", "b"}), V({"a", "b"}));
+  ASSERT_EQ(N({"a", "b", ".."}), V({"a"}));
+  ASSERT_EQ(N({"a", "b", "..", ".."}), V({}));
+  ASSERT_EQ(N({"a", "b", "..", "..", "..", "foo"}), V({"..", "foo"}));
+  ASSERT_EQ(N({"..", "..", "c", "d", ".", "..", "foo"}), V({"..", "..", "c", "foo"}));
+  ASSERT_EQ(N({"a", "b", ".", "c", "d", "..", "foo"}), V({"a", "b", "c", "foo"}));
+#undef N
+}
+
+TEST(pathTools, isRelativePath)
+{
+  ASSERT_TRUE(isRelativePath("foo"));
+  ASSERT_TRUE(isRelativePath(P2("foo","bar")));
+  ASSERT_TRUE(isRelativePath(P3(".","foo","bar")));
+  ASSERT_TRUE(isRelativePath(P2("..","foo")));
+  ASSERT_TRUE(isRelativePath(P4("foo","","bar","")));
+  ASSERT_FALSE(isRelativePath(A1("foo")));
+  ASSERT_FALSE(isRelativePath(A2("foo", "bar")));
+}
+
+TEST(pathTools, computeAbsolutePath)
+{
+  ASSERT_EQ(computeAbsolutePath(A2("a","b"), "foo"),
+            A3("a","b","foo"));
+  ASSERT_EQ(computeAbsolutePath(A3("a","b",""), "foo"),
+            A3("a","b","foo"));
+  ASSERT_EQ(computeAbsolutePath(A2("a","b"), P2(".","foo")),
+            A3("a","b","foo"));
+  ASSERT_EQ(computeAbsolutePath(A2("a","b"), P2("..","foo")),
+            A2("a","foo"));
+  ASSERT_EQ(computeAbsolutePath(A3("a","b",""), P2("..","foo")),
+            A2("a","foo"));
+  ASSERT_EQ(computeAbsolutePath(A5("a","b","c","d","e"), P2("..","foo")),
+            A5("a","b","c","d","foo"));
+  ASSERT_EQ(computeAbsolutePath(A5("a","b","c","d","e"), P5("..","..","..","g","foo")),
+            A4("a","b","g","foo"));
+}
+
+TEST(pathTools, computeRelativePath)
+{
+  ASSERT_EQ(computeRelativePath(A2("a","b"), A3("a","b","foo")),
+            "foo");
+  ASSERT_EQ(computeRelativePath(A3("a","b",""), A3("a","b","foo")),
+            "foo");
+  ASSERT_EQ(computeRelativePath(A2("a","b"), A2("a","foo")),
+            P2("..","foo"));
+  ASSERT_EQ(computeRelativePath(A3("a","b",""), A2("a","foo")),
+            P2("..","foo"));
+  ASSERT_EQ(computeRelativePath(A5("a","b","c","d","e"), A5("a","b","c","d","foo")),
+            P2("..","foo"));
+  ASSERT_EQ(computeRelativePath(A5("a","b","c","d","e"), A4("a","b","g","foo")),
+            P5("..","..","..","g","foo"));
+}
+
+TEST(pathTools, removeLastPathElement)
+{
+  ASSERT_EQ(removeLastPathElement(P3("a","b","c")),
+            P2("a","b"));
+  ASSERT_EQ(removeLastPathElement(A3("a","b","c")),
+            A2("a","b"));
+  ASSERT_EQ(removeLastPathElement(P4("a","b","c","")),
+            P2("a","b"));
+  ASSERT_EQ(removeLastPathElement(A4("a","b","c","")),
+            A2("a","b"));
+}
+
+TEST(pathTools, appendToDirectory)
+{
+  ASSERT_EQ(appendToDirectory(P3("a","b","c"), "foo.xml"),
+            P4("a","b","c","foo.xml"));
+  ASSERT_EQ(appendToDirectory(P4("a","b","c",""), "foo.xml"),
+            P4("a","b","c","foo.xml"));
+  ASSERT_EQ(appendToDirectory(P3("a","b","c"), P2("d","foo.xml")),
+            P5("a","b","c","d","foo.xml"));
+  ASSERT_EQ(appendToDirectory(P4("a","b","c",""), P2("d","foo.xml")),
+            P5("a","b","c","d","foo.xml"));
+  ASSERT_EQ(appendToDirectory(P3("a","b","c"), P2(".","foo.xml")),
+            P5("a","b","c",".","foo.xml"));
+  ASSERT_EQ(appendToDirectory(P4("a","b","c",""), P2(".","foo.xml")),
+            P5("a","b","c",".","foo.xml"));
+}
+
+
+TEST(pathTools, goUp)
+{
+  ASSERT_EQ(computeAbsolutePath(A3("a","b","c"), ".."),
+            A2("a", "b"));
+  ASSERT_EQ(computeAbsolutePath(A3("a","b","c"), P2("..","..")),
+            A1("a"));
+#ifdef _WIN32
+  ASSERT_EQ(computeAbsolutePath(A3("a","b","c"), P3("..","..","..")),
+            "c:");
+  ASSERT_EQ(computeAbsolutePath(A3("a","b","c"), P4("..","..","..","..")),
+            "c:");
+#else
+  ASSERT_EQ(computeAbsolutePath(A3("a","b","c"), P3("..","..","..")),
+            "/");
+  ASSERT_EQ(computeAbsolutePath(A3("a","b","c"), P4("..","..","..","..")),
+            "/");
+#endif
+
+
+  ASSERT_EQ(computeAbsolutePath(A3("a","b","c"), P2("..", "foo")),
+            A3("a", "b","foo"));
+  ASSERT_EQ(computeAbsolutePath(A3("a","b","c"), P3("..","..","foo")),
+            A2("a","foo"));
+  ASSERT_EQ(computeAbsolutePath(A3("a","b","c"), P4("..","..","..","foo")),
+            A1("foo"));
+  ASSERT_EQ(computeAbsolutePath(A3("a","b","c"), P5("..","..","..","..","foo")),
+            A1("foo"));
+}
+
+
+#ifdef _WIN32
+TEST(pathTools, dirChange)
+{
+  std::string p1("c:\\a\\b\\c");
+  std::string p2("d:\\d\\e\\foo.xml");
+  std::string relative_path = computeRelativePath(p1, p2);
+  ASSERT_EQ(relative_path, "d:\\d\\e\\foo.xml");
+  std::string abs_path = computeAbsolutePath(p1, relative_path);
+  ASSERT_EQ(abs_path, p2);
+  ASSERT_EQ(computeAbsolutePath(p1, "..\\..\\..\\..\\..\\d:\\d\\e\\foo.xml"), p2);
+}
+
+TEST(pathTools, Utf8ToWide)
+{
+  ASSERT_EQ(Utf8ToWide(u8""), L"");
+  ASSERT_EQ(Utf8ToWide(u8"test"), L"test");
+  ASSERT_EQ(Utf8ToWide(u8"testé`œà"), L"testé`œà");
+}
+
+TEST(pathTools, WideToUtf8)
+{
+  ASSERT_EQ(WideToUtf8(L""), u8"");
+  ASSERT_EQ(WideToUtf8(L"test"), u8"test");
+  ASSERT_EQ(WideToUtf8(L"testé`œà"), u8"testé`œà");
+}
+#endif
+
+
+};
+int main(int argc, char** argv)
+{
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}

test/stringTools.cpp

@@ -23,6 +23,7 @@
 
 namespace kiwix {
 std::string join(const std::vector<std::string>& list, const std::string& sep);
+std::vector<std::string> split(const std::string&  base, const std::string& sep, bool trimEmpty);
 };
 
 using namespace kiwix;
@@ -36,6 +37,22 @@ TEST(stringTools, join)
   ASSERT_EQ(join(list, ";"), "a;b;c");
 }
 
+TEST(stringTools, split)
+{
+  std::vector<std::string> list1 = { "a", "b", "c" };
+  ASSERT_EQ(split("a;b;c", ";", false), list1);
+  ASSERT_EQ(split("a;b;c", ";", true), list1);
+  std::vector<std::string> list2 = { "", "a", "b", "c" };
+  ASSERT_EQ(split(";a;b;c", ";", false), list2);
+  ASSERT_EQ(split(";a;b;c", ";", true), list1);
+  std::vector<std::string> list3 = { "", "a", "b", "c", ""};
+  ASSERT_EQ(split(";a;b;c;", ";", false), list3);
+  ASSERT_EQ(split(";a;b;c;", ";", true), list1);
+  std::vector<std::string> list4 = { "", "a", "b", "", "c", ""};
+  ASSERT_EQ(split(";a;b;;c;", ";", false), list4);
+  ASSERT_EQ(split(";a;b;;c;", ";", true), list1);
+}
+
 };
 int main(int argc, char** argv)
 {

travis/compile.sh

@@ -38,6 +38,10 @@ else
   export PKG_CONFIG_PATH=${INSTALL_DIR}/lib/x86_64-linux-gnu/pkgconfig
 fi
 export CPPFLAGS="-I${INSTALL_DIR}/include"
+if [[ "$TEST" == "1" ]]
+then
+    MESON_OPTION="${MESON_OPTION} -Db_coverage=true"
+fi
 meson . build ${MESON_OPTION}
 cd build
 ninja
@@ -45,5 +49,9 @@ if [[ "$TEST" == "1" ]]
 then
   echo "Running test"
   export LD_LIBRARY_PATH=${INSTALL_DIR}/lib:${INSTALL_DIR}/lib64:${INSTALL_DIR}/lib/x86_64-linux-gnu
-  ninja test
+  meson test --verbose
+  ninja coverage
+  cd ..
+  echo "*** Publish code coverage"
+  bash <(curl -s https://codecov.io/bash)
 fi