Revision control
Copy as Markdown
// Copyright (C) 2024 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#include <QtTest/QTest>
#include <QtQml/qqmlapplicationengine.h>
#include <QtQuick/qquickwindow.h>
#include <QtQuickTest/quicktest.h>
#include <QtQuickTemplates2/private/qquickcontrol_p.h>
#include <QtQuickControlsTestUtils/private/controlstestutils_p.h>
#include "tickmarkcontainer.h"
QT_BEGIN_NAMESPACE
using namespace QQuickControlsTestUtils;
class tst_HowToCppGauge : public QObject
{
Q_OBJECT
public:
tst_HowToCppGauge();
private slots:
void example_data();
void example();
};
tst_HowToCppGauge::tst_HowToCppGauge()
{
}
void tst_HowToCppGauge::example_data()
{
QTest::addColumn<Qt::Orientation>("orientation");
QTest::newRow("vertical") << Qt::Vertical;
QTest::newRow("horizontal") << Qt::Horizontal;
}
void tst_HowToCppGauge::example()
{
QFETCH(Qt::Orientation, orientation);
QTest::failOnWarning(QRegularExpression(QStringLiteral(".?")));
QQmlApplicationEngine engine;
engine.loadFromModule("GaugeHowTo", "Main");
QCOMPARE(engine.rootObjects().size(), 1);
auto *window = qobject_cast<QQuickWindow*>(engine.rootObjects().at(0));
window->show();
QVERIFY(QTest::qWaitForWindowExposed(window));
auto *gauge = window->findChild<QQuickControl*>();
QVERIFY(gauge);
const int expectedTickmarkStepSize = 10;
QCOMPARE(gauge->property("tickmarkStepSize").toInt(), expectedTickmarkStepSize);
const int expectedTickmarkCount = 11;
QCOMPARE(gauge->property("tickmarkCount").toInt(), expectedTickmarkCount);
const int expectedMinorTickmarkCount = 4;
QCOMPARE(gauge->property("minorTickmarkCount").toInt(), expectedMinorTickmarkCount);
// Set orientation.
QVERIFY(gauge->setProperty("orientation", orientation));
const int expectedTickmarkLength = 16;
const int expectedTickmarkWidth = 2;
QCOMPARE(gauge->property("tickmarkLength").toInt(), expectedTickmarkLength);
QCOMPARE(gauge->property("tickmarkWidth").toInt(), expectedTickmarkWidth);
const int expectedMinorTickmarkLength = 8;
const int expectedMinorTickmarkWidth = 1;
QCOMPARE(gauge->property("minorTickmarkLength").toInt(), expectedMinorTickmarkLength);
QCOMPARE(gauge->property("minorTickmarkWidth").toInt(), expectedMinorTickmarkWidth);
const qreal tickmarkSpacing = gauge->property("tickmarkSpacing").toReal();
const bool vertical = orientation == Qt::Vertical;
if (!vertical) {
// If it changes orientation, a polish will occur. We need to wait for
// that to happen before trying to access delegate items, as those will
// be recreated in updatePolish.
QVERIFY(QQuickTest::qIsPolishScheduled(window));
QVERIFY(QQuickTest::qWaitForPolish(window));
}
auto *tickmarkLabelContainer = gauge->findChild<TickmarkContainer *>("tickmarkLabelContainer");
QVERIFY(tickmarkLabelContainer);
auto *tickmarkContainer = gauge->findChild<TickmarkContainer *>("tickmarkContainer");
QVERIFY(tickmarkContainer);
auto *minorTickmarkContainer = gauge->findChild<TickmarkContainer *>("minorTickmarkContainer");
QVERIFY(minorTickmarkContainer);
auto *valueBarItem = gauge->findChild<QQuickItem *>("valueBarItem");
QVERIFY(valueBarItem);
// Check that there are as many tickmarks and labels as we expect.
QCOMPARE(tickmarkLabelContainer->childItems().size(), expectedTickmarkCount);
QCOMPARE(tickmarkContainer->childItems().size(), expectedTickmarkCount);
const int expectedTotalMinorTickmarkCount = (expectedTickmarkCount - 1) * expectedMinorTickmarkCount;
QCOMPARE(minorTickmarkContainer->childItems().size(), expectedTotalMinorTickmarkCount);
QQuickItem *firstTickmark = tickmarkContainer->delegateItemAt(0);
QVERIFY(firstTickmark);
QQuickItem *secondTickmark = tickmarkContainer->delegateItemAt(1);
QVERIFY(secondTickmark);
QQuickItem *lastTickmark = tickmarkContainer->delegateItemAt(expectedTickmarkCount - 1);
QVERIFY(lastTickmark);
QQuickItem *firstMinorTickmark = minorTickmarkContainer->delegateItemAt(0);
QVERIFY(firstMinorTickmark);
QQuickItem *secondMinorTickmark = minorTickmarkContainer->delegateItemAt(1);
QVERIFY(secondMinorTickmark);
QQuickItem *lastMinorTickmark = minorTickmarkContainer->delegateItemAt(expectedTotalMinorTickmarkCount - 1);
QVERIFY(lastMinorTickmark);
QQuickItem *firstLabel = tickmarkLabelContainer->delegateItemAt(0);
QVERIFY(firstLabel);
QQuickItem *secondLabel = tickmarkLabelContainer->delegateItemAt(1);
QVERIFY(secondLabel);
QQuickItem *lastLabel = tickmarkLabelContainer->delegateItemAt(expectedTickmarkCount - 1);
QVERIFY(lastLabel);
if (vertical) {
QCOMPARE_GT(gauge->implicitHeight(), gauge->implicitWidth());
// Check that the items are laid out correctly.
QCOMPARE_LT(tickmarkLabelContainer->x(), tickmarkContainer->x());
QCOMPARE_LT(tickmarkContainer->x(), valueBarItem->x());
// Check that tickmarks have the size they should.
QCOMPARE(firstTickmark->width(), expectedTickmarkLength);
QCOMPARE(firstTickmark->height(), expectedTickmarkWidth);
QCOMPARE(firstMinorTickmark->width(), expectedMinorTickmarkLength);
QCOMPARE(firstMinorTickmark->height(), expectedMinorTickmarkWidth);
// Check that some tickmarks are laid out roughly where they should be.
QCOMPARE_GT(firstTickmark->y(), lastTickmark->y());
QCOMPARE_LE(secondTickmark->y(), firstTickmark->y() - tickmarkSpacing);
QCOMPARE_GT(secondTickmark->y(), lastTickmark->y());
QCOMPARE_GT(firstMinorTickmark->y(), lastMinorTickmark->y());
QCOMPARE_LE(secondMinorTickmark->y(), firstMinorTickmark->y());
QCOMPARE_GT(secondMinorTickmark->y(), lastMinorTickmark->y());
// Check that some labels are laid out roughly where they should be.
QCOMPARE_GT(firstLabel->y(), lastLabel->y());
QCOMPARE_LE(secondLabel->y(), firstLabel->y() - tickmarkSpacing);
QCOMPARE_GT(secondLabel->y(), lastLabel->y());
} else { // Horizontal
QCOMPARE_GT(gauge->implicitWidth(), gauge->implicitHeight());
// Check that the items are laid out correctly.
QCOMPARE_LT(valueBarItem->y(), tickmarkContainer->y());
QCOMPARE_LT(tickmarkContainer->y(), tickmarkLabelContainer->y());
// Check that tickmarks have the size they should.
QCOMPARE(firstTickmark->width(), expectedTickmarkWidth);
QCOMPARE(firstTickmark->height(), expectedTickmarkLength);
QCOMPARE(firstMinorTickmark->width(), expectedMinorTickmarkWidth);
QCOMPARE(firstMinorTickmark->height(), expectedMinorTickmarkLength);
// Check that some tickmarks are laid out roughly where they should be.
QCOMPARE_LT(firstTickmark->x(), lastTickmark->x());
QCOMPARE_GE(secondTickmark->x(), firstTickmark->x() - tickmarkSpacing);
QCOMPARE_LT(secondTickmark->x(), lastTickmark->x());
QCOMPARE_LT(firstMinorTickmark->x(), lastMinorTickmark->x());
QCOMPARE_GE(secondMinorTickmark->x(), firstMinorTickmark->x());
QCOMPARE_LT(secondMinorTickmark->x(), lastMinorTickmark->x());
// // Check that some labels are laid out roughly where they should be.
QCOMPARE_LT(firstLabel->x(), lastLabel->x());
QCOMPARE_GE(secondLabel->x(), firstLabel->x() - tickmarkSpacing);
QCOMPARE_LT(secondLabel->x(), lastLabel->x());
}
QCOMPARE(firstTickmark->property("index").toInt(), 0);
QCOMPARE(firstTickmark->property("value").toInt(), 0);
QCOMPARE(secondTickmark->property("index").toInt(), 1);
QCOMPARE(secondTickmark->property("value").toInt(), expectedTickmarkStepSize);
QCOMPARE(lastTickmark->property("index").toInt(), expectedTickmarkCount - 1);
QCOMPARE(lastTickmark->property("value").toInt(), expectedTickmarkStepSize * (expectedTickmarkCount - 1));
QCOMPARE(firstMinorTickmark->property("index").toInt(), 0);
QCOMPARE(firstMinorTickmark->property("value").toInt(), 2);
QCOMPARE(secondMinorTickmark->property("index").toInt(), 1);
QCOMPARE(secondMinorTickmark->property("value").toInt(), 4);
QCOMPARE(lastMinorTickmark->property("index").toInt(), expectedTotalMinorTickmarkCount - 1);
QCOMPARE(lastMinorTickmark->property("value").toInt(), 98);
QCOMPARE(firstLabel->property("index").toInt(), 0);
QCOMPARE(firstLabel->property("value").toInt(), 0);
QCOMPARE(secondLabel->property("index").toInt(), 1);
QCOMPARE(secondLabel->property("value").toInt(), expectedTickmarkStepSize);
QCOMPARE(lastLabel->property("index").toInt(), expectedTickmarkCount - 1);
QCOMPARE(lastLabel->property("value").toInt(), expectedTickmarkStepSize * (expectedTickmarkCount - 1));
}
QT_END_NAMESPACE
QTEST_MAIN(tst_HowToCppGauge)
#include "tst_how-to-cpp-gauge.moc"