tst_proxy.cpp - mozsearch

qt/qtgraphs/tests/auto/cpptest/qgsurface-modelproxy/tst_proxy.cpp (file symbol)

Enable keyboard shortcuts

Revision control

Copy as Markdown

// Copyright (C) 2023 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

#include <QtTest/QtTest>

#include <QtGraphs/QItemModelSurfaceDataProxy>

#include <QtGraphsWidgets/q3dsurfacewidgetitem.h>

#include <QtWidgets/QTableWidget>

#include "cpptestutil.h"

class tst_proxy: public QObject

    Q_OBJECT

private slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

    void construct();

    void initialProperties();

    void initializeProperties();

    void multiMatch();

private:

    QItemModelSurfaceDataProxy *m_proxy;

    QSurface3DSeries *m_series;

};

void tst_proxy::initTestCase()

void tst_proxy::cleanupTestCase()

void tst_proxy::init()

    m_proxy = new QItemModelSurfaceDataProxy();

    m_series = new QSurface3DSeries(m_proxy);

void tst_proxy::cleanup()

    delete m_series;

    m_proxy = 0; // proxy gets deleted with series

void tst_proxy::construct()

    QItemModelSurfaceDataProxy *proxy = new QItemModelSurfaceDataProxy();

    QVERIFY(proxy);

    QSurface3DSeries *series = new QSurface3DSeries(proxy);

    QVERIFY(series);

    delete series;

    proxy = 0; // proxy gets deleted with series

    QTableWidget table;

    proxy = new QItemModelSurfaceDataProxy(table.model());

    series = new QSurface3DSeries(proxy);

    QVERIFY(proxy);

    QVERIFY(series);

    delete series;

    proxy = 0; // proxy gets deleted with series

    proxy = new QItemModelSurfaceDataProxy(table.model(), "y");

    QVERIFY(proxy);

    series = new QSurface3DSeries(proxy);

    QVERIFY(series);

    QCOMPARE(proxy->rowRole(), QString(""));

    QCOMPARE(proxy->columnRole(), QString(""));

    QCOMPARE(proxy->xPosRole(), QString(""));

    QCOMPARE(proxy->yPosRole(), QString("y"));

    QCOMPARE(proxy->zPosRole(), QString(""));

    QCOMPARE(proxy->rowCategories().size(), 0);

    QCOMPARE(proxy->columnCategories().size(), 0);

    delete series;

    proxy = 0; // proxy gets deleted with series

    proxy = new QItemModelSurfaceDataProxy(table.model(), "row", "column", "y");

    QVERIFY(proxy);

    series = new QSurface3DSeries(proxy);

    QVERIFY(series);

    QCOMPARE(proxy->rowRole(), QString("row"));

    QCOMPARE(proxy->columnRole(), QString("column"));

    QCOMPARE(proxy->xPosRole(), QString("column"));

    QCOMPARE(proxy->yPosRole(), QString("y"));

    QCOMPARE(proxy->zPosRole(), QString("row"));

    QCOMPARE(proxy->rowCategories().size(), 0);

    QCOMPARE(proxy->columnCategories().size(), 0);

    delete series;

    proxy = 0; // proxy gets deleted with series

    proxy = new QItemModelSurfaceDataProxy(table.model(), "row", "column", "x", "y", "z");

    QVERIFY(proxy);

    series = new QSurface3DSeries(proxy);

    QVERIFY(series);

    QCOMPARE(proxy->rowRole(), QString("row"));

    QCOMPARE(proxy->columnRole(), QString("column"));

    QCOMPARE(proxy->xPosRole(), QString("x"));

    QCOMPARE(proxy->yPosRole(), QString("y"));

    QCOMPARE(proxy->zPosRole(), QString("z"));

    QCOMPARE(proxy->rowCategories().size(), 0);

    QCOMPARE(proxy->columnCategories().size(), 0);

    delete series;

    proxy = 0; // proxy gets deleted with series

    proxy = new QItemModelSurfaceDataProxy(table.model(), "row", "column", "y",

                                           QStringList() << "rowCat", QStringList() << "colCat");

    QVERIFY(proxy);

    series = new QSurface3DSeries(proxy);

    QVERIFY(series);

    QCOMPARE(proxy->rowRole(), QString("row"));

    QCOMPARE(proxy->columnRole(), QString("column"));

    QCOMPARE(proxy->xPosRole(), QString("column"));

    QCOMPARE(proxy->yPosRole(), QString("y"));

    QCOMPARE(proxy->zPosRole(), QString("row"));

    QCOMPARE(proxy->rowCategories().size(), 1);

    QCOMPARE(proxy->columnCategories().size(), 1);

    delete series;

    proxy = 0; // proxy gets deleted with series

    proxy = new QItemModelSurfaceDataProxy(table.model(), "row", "column", "x", "y", "z",

                                           QStringList() << "rowCat", QStringList() << "colCat");

    QVERIFY(proxy);

    series = new QSurface3DSeries(proxy);

    QVERIFY(series);

    QCOMPARE(proxy->rowRole(), QString("row"));

    QCOMPARE(proxy->columnRole(), QString("column"));

    QCOMPARE(proxy->xPosRole(), QString("x"));

    QCOMPARE(proxy->yPosRole(), QString("y"));

    QCOMPARE(proxy->zPosRole(), QString("z"));

    QCOMPARE(proxy->rowCategories().size(), 1);

    QCOMPARE(proxy->columnCategories().size(), 1);

    delete series;

    proxy = 0; // proxy gets deleted with series

