TestToolbar.cpp - master - imurzich/shulte

TestToolbar.cpp
527 строк16 KB
Igor Murzich
spec: add Packager, translate Summary/Description to English, fix non-ASCII char; trigger resizeForFieldSize on toolbar visibility change; add field pixel tests
20 июл 2026, 14:41
20 июл 2026, 14:41d0a1979
#include <QtTest>
#include <QSignalSpy>
#include <cmath>

#include "Settings.h"
#include "GameEngine.h"

class TestToolbar : public QObject
{
    Q_OBJECT

private:
    double simulateFieldRequiredWidth(double fieldSizeCm, bool visible, bool onSide,
                                       double tbW, double pxPerMm) const
    {
        double fieldPx = fieldSizeCm * 10.0 * pxPerMm;
        double extraW = (visible && onSide) ? tbW : 0.0;
        return fieldPx + extraW;
    }

    double simulateFieldRequiredHeight(double fieldSizeCm, bool visible, bool onSide,
                                        double tbH, double ftH, double mbH, double pxPerMm) const
    {
        double fieldPx = fieldSizeCm * 10.0 * pxPerMm;
        double extraH = (visible && !onSide) ? tbH : 0.0;
        return fieldPx + extraH + ftH + mbH;
    }

    void resetSettingsToDefaults()
    {
        QSettings s("KDE", "Schulte Table");
        s.beginGroup("General");
        s.setValue("toolbarVisible", true);
        s.setValue("toolbarOnSide", false);
        s.setValue("fieldSizeCm", 20.0);
        s.endGroup();
        s.sync();
    }

private slots:
    void init()
    {
        resetSettingsToDefaults();
    }

    void cleanup()
    {
        resetSettingsToDefaults();
    }

    void testToolbarVisibleDefault()
    {
        Settings s;
        QVERIFY(s.toolbarVisible() == true);
    }

    void testToolbarVisibleSetFalse()
    {
        Settings s;
        QSignalSpy spy(&s, &Settings::toolbarVisibleChanged);
        s.setToolbarVisible(false);
        QVERIFY(s.toolbarVisible() == false);
        QCOMPARE(spy.count(), 1);
    }

    void testToolbarVisibleSetTrue()
    {
        Settings s;
        s.setToolbarVisible(false);
        QSignalSpy spy(&s, &Settings::toolbarVisibleChanged);
        s.setToolbarVisible(true);
        QVERIFY(s.toolbarVisible() == true);
        QCOMPARE(spy.count(), 1);
    }

    void testToolbarVisibleNoopSameValue()
    {
        Settings s;
        QSignalSpy spy(&s, &Settings::toolbarVisibleChanged);
        s.setToolbarVisible(true);
        QCOMPARE(spy.count(), 0);

        s.setToolbarVisible(false);
        spy.clear();
        s.setToolbarVisible(false);
        QCOMPARE(spy.count(), 0);
    }

    void testToolbarOnSideDefault()
    {
        Settings s;
        QVERIFY(s.toolbarOnSide() == false);
    }

    void testToolbarOnSideSetTrue()
    {
        Settings s;
        QSignalSpy spy(&s, &Settings::toolbarOnSideChanged);
        s.setToolbarOnSide(true);
        QVERIFY(s.toolbarOnSide() == true);
        QCOMPARE(spy.count(), 1);
    }

    void testToolbarOnSideSetFalse()
    {
        Settings s;
        s.setToolbarOnSide(true);
        QSignalSpy spy(&s, &Settings::toolbarOnSideChanged);
        s.setToolbarOnSide(false);
        QVERIFY(s.toolbarOnSide() == false);
        QCOMPARE(spy.count(), 1);
    }

    void testToolbarOnSideNoop()
    {
        Settings s;
        QSignalSpy spy(&s, &Settings::toolbarOnSideChanged);
        s.setToolbarOnSide(false);
        QCOMPARE(spy.count(), 0);
    }

