qt_test_tools.h

Go to the documentation of this file.

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
#pragma once
#include <QString>
#include <QApplication>
#include <QTreeWidget>
#include <QThread>
#include <adtf_utils.h>
#include <adtfbase/exception_handling.h>
#include <chrono>
 
namespace adtf
{
namespace ui
{
namespace testing
{
namespace hollow
{

template<typename T>
T* find_qobject(const QString& strObjectName)
{
    auto fnFindObject = [&]() -> T*
    {
        for (auto pWidget : qApp->topLevelWidgets())
        {
            if (auto pFound = qobject_cast<T*>(pWidget))
            {
                if (strObjectName.isEmpty() || strObjectName == pFound->objectName())
                {
                    return pFound;
                }
            }
 
            if (auto pFound = pWidget->findChild<T*>(strObjectName))
            {
                return pFound;
            }
        }
 
        return nullptr;
    };
 
    T* pObject = nullptr;
 
    if (QThread::currentThread() == qApp->thread())
    {
        pObject = fnFindObject();
    }
    else
    {
        QMetaObject::invokeMethod(qApp, fnFindObject, Qt::BlockingQueuedConnection, &pObject);
    }
 
    if (!pObject)
    {
        THROW_ERROR_DESC(ERR_NOT_FOUND, "No widget with name %s and type %s.", strObjectName.toLocal8Bit().data(),
                         T::staticMetaObject.className());
    }
 
    return pObject;
}

QString dump_tree(const QTreeWidgetItem* pNode, size_t nColumnCount, QString strPrefix = "");

QString dump_tree(const QTreeWidget* pTree, size_t nColumnCount);

tResult compare_dump(const QString& strChecked, const QString& strExpected);

tResult wait_for_next_ui_timer(std::chrono::nanoseconds tmTimeout = std::chrono::nanoseconds{-1});
 
} // namespace hollow
 
namespace lucky
{

void schedule_in_gui_thread(std::function<void()> fnFunction);

tResult execute_in_gui_thread(std::function<tResult()> fnFunction,
                              std::chrono::milliseconds tmTimeout = std::chrono::milliseconds{0});
 
} // namespace lucky
 
namespace mega
{

tResult wait_for_next_idle(std::chrono::nanoseconds tmTimeout = std::chrono::nanoseconds{-1});

QAction* find_action(QMenu* pMenu, const QString& strName, bool bThrow = true);

void trigger_action(QAction* pAction, Qt::ConnectionType eConnectionType = Qt::BlockingQueuedConnection);

void trigger_action(const QString& strActionObjectName,
                    Qt::ConnectionType eConnectionType = Qt::BlockingQueuedConnection);
 
} // namespace mega
 
namespace nitro
{
QString dump_tree(const QAbstractItemModel* pTree,
                  size_t nColumnCount,
                  const QModelIndex oNode = QModelIndex(),
                  QString strPrefix = "");
} // namespace nitro
 
namespace v0
{
 
using hollow::find_qobject;
using hollow::dump_tree;
using hollow::compare_dump;
using hollow::wait_for_next_ui_timer;
using lucky::schedule_in_gui_thread;
using lucky::execute_in_gui_thread;
using mega::wait_for_next_idle;
using mega::find_action;
using mega::trigger_action;
using nitro::dump_tree;
 
} // namespace v0
 
namespace v2
{
    class cInitQt
    {
    private:
        std::unique_ptr<QApplication> m_pApp;
 
        // Member variables must stay alive as long as m_pApp exists.
        int m_argc;
        char* m_argv[2];
 
    public:
        cInitQt()
            : m_argc(1)
        {
            if (qApp)
            {
                throw std::runtime_error("QApplication already exists!");
            }
            // Static storage to prevent 'use-after-free' as QApplication
            // keeps a reference to these variables.
           
            m_argv[0] = const_cast<char*>("adtf_test");
            m_argv[1] = nullptr;
 
            m_pApp = std::make_unique<QApplication>(m_argc, m_argv);
        }

        cInitQt(const cInitQt&) = delete;

        cInitQt& operator=(const cInitQt&) = delete;
    };
}
 
using v0::find_qobject;
using v0::dump_tree;
using v0::compare_dump;
using v0::wait_for_next_ui_timer;
using v0::schedule_in_gui_thread;
using v0::execute_in_gui_thread;
using v0::wait_for_next_idle;
using v0::find_action;
using v0::trigger_action;
using v0::dump_tree;
 
using v2::cInitQt;
 
} // namespace testing
} // namespace ui
} // namespace adtf