void tst_proxy::initialProperties()

    QVERIFY(m_proxy);

    QVERIFY(m_series);

    QCOMPARE(m_proxy->autoColumnCategories(), true);

    QCOMPARE(m_proxy->autoRowCategories(), true);

    QCOMPARE(m_proxy->columnCategories(), QStringList());

    QCOMPARE(m_proxy->columnRole(), QString());

    QCOMPARE(m_proxy->columnRolePattern(), QRegularExpression());

    QCOMPARE(m_proxy->columnRoleReplace(), QString());

    QVERIFY(!m_proxy->itemModel());

    QCOMPARE(m_proxy->multiMatchBehavior(), QItemModelSurfaceDataProxy::MultiMatchBehavior::Last);

    QCOMPARE(m_proxy->rowCategories(), QStringList());

    QCOMPARE(m_proxy->rowRole(), QString());

    QCOMPARE(m_proxy->rowRolePattern(), QRegularExpression());

    QCOMPARE(m_proxy->rowRoleReplace(), QString());

    QCOMPARE(m_proxy->useModelCategories(), false);

    QCOMPARE(m_proxy->xPosRole(), QString());

    QCOMPARE(m_proxy->xPosRolePattern(), QRegularExpression());

    QCOMPARE(m_proxy->xPosRoleReplace(), QString());

    QCOMPARE(m_proxy->yPosRole(), QString());

    QCOMPARE(m_proxy->yPosRolePattern(), QRegularExpression());

    QCOMPARE(m_proxy->yPosRoleReplace(), QString());

    QCOMPARE(m_proxy->zPosRole(), QString());

    QCOMPARE(m_proxy->zPosRolePattern(), QRegularExpression());

    QCOMPARE(m_proxy->zPosRoleReplace(), QString());

    QCOMPARE(m_proxy->columnCount(), 0);

    QCOMPARE(m_proxy->rowCount(), 0);

    QCOMPARE(m_proxy->type(), QAbstractDataProxy::DataType::Surface);