    void testToolbarIndependentVisibleFirst()
    {
        Settings s;
        s.setToolbarVisible(false);
        QVERIFY(s.toolbarVisible() == false);
        QVERIFY(s.toolbarOnSide() == false);

        s.setToolbarOnSide(true);
        QVERIFY(s.toolbarVisible() == false);
        QVERIFY(s.toolbarOnSide() == true);
    }

    void testToolbarIndependentSideFirst()
    {
        Settings s;
        s.setToolbarOnSide(true);
        QVERIFY(s.toolbarVisible() == true);
        QVERIFY(s.toolbarOnSide() == true);

        s.setToolbarVisible(false);
        QVERIFY(s.toolbarVisible() == false);
        QVERIFY(s.toolbarOnSide() == true);
    }

    void testCombinedToggleSequence()
    {
        Settings s;

        QVERIFY(s.toolbarVisible() == true);
        QVERIFY(s.toolbarOnSide() == false);

        s.setToolbarVisible(false);
        QVERIFY(!s.toolbarVisible());
        QVERIFY(!s.toolbarOnSide());

        s.setToolbarOnSide(true);
        QVERIFY(!s.toolbarVisible());
        QVERIFY(s.toolbarOnSide());

        s.setToolbarVisible(true);
        QVERIFY(s.toolbarVisible());
        QVERIFY(s.toolbarOnSide());

        s.setToolbarOnSide(false);
        QVERIFY(s.toolbarVisible());
        QVERIFY(!s.toolbarOnSide());
    }

    void testCombinedSignals()
    {
        Settings s;
        QSignalSpy visSpy(&s, &Settings::toolbarVisibleChanged);
        QSignalSpy sideSpy(&s, &Settings::toolbarOnSideChanged);

        s.setToolbarVisible(false);
        QCOMPARE(visSpy.count(), 1);
        QCOMPARE(sideSpy.count(), 0);

        visSpy.clear();
        s.setToolbarOnSide(true);
        QCOMPARE(visSpy.count(), 0);
        QCOMPARE(sideSpy.count(), 1);
    }

    void testResizeCalcTopToolbarVisible()
    {
        const double fieldCm = 20.0;
        const double pxPerMm = 3.78;
        const double tbH = 40.0;
        const double ftH = 35.0;
        const double mbH = 25.0;

        double w = simulateFieldRequiredWidth(fieldCm, true, false, 50, pxPerMm);
        double h = simulateFieldRequiredHeight(fieldCm, true, false, tbH, ftH, mbH, pxPerMm);

        double fieldPx = fieldCm * 10.0 * pxPerMm;
        QCOMPARE(w, fieldPx);
        QCOMPARE(h, fieldPx + tbH + ftH + mbH);
    }

    void testResizeCalcSideToolbarVisible()
    {
        const double fieldCm = 20.0;
        const double pxPerMm = 3.78;
        const double tbW = 48.0;
        const double ftH = 35.0;
        const double mbH = 25.0;

        double w = simulateFieldRequiredWidth(fieldCm, true, true, tbW, pxPerMm);
        double h = simulateFieldRequiredHeight(fieldCm, true, true, 0, ftH, mbH, pxPerMm);

        double fieldPx = fieldCm * 10.0 * pxPerMm;
        QCOMPARE(w, fieldPx + tbW);
        QCOMPARE(h, fieldPx + ftH + mbH);
    }

    void testResizeCalcToolbarHidden()
    {
        const double fieldCm = 20.0;
        const double pxPerMm = 3.78;
        const double ftH = 35.0;
        const double mbH = 25.0;

        double w = simulateFieldRequiredWidth(fieldCm, false, false, 48, pxPerMm);
        double h = simulateFieldRequiredHeight(fieldCm, false, false, 40, ftH, mbH, pxPerMm);

        double fieldPx = fieldCm * 10.0 * pxPerMm;
        QCOMPARE(w, fieldPx);
        QCOMPARE(h, fieldPx + ftH + mbH);
    }

    void testResizeCalcHiddenWithSideTrue()
    {
        const double fieldCm = 20.0;
        const double pxPerMm = 3.78;

        double w = simulateFieldRequiredWidth(fieldCm, false, true, 48, pxPerMm);
        QCOMPARE(w, fieldCm * 10.0 * pxPerMm);
    }

    void testResizeCalcDifferentFieldSizes()
    {
        const double pxPerMm = 3.78;

        double w5 = simulateFieldRequiredWidth(5.0, true, true, 48, pxPerMm);
        double fieldPx5 = 5.0 * 10.0 * pxPerMm;
        QCOMPARE(w5, fieldPx5 + 48);

        double w30 = simulateFieldRequiredWidth(30.0, true, true, 48, pxPerMm);
        double fieldPx30 = 30.0 * 10.0 * pxPerMm;
        QCOMPARE(w30, fieldPx30 + 48);
        QVERIFY(w30 > w5);
    }

    void testResizeCalcTransitions()
    {
        const double fieldCm = 20.0;
        const double pxPerMm = 3.78;
        const double tbW = 48.0;
        const double tbH = 40.0;
        const double ftH = 35.0;
        const double mbH = 25.0;

        double wTop = simulateFieldRequiredWidth(fieldCm, true, false, tbW, pxPerMm);
        double hTop = simulateFieldRequiredHeight(fieldCm, true, false, tbH, ftH, mbH, pxPerMm);

        double wSide = simulateFieldRequiredWidth(fieldCm, true, true, tbW, pxPerMm);
        double hSide = simulateFieldRequiredHeight(fieldCm, true, true, tbH, ftH, mbH, pxPerMm);

        QVERIFY(wSide > wTop);
        QVERIFY(hSide < hTop);

        double wHidden = simulateFieldRequiredWidth(fieldCm, false, false, tbW, pxPerMm);
        double wTop2 = simulateFieldRequiredWidth(fieldCm, true, false, tbW, pxPerMm);
        QCOMPARE(wHidden, wTop2);
    }

    void testResizeCalcSkipsWhenMaximized()
    {
        const double fieldCm = 20.0;
        const double pxPerMm = 3.78;
        const double tbW = 48.0;
        const double tbH = 40.0;
        const double ftH = 35.0;
        const double mbH = 25.0;

        auto calcWidth = [&](bool visible, bool onSide, bool skipResize) -> double {
            if (skipResize) return -1;
            return simulateFieldRequiredWidth(fieldCm, visible, onSide, tbW, pxPerMm);
        };
        auto calcHeight = [&](bool visible, bool onSide, bool skipResize) -> double {
            if (skipResize) return -1;
            return simulateFieldRequiredHeight(fieldCm, visible, onSide, tbH, ftH, mbH, pxPerMm);
        };

        QCOMPARE(calcWidth(true, false, true), -1.0);
        QCOMPARE(calcHeight(true, false, true), -1.0);

        QCOMPARE(calcWidth(true, true, true), -1.0);
        QCOMPARE(calcHeight(true, true, true), -1.0);

        QCOMPARE(calcWidth(false, false, true), -1.0);
        QCOMPARE(calcHeight(false, false, true), -1.0);

        double wNormal = calcWidth(true, true, false);
        QVERIFY(wNormal > 0);
        double hNormal = calcHeight(true, false, false);
        QVERIFY(hNormal > 0);

        QVERIFY(wNormal != calcWidth(true, true, true));
        QVERIFY(hNormal != calcHeight(true, false, true));
    }

    void testGameEngineFieldSizeCmDefault()
    {
        GameEngine e;
        QCOMPARE(e.fieldSizeCm(), 20.0);
    }

    void testGameEngineFieldSizeCmSet()
    {
        GameEngine e;
        QSignalSpy spy(&e, &GameEngine::fieldSizeCmChanged);
        e.setFieldSizeCm(15.0);
        QCOMPARE(e.fieldSizeCm(), 15.0);
        QCOMPARE(spy.count(), 1);
    }

    void testGameEngineFieldSizeCmNoop()
    {
        GameEngine e;
        QSignalSpy spy(&e, &GameEngine::fieldSizeCmChanged);
        e.setFieldSizeCm(20.0);
        QCOMPARE(spy.count(), 0);
    }

    void testGameEngineMmToPixelsNoWindow()
    {
        GameEngine e;
        double px = e.mmToPixels(1.0);
        QCOMPARE(px, 3.78);
    }

    void testFieldRecalcAfterGridResize()
    {
        GameEngine e;
        e.setGridSize(7);
        QCOMPARE(e.gridSize(), 7);
        QCOMPARE(e.cells().size(), 49);
        QCOMPARE(e.nextNumber(), 1);
        QVERIFY(!e.playing());
        QVERIFY(!e.finished());
    }

    void testFieldRecalcFormula()
    {
        GameEngine e;

        double pxFor200mm = e.mmToPixels(200.0);
        QCOMPARE(pxFor200mm, 200.0 * 3.78);

        double pxFor50mm = e.mmToPixels(50.0);
        QCOMPARE(pxFor50mm, 50.0 * 3.78);

        double pxFor10mm = e.mmToPixels(10.0);
        QCOMPARE(pxFor10mm, 10.0 * 3.78);
    }

    void testSettingsFieldSizeCm()
    {
        Settings s;
        QVERIFY(qFuzzyCompare(s.fieldSizeCm(), 20.0));

        QSignalSpy spy(&s, &Settings::fieldSizeCmChanged);
        s.setFieldSizeCm(25.0);
        QVERIFY(qFuzzyCompare(s.fieldSizeCm(), 25.0));
        QCOMPARE(spy.count(), 1);
    }

    void testFieldSizeCmAndToolbarCombined()
    {
        GameEngine e;
        Settings s;

        e.setFieldSizeCm(30.0);
        QCOMPARE(e.fieldSizeCm(), 30.0);
        s.setFieldSizeCm(30.0);
        QVERIFY(qFuzzyCompare(s.fieldSizeCm(), 30.0));

        s.setToolbarVisible(true);
        s.setToolbarOnSide(true);
        QCOMPARE(e.fieldSizeCm(), 30.0);
        QVERIFY(qFuzzyCompare(s.fieldSizeCm(), 30.0));
    }

    void testFieldPxSameAllStates()
    {
        const double fieldCm = 20.0;
        const double pxPerMm = 3.78;
        const double tbW = 48.0;
        const double tbH = 40.0;
        const double ftH = 35.0;
        const double mbH = 25.0;
        const double expectedFieldPx = fieldCm * 10.0 * pxPerMm;

        double wTop = simulateFieldRequiredWidth(fieldCm, true, false, tbW, pxPerMm);
        double hTop = simulateFieldRequiredHeight(fieldCm, true, false, tbH, ftH, mbH, pxPerMm);
        QCOMPARE(wTop, expectedFieldPx);
        QCOMPARE(hTop - tbH - ftH - mbH, expectedFieldPx);

        double wSide = simulateFieldRequiredWidth(fieldCm, true, true, tbW, pxPerMm);
        double hSide = simulateFieldRequiredHeight(fieldCm, true, true, tbH, ftH, mbH, pxPerMm);
        QCOMPARE(wSide - tbW, expectedFieldPx);
        QCOMPARE(hSide - ftH - mbH, expectedFieldPx);

        double wHidden = simulateFieldRequiredWidth(fieldCm, false, false, tbW, pxPerMm);
        double hHidden = simulateFieldRequiredHeight(fieldCm, false, false, tbH, ftH, mbH, pxPerMm);
        QCOMPARE(wHidden, expectedFieldPx);
        QCOMPARE(hHidden - ftH - mbH, expectedFieldPx);
    }

    void testFieldPxPreservedWhenToolbarToggled()
    {
        const double fieldCm = 15.0;
        const double pxPerMm = 3.78;
        const double tbW = 48.0;
        const double tbH = 40.0;
        const double ftH = 35.0;
        const double mbH = 25.0;
        const double expectedFieldPx = fieldCm * 10.0 * pxPerMm;

        double wVisible = simulateFieldRequiredWidth(fieldCm, true, true, tbW, pxPerMm);
        double hVisible = simulateFieldRequiredHeight(fieldCm, true, true, tbH, ftH, mbH, pxPerMm);
        double fieldPxW_visible = wVisible - tbW;
        double fieldPxH_visible = hVisible - ftH - mbH;
        QCOMPARE(fieldPxW_visible, expectedFieldPx);
        QCOMPARE(fieldPxH_visible, expectedFieldPx);

        double wHidden = simulateFieldRequiredWidth(fieldCm, false, false, tbW, pxPerMm);
        double hHidden = simulateFieldRequiredHeight(fieldCm, false, false, tbH, ftH, mbH, pxPerMm);
        double fieldPxW_hidden = wHidden;
        double fieldPxH_hidden = hHidden - ftH - mbH;
        QCOMPARE(fieldPxW_hidden, expectedFieldPx);
        QCOMPARE(fieldPxH_hidden, expectedFieldPx);
    }

    void testFieldPxPreservedTopToSideTransition()
    {
        const double fieldCm = 25.0;
        const double pxPerMm = 3.78;
        const double tbW = 48.0;
        const double tbH = 40.0;
        const double ftH = 35.0;
        const double mbH = 25.0;
        const double expectedFieldPx = fieldCm * 10.0 * pxPerMm;

        double wTop = simulateFieldRequiredWidth(fieldCm, true, false, tbW, pxPerMm);
        double hTop = simulateFieldRequiredHeight(fieldCm, true, false, tbH, ftH, mbH, pxPerMm);
        QCOMPARE(wTop, expectedFieldPx);
        QCOMPARE(hTop - tbH - ftH - mbH, expectedFieldPx);

        double wSide = simulateFieldRequiredWidth(fieldCm, true, true, tbW, pxPerMm);
        double hSide = simulateFieldRequiredHeight(fieldCm, true, true, tbH, ftH, mbH, pxPerMm);
        QCOMPARE(wSide - tbW, expectedFieldPx);
        QCOMPARE(hSide - ftH - mbH, expectedFieldPx);

        QVERIFY(wSide > wTop);
        QVERIFY(hSide < hTop);
    }

    void testFieldPxWithSmallField()
    {
        const double fieldCm = 5.0;
        const double pxPerMm = 3.78;
        const double tbW = 48.0;
        const double tbH = 40.0;
        const double ftH = 35.0;
        const double mbH = 25.0;
        const double expectedFieldPx = fieldCm * 10.0 * pxPerMm;

        double wHidden = simulateFieldRequiredWidth(fieldCm, false, false, tbW, pxPerMm);
        double wTop = simulateFieldRequiredWidth(fieldCm, true, false, tbW, pxPerMm);
        double wSide = simulateFieldRequiredWidth(fieldCm, true, true, tbW, pxPerMm);

        QCOMPARE(wHidden, expectedFieldPx);
        QCOMPARE(wTop, expectedFieldPx);
        QCOMPARE(wSide - tbW, expectedFieldPx);
    }

    void testFieldPxWithLargeField()
    {
        const double fieldCm = 30.0;
        const double pxPerMm = 3.78;
        const double tbW = 48.0;
        const double tbH = 40.0;
        const double ftH = 35.0;
        const double mbH = 25.0;
        const double expectedFieldPx = fieldCm * 10.0 * pxPerMm;

        double wHidden = simulateFieldRequiredWidth(fieldCm, false, false, tbW, pxPerMm);
        double wTop = simulateFieldRequiredWidth(fieldCm, true, false, tbW, pxPerMm);
        double wSide = simulateFieldRequiredWidth(fieldCm, true, true, tbW, pxPerMm);

        QCOMPARE(wHidden, expectedFieldPx);
        QCOMPARE(wTop, expectedFieldPx);
        QCOMPARE(wSide - tbW, expectedFieldPx);
    }

    void testToolbarSettingsPersistenceInMemory()
    {
        Settings s;

        s.setToolbarVisible(false);
        s.setToolbarOnSide(true);
        QVERIFY(!s.toolbarVisible());
        QVERIFY(s.toolbarOnSide());

        QVERIFY(!s.toolbarVisible());
        QVERIFY(s.toolbarOnSide());
        QVERIFY(!s.toolbarVisible());
        QVERIFY(s.toolbarOnSide());
    }
};

QTEST_MAIN(TestToolbar)
#include "TestToolbar.moc"