File indexing completed on 2024-11-24 03:41:03

 /*
     This file is part of the KDE libraries
     SPDX-FileCopyrightText: 2021 Slava Aseev <nullptrnine@basealt.ru>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 #ifndef __TESTHELPERS_HPP__
 #define __TESTHELPERS_HPP__
 
 #include <../kwalletfreedesktopservice.h>
 #include <QTest>
 #include <string>
 #include <tuple>
 #include <vector>
 
 template<typename InputT, typename OutputT>
 using Testset = std::vector<std::pair<InputT, OutputT>>;
 
 template<typename T, typename Enable = void>
 struct EasyFormater {
     std::string operator()(const T &v) const
     {
         return std::string(v.toStdString());
     }
 };
 
 template<typename T>
 struct EasyFormater<T, typename std::enable_if<std::is_integral<T>::value || std::is_floating_point<T>::value>::type> {
     std::string operator()(T v) const
     {
         return std::to_string(v);
     }
 };
 
 template<>
 struct EasyFormater<FdoUniqueLabel> {
     std::string operator()(const FdoUniqueLabel &v) const
     {
         return "{" + v.label.toStdString() + ", " + std::to_string(v.copyId) + "}";
     }
 };
 
 template<>
 struct EasyFormater<EntryLocation> {
     std::string operator()(const EntryLocation &v) const
     {
         return "{" + v.folder.toStdString() + ", " + v.key.toStdString() + "}";
     }
 };
 
 template<bool Reverse>
 struct TestsetCmpHelper {
     template<typename F, typename T>
     bool cmp(F &&function, const T &pair)
     {
         return function(pair.first) == pair.second;
     }
     template<typename F, typename T>
     std::string format(F &&function, const T &pair)
     {
         using RetT = decltype(function(pair.first));
         return EasyFormater<typename T::first_type>()(pair.first) + " (evaluates to " + EasyFormater<RetT>()(function(pair.first)) + ") not equal with "
             + EasyFormater<typename T::second_type>()(pair.second);
     }
 };
 template<>
 struct TestsetCmpHelper<true> {
     template<typename F, typename T>
     bool cmp(F &&function, const T &pair)
     {
         return function(pair.second) == pair.first;
     }
     template<typename F, typename T>
     std::string format(F &&function, const T &pair)
     {
         using RetT = decltype(function(pair.second));
         return EasyFormater<typename T::second_type>()(pair.second) + " (evaluates to " + EasyFormater<RetT>()(function(pair.second)) + ") not equal with "
             + EasyFormater<typename T::first_type>()(pair.first);
     }
 };
 
 template<bool Reverse, typename F, typename I, typename O>
 void runTestsetTmpl(F &&function, const Testset<I, O> &labelMap)
 {
     for (auto &pair : labelMap) {
         bool ok = TestsetCmpHelper<Reverse>().cmp(function, pair);
         if (!ok) {
             std::string str = TestsetCmpHelper<Reverse>().format(function, pair);
             QVERIFY2(ok, str.c_str());
         }
     }
 }
 
 template<typename F, typename I, typename O>
 void runTestset(F &&function, const Testset<I, O> &labelMap)
 {
     return runTestsetTmpl<false>(std::forward<F>(function), labelMap);
 }
 
 template<typename F, typename I, typename O>
 void runRevTestset(F &&function, const Testset<I, O> &labelMap)
 {
     return runTestsetTmpl<true>(std::forward<F>(function), labelMap);
 }
 
 #endif // __TESTHELPERS_HPP__