Test.h

#pragma once
 
#include <QtTest/QtTest>
 
#include "BigNumber.h"
#include "Timestamp.h"
#include "ReturnValue.h"
#include "Uri.h"
#include "Unit.h"
#include "Value.h"
 
namespace QTest
{
  inline bool qCompare(knowCore::Uri const &t1, const char* const &t2, const char *actual, const char *expected,
                      const char *file, int line)
  {
    return qCompare((QString)t1, QString::fromUtf8(t2), actual, expected, file, line);
  }
}
 
namespace knowCore
{
  inline char *toString(const knowCore::Uri &t)
  {
      return QTest::toString((QString)t);
  }
  inline char *toString(const knowCore::Timestamp &t)
  {
      return QTest::toString(t.toEpoch<knowCore::NanoSeconds>().count());
  }
  inline char *toString(const knowCore::BigNumber &t)
  {
      return QTest::toString(t.toString());
  }
  inline char *toString(const knowCore::Value &t)
  {
    auto const [success, result, error] = t.printable();
    if(success) {
      return QTest::toString(result);
    } else {
      return QTest::toString(error);
    }
  }
  template<typename _T_>
  inline char *toString(const ReturnValue<_T_>& _t)
  {
    if(_t.success())
    {
      return QTest::toString(_t.value());
    } else {
      return toString(_t.message());
    }
  }
  inline char *toString(const knowCore::Unit &t)
  {
    return t.isValid() ? QTest::toString(t.symbol()) : QTest::toString("invalid unit");
  }
}
 
#define KNOWCORE_TEST_WAIT_FOR_ACT(_CONDITION_, _ACT_)                          \
  for(int i = 0; i < 2000; ++i)                                                 \
  {                                                                             \
    QThread::msleep(10);                                                        \
    {_ACT_}                                                                     \
    auto ___expr___ = clog_eval_expr(_CONDITION_);                              \
    if(___expr___.value()) break;                                               \
    if((i % 100) == 0)                                                          \
    {                                                                           \
      KNOWCORE_LOG_INFO("Waiting for: {} since {}s", ___expr___, i/100);        \
    }                                                                           \
  }(void)0
 
 
#define KNOWCORE_TEST_WAIT_FOR(_CONDITION_)   \
  KNOWCORE_TEST_WAIT_FOR_ACT(_CONDITION_, )
 
 
#define KNOWCORE_TEST_VERIFY_SUCCESS_VOID(_EXPR_)                                             \
  do {                                                                                        \
    auto const [__success__, __message__] = (_EXPR_);                                         \
    if (!QTest::qVerify(static_cast<bool>(__success__), #_EXPR_, qPrintable(__message__),     \
                        __FILE__, __LINE__))                                                  \
      return;                                                                                 \
  } while (false)
 
 
#define KNOWCORE_TEST_VERIFY_FAILURE_VOID(_EXPR_)                                             \
  do {                                                                                        \
    auto const [__success__, __message__] = (_EXPR_);                                         \
    if (!QTest::qVerify(static_cast<bool>(!__success__), #_EXPR_,                             \
                        qPrintable("Call succeeded, expected failure."),                      \
                        __FILE__, __LINE__))                                                  \
      return;                                                                                 \
  } while (false)
 
#define KNOWCORE_TEST_VERIFY_SUCCESS(_EXPR_)                                            \
  ([&]() {                                                                              \
    auto const [__success__, __result__, __message__] = (_EXPR_);                       \
    QTest::qVerify(__success__, #_EXPR_, qPrintable(__message__), __FILE__, __LINE__);  \
    if(not __success__)                                                                 \
    {                                                                                   \
      throw(std::runtime_error(__message__.toStdString()));                             \
    }                                                                                   \
    return __result__;                                                                  \
  })()
 
#define KNOWCORE_TEST_VERIFY_FAILURE(_EXPR_)                                                \
  ([&]() {                                                                                  \
    auto const [__success__, __result__, __message__] = (_EXPR_);                           \
    QTest::qVerify(not __success__, #_EXPR_,                                                \
                   qPrintable("Call succeeded, expected failure."), __FILE__, __LINE__);    \
    if(__success__)                                                                         \
    {                                                                                       \
      throw(std::runtime_error(__message__.toStdString()));                                 \
    }                                                                                       \
    return __result__;                                                                      \
  })()
 
#define KNOWCORE_TEST_VERIFY_COMPARE(_EXPR_, _EXPECTED_)                                      \
  do {                                                                                        \
    auto const [__success__, __result__, __message__] = (_EXPR_);                             \
    if (!QTest::qVerify(static_cast<bool>(__success__), #_EXPR_, qPrintable(__message__),     \
                        __FILE__, __LINE__))                                                  \
      return;                                                                                 \
    if (!QTest::qCompare(__result__, _EXPECTED_, #_EXPR_, #_EXPECTED_, __FILE__, __LINE__))   \
      return;                                                                                 \
  } while (false)