void tst_proxy::initializeProperties()

    QVERIFY(m_proxy);

    QVERIFY(m_series);

    QSignalSpy itemModelSpy(m_proxy, &QItemModelSurfaceDataProxy::itemModelChanged);

    QSignalSpy rowRoleSpy(m_proxy, &QItemModelSurfaceDataProxy::rowRoleChanged);

    QSignalSpy columnRoleSpy(m_proxy, &QItemModelSurfaceDataProxy::columnRoleChanged);

    QSignalSpy xPosRoleSpy(m_proxy, &QItemModelSurfaceDataProxy::xPosRoleChanged);

    QSignalSpy yPosRoleSpy(m_proxy, &QItemModelSurfaceDataProxy::yPosRoleChanged);

    QSignalSpy zPosRoleSpy(m_proxy, &QItemModelSurfaceDataProxy::zPosRoleChanged);

    QSignalSpy rowCategoriesSpy(m_proxy, &QItemModelSurfaceDataProxy::rowCategoriesChanged);

    QSignalSpy columnCategoriesSpy(m_proxy, &QItemModelSurfaceDataProxy::columnCategoriesChanged);

    QSignalSpy useModelcategoriesSpy(m_proxy, &QItemModelSurfaceDataProxy::useModelCategoriesChanged);

    QSignalSpy autorowCategoriesSpy(m_proxy, &QItemModelSurfaceDataProxy::autoRowCategoriesChanged);

    QSignalSpy autoColumncategoriesSpy(m_proxy, &QItemModelSurfaceDataProxy::autoColumnCategoriesChanged);

    QSignalSpy rowRolePatternSpy(m_proxy, &QItemModelSurfaceDataProxy::rowRolePatternChanged);

    QSignalSpy columnRolePatternSpy(m_proxy, &QItemModelSurfaceDataProxy::columnRolePatternChanged);

    QSignalSpy xPosRolePatternSpy(m_proxy, &QItemModelSurfaceDataProxy::xPosRolePatternChanged);

    QSignalSpy yPosRolePatternSpy(m_proxy, &QItemModelSurfaceDataProxy::yPosRolePatternChanged);

    QSignalSpy zPosRolePatternSpy(m_proxy, &QItemModelSurfaceDataProxy::zPosRolePatternChanged);

    QSignalSpy rowRoleReplaceSpy(m_proxy, &QItemModelSurfaceDataProxy::rowRoleReplaceChanged);

    QSignalSpy columnRoleReplaceSpy(m_proxy, &QItemModelSurfaceDataProxy::columnRoleReplaceChanged);

    QSignalSpy xPosRoleReplaceSpy(m_proxy, &QItemModelSurfaceDataProxy::xPosRoleReplaceChanged);

    QSignalSpy yPosRoleReplaceSpy(m_proxy, &QItemModelSurfaceDataProxy::yPosRoleReplaceChanged);

    QSignalSpy zPosRoleReplaceSpy(m_proxy, &QItemModelSurfaceDataProxy::zPosRoleReplaceChanged);

    QSignalSpy multiMatchSpy(m_proxy, &QItemModelSurfaceDataProxy::multiMatchBehaviorChanged);

    QTableWidget table;

    m_proxy->setAutoColumnCategories(false);

    m_proxy->setAutoRowCategories(false);

    m_proxy->setColumnCategories(QStringList() << "col1" << "col2");

    m_proxy->setColumnRole("column");

    m_proxy->setColumnRolePattern(QRegularExpression("/^.*-(\\d\\d)$/"));

    m_proxy->setColumnRoleReplace("\\\\1");

    m_proxy->setItemModel(table.model());

    m_proxy->setMultiMatchBehavior(QItemModelSurfaceDataProxy::MultiMatchBehavior::Average);

    m_proxy->setRowCategories(QStringList() << "row1" << "row2");

    m_proxy->setRowRole("row");

    m_proxy->setRowRolePattern(QRegularExpression("/^(\\d\\d\\d\\d).*$/"));

    m_proxy->setRowRoleReplace("\\\\1");

    m_proxy->setUseModelCategories(true);

    m_proxy->setXPosRole("X");

    m_proxy->setXPosRolePattern(QRegularExpression("/-/"));

    m_proxy->setXPosRoleReplace("\\\\1");

    m_proxy->setYPosRole("Y");

    m_proxy->setYPosRolePattern(QRegularExpression("/-/"));

    m_proxy->setYPosRoleReplace("\\\\1");

    m_proxy->setZPosRole("Z");

    m_proxy->setZPosRolePattern(QRegularExpression("/-/"));

    m_proxy->setZPosRoleReplace("\\\\1");

    QCOMPARE(m_proxy->autoColumnCategories(), false);

    QCOMPARE(m_proxy->autoRowCategories(), false);

    QCOMPARE(m_proxy->columnCategories().size(), 2);

    QCOMPARE(m_proxy->columnRole(), QString("column"));

    QCOMPARE(m_proxy->columnRolePattern(), QRegularExpression("/^.*-(\\d\\d)$/"));

    QCOMPARE(m_proxy->columnRoleReplace(), QString("\\\\1"));

    QVERIFY(m_proxy->itemModel());

    QCOMPARE(m_proxy->multiMatchBehavior(), QItemModelSurfaceDataProxy::MultiMatchBehavior::Average);

    QCOMPARE(m_proxy->rowCategories().size(), 2);

    QCOMPARE(m_proxy->rowRole(), QString("row"));

    QCOMPARE(m_proxy->rowRolePattern(), QRegularExpression("/^(\\d\\d\\d\\d).*$/"));

    QCOMPARE(m_proxy->rowRoleReplace(), QString("\\\\1"));

    QCOMPARE(m_proxy->useModelCategories(), true);

    QCOMPARE(m_proxy->xPosRole(), QString("X"));

    QCOMPARE(m_proxy->xPosRolePattern(), QRegularExpression("/-/"));

    QCOMPARE(m_proxy->xPosRoleReplace(), QString("\\\\1"));

    QCOMPARE(m_proxy->yPosRole(), QString("Y"));

    QCOMPARE(m_proxy->yPosRolePattern(), QRegularExpression("/-/"));

    QCOMPARE(m_proxy->yPosRoleReplace(), QString("\\\\1"));

    QCOMPARE(m_proxy->zPosRole(), QString("Z"));

    QCOMPARE(m_proxy->zPosRolePattern(), QRegularExpression("/-/"));

    QCOMPARE(m_proxy->zPosRoleReplace(), QString("\\\\1"));

    QCOMPARE(itemModelSpy.size(), 1);

    QCOMPARE(rowRoleSpy.size(), 1);

    QCOMPARE(columnRoleSpy.size(), 1);

    QCOMPARE(xPosRoleSpy.size(), 1);

    QCOMPARE(yPosRoleSpy.size(), 1);

    QCOMPARE(zPosRoleSpy.size(), 1);

    QCOMPARE(rowCategoriesSpy.size(), 1);

    QCOMPARE(columnCategoriesSpy.size(), 1);

    QCOMPARE(useModelcategoriesSpy.size(), 1);

    QCOMPARE(autorowCategoriesSpy.size(), 1);

    QCOMPARE(autoColumncategoriesSpy.size(), 1);

    QCOMPARE(rowRolePatternSpy.size(), 1);

    QCOMPARE(columnRolePatternSpy.size(), 1);

    QCOMPARE(xPosRolePatternSpy.size(), 1);

    QCOMPARE(yPosRolePatternSpy.size(), 1);

    QCOMPARE(zPosRolePatternSpy.size(), 1);

    QCOMPARE(rowRoleReplaceSpy.size(), 1);

    QCOMPARE(columnRoleReplaceSpy.size(), 1);

    QCOMPARE(xPosRoleReplaceSpy.size(), 1);

    QCOMPARE(yPosRoleReplaceSpy.size(), 1);

    QCOMPARE(zPosRoleReplaceSpy.size(), 1);

    QCOMPARE(multiMatchSpy.size(), 1);

void tst_proxy::multiMatch()

    if (!CpptestUtil::isOpenGLSupported())

        QSKIP("OpenGL not supported on this platform");

    QQuickWidget quickWidget;

    Q3DSurfaceWidgetItem graph;

    graph.setWidget(&quickWidget);

    QTableWidget table;

    QStringList rows;

    rows << "row 1" << "row 2";

    QStringList columns;

    columns << "col 1" << "col 2" << "col 3" << "col 4";

    const char *values[4][2] = {{"0/0/5.5/30", "0/0/10.5/30"},

                               {"0/1/5.5/30", "0/1/0.5/30"},

                               {"1/0/5.5/30", "1/0/0.5/30"},

                               {"1/1/0.0/30", "1/1/0.0/30"}};

    table.setRowCount(2);

    table.setColumnCount(4);

    for (int col = 0; col < columns.size(); col++) {

        for (int row = 0; row < rows.size(); row++) {

            QModelIndex index = table.model()->index(col, row);

            table.model()->setData(index, values[col][row]);

    m_proxy->setItemModel(table.model());

    m_proxy->setRowRole(table.model()->roleNames().value(Qt::DisplayRole));

    m_proxy->setColumnRole(table.model()->roleNames().value(Qt::DisplayRole));

    m_proxy->setRowRolePattern(QRegularExpression(QStringLiteral("^(\\d*)\\/(\\d*)\\/\\d*[\\.\\,]?\\d*\\/\\d*[\\.\\,]?\\d*$")));

    m_proxy->setRowRoleReplace(QStringLiteral("\\2"));

    m_proxy->setYPosRolePattern(QRegularExpression(QStringLiteral("^\\d*(\\/)(\\d*)\\/(\\d*[\\.\\,]?\\d*)\\/\\d*[\\.\\,]?\\d*$")));

    m_proxy->setYPosRoleReplace(QStringLiteral("\\3"));

    m_proxy->setColumnRolePattern(QRegularExpression(QStringLiteral("^(\\d*)(\\/)(\\d*)\\/\\d*[\\.\\,]?\\d*\\/\\d*[\\.\\,]?\\d*$")));

    m_proxy->setColumnRoleReplace(QStringLiteral("\\1"));

    QCoreApplication::processEvents();

    graph.addSeries(m_series);

    QCoreApplication::processEvents();

    QCOMPARE(graph.axisY()->max(), 10.5f);

    m_proxy->setMultiMatchBehavior(QItemModelSurfaceDataProxy::MultiMatchBehavior::First);

    QCoreApplication::processEvents();

    QCOMPARE(graph.axisY()->max(), 5.5f);

    m_proxy->setMultiMatchBehavior(QItemModelSurfaceDataProxy::MultiMatchBehavior::Last);

    QCoreApplication::processEvents();

    QCOMPARE(graph.axisY()->max(), 10.5f);

    m_proxy->setMultiMatchBehavior(QItemModelSurfaceDataProxy::MultiMatchBehavior::Average);

    QCoreApplication::processEvents();

    QCOMPARE(graph.axisY()->max(), 8.0f);

    m_proxy->setMultiMatchBehavior(QItemModelSurfaceDataProxy::MultiMatchBehavior::CumulativeY);

    QCoreApplication::processEvents();

    QCOMPARE(graph.axisY()->max(), 16.0f);

    QCOMPARE(m_proxy->columnCount(), 2);

    QCOMPARE(m_proxy->rowCount(), 3);

    m_series = 0;

    m_proxy = 0; // Graph deletes proxy

QTEST_MAIN(tst_proxy)

#include "tst_proxy.moc"