tst_axisaccumulator.cpp

// Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB).

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

#include <QtTest/QTest>

#include <qbackendnodetester.h>

#include <Qt3DCore/private/qnode_p.h>

#include <Qt3DCore/private/qscene_p.h>

#include <Qt3DInput/private/axis_p.h>

#include <Qt3DInput/private/axisaccumulator_p.h>

#include <Qt3DInput/private/qabstractaxisinput_p.h>

#include <Qt3DInput/private/inputmanagers_p.h>

#include <Qt3DInput/QAnalogAxisInput>

#include <Qt3DInput/QAxis>

#include <Qt3DInput/QAxisAccumulator>

#include <Qt3DCore/private/qbackendnode_p.h>

#include "testarbiter.h"

class tst_AxisAccumulator: public Qt3DCore::QBackendNodeTester

    Q_OBJECT

private Q_SLOTS:

    void checkPeerPropertyMirroring()

        // GIVEN

        Qt3DInput::Input::AxisAccumulator backendAccumulator;

        Qt3DInput::QAxisAccumulator axisAccumulator;

        Qt3DInput::QAxis axis;

        axisAccumulator.setSourceAxis(&axis);

        axisAccumulator.setSourceAxisType(Qt3DInput::QAxisAccumulator::Velocity);

        axisAccumulator.setScale(2.0f);

        // WHEN

        simulateInitializationSync(&axisAccumulator, &backendAccumulator);

        // THEN

        QCOMPARE(backendAccumulator.peerId(), axisAccumulator.id());

        QCOMPARE(backendAccumulator.isEnabled(), axisAccumulator.isEnabled());

        QCOMPARE(backendAccumulator.sourceAxisType(), axisAccumulator.sourceAxisType());

        QCOMPARE(backendAccumulator.sourceAxisId(), axisAccumulator.sourceAxis()->id());

        QCOMPARE(backendAccumulator.scale(), axisAccumulator.scale());

    void checkInitialAndCleanedUpState()

        // GIVEN

        Qt3DInput::Input::AxisAccumulator backendAxisAccumulator;

        // THEN

        QVERIFY(backendAxisAccumulator.peerId().isNull());

        QCOMPARE(backendAxisAccumulator.isEnabled(), false);

        QCOMPARE(backendAxisAccumulator.value(), 0.0f);

        QCOMPARE(backendAxisAccumulator.velocity(), 0.0f);

        QCOMPARE(backendAxisAccumulator.scale(), 1.0f);

        QCOMPARE(backendAxisAccumulator.sourceAxisId(), Qt3DCore::QNodeId());

        QCOMPARE(backendAxisAccumulator.sourceAxisType(), Qt3DInput::QAxisAccumulator::Velocity);

        // GIVEN

        Qt3DInput::QAxisAccumulator axisAccumulator;

        Qt3DInput::QAxis axis;

        axisAccumulator.setSourceAxis(&axis);

        axisAccumulator.setScale(2.0f);

        axisAccumulator.setSourceAxisType(Qt3DInput::QAxisAccumulator::Acceleration);

        axisAccumulator.setEnabled(true);

        // WHEN

        simulateInitializationSync(&axisAccumulator, &backendAxisAccumulator);

        backendAxisAccumulator.cleanup();

        // THEN

        QCOMPARE(backendAxisAccumulator.isEnabled(), false);

        QCOMPARE(backendAxisAccumulator.value(), 0.0f);

        QCOMPARE(backendAxisAccumulator.velocity(), 0.0f);

        QCOMPARE(backendAxisAccumulator.scale(), 1.0f);

        QCOMPARE(backendAxisAccumulator.sourceAxisId(), Qt3DCore::QNodeId());

        QCOMPARE(backendAxisAccumulator.sourceAxisType(), Qt3DInput::QAxisAccumulator::Velocity);

    void checkPropertyChanges()

        // GIVEN

        Qt3DInput::QAxisAccumulator axisAccumulator;

        Qt3DInput::Input::AxisAccumulator backendAxisAccumulator;

        simulateInitializationSync(&axisAccumulator, &backendAxisAccumulator);

        // WHEN

        axisAccumulator.setEnabled(false);

        backendAxisAccumulator.syncFromFrontEnd(&axisAccumulator, false);

        // THEN

        QCOMPARE(backendAxisAccumulator.isEnabled(), false);

        // WHEN

        Qt3DInput::QAxis axis;

        const Qt3DCore::QNodeId axisId = axis.id();

        axisAccumulator.setSourceAxis(&axis);

        backendAxisAccumulator.syncFromFrontEnd(&axisAccumulator, false);

        // THEN

        QCOMPARE(backendAxisAccumulator.sourceAxisId(), axisId);

        // WHEN

        axisAccumulator.setSourceAxisType(Qt3DInput::QAxisAccumulator::Acceleration);

        backendAxisAccumulator.syncFromFrontEnd(&axisAccumulator, false);

        // THEN

        QCOMPARE(backendAxisAccumulator.sourceAxisType(), Qt3DInput::QAxisAccumulator::Acceleration);

        // WHEN

        axisAccumulator.setScale(3.f);

        backendAxisAccumulator.syncFromFrontEnd(&axisAccumulator, false);

        // THEN

        QCOMPARE(backendAxisAccumulator.scale(), 3.0f);

    void shouldNotChangeValueWhenDisabled()

        // GIVEN

        TestArbiter arbiter;

        Qt3DInput::Input::AxisAccumulator backendAxisAccumulator;

        backendAxisAccumulator.setEnabled(false);

        // WHEN

        backendAxisAccumulator.setValue(454.0f);

        // THEN

        QCOMPARE(backendAxisAccumulator.value(), 0.0f);

        QCOMPARE(arbiter.dirtyNodes().size(), 0);

    void checkIntegration_data()

        QTest::addColumn<Qt3DInput::QAxisAccumulator::SourceAxisType>("sourceAxisType");

        QTest::addColumn<float>("axisValue");

        QTest::addColumn<float>("scale");

        QTest::addColumn<float>("dt");

        QTest::addColumn<float>("valueResult");

        QTest::addColumn<float>("velocityResult");

        QTest::newRow("velocity=10, axis=1, dt=1") << Qt3DInput::QAxisAccumulator::Velocity

                                                   << 1.0f

                                                   << 10.0f

                                                   << 1.0f

                                                   << 10.0f

                                                   << 0.0f;

        QTest::newRow("velocity=10, axis=1, dt=0.2") << Qt3DInput::QAxisAccumulator::Velocity

                                                   << 1.0f

                                                   << 10.0f

                                                   << 0.2f

                                                   << 2.0f

                                                   << 0.0f;

        QTest::newRow("velocity=20, axis=1, dt=0.1") << Qt3DInput::QAxisAccumulator::Velocity

                                                   << 1.0f

                                                   << 20.0f

                                                   << 0.1f

                                                   << 2.0f

                                                   << 0.0f;

        QTest::newRow("velocity=10, axis=0.5, dt=1") << Qt3DInput::QAxisAccumulator::Velocity

                                                   << 0.5f

                                                   << 10.0f

                                                   << 1.0f

                                                   << 5.0f

                                                   << 0.0f;

        QTest::newRow("acceleration=10, axis=1, dt=1") << Qt3DInput::QAxisAccumulator::Acceleration

                                                       << 1.0f

                                                       << 10.0f

                                                       << 1.0f

                                                       << 10.0f

                                                       << 10.0f;

    void checkIntegration()

        // GIVEN

        QFETCH(Qt3DInput::QAxisAccumulator::SourceAxisType, sourceAxisType);

        QFETCH(float, axisValue);

        QFETCH(float, scale);

        QFETCH(float, dt);

        QFETCH(float, valueResult);

        QFETCH(float, velocityResult);

        Qt3DInput::QAxis *axis = new Qt3DInput::QAxis;

        Qt3DInput::Input::AxisManager axisManager;

        Qt3DInput::Input::Axis *backendAxis = axisManager.getOrCreateResource(axis->id());

        Qt3DInput::QAxisAccumulator axisAccumulator;

        Qt3DInput::Input::AxisAccumulator backendAxisAccumulator;

        // WHEN

        backendAxis->setEnabled(true);

        backendAxis->setAxisValue(axisValue);

        axisAccumulator.setSourceAxis(axis);

        axisAccumulator.setScale(scale);

        axisAccumulator.setSourceAxisType(sourceAxisType);

        axisAccumulator.setEnabled(true);

        simulateInitializationSync(&axisAccumulator, &backendAxisAccumulator);

        backendAxisAccumulator.stepIntegration(&axisManager, dt);

        // THEN

        switch (sourceAxisType) {

        case Qt3DInput::QAxisAccumulator::Velocity:

            QCOMPARE(backendAxisAccumulator.value(), valueResult);

            break;

        case Qt3DInput::QAxisAccumulator::Acceleration:

            QCOMPARE(backendAxisAccumulator.velocity(), velocityResult);

            QCOMPARE(backendAxisAccumulator.value(), valueResult);

            break;

};

QTEST_APPLESS_MAIN(tst_AxisAccumulator)

#include "tst_axisaccumulator.moc"

Revision control

Copy as Markdown