[autotests] Test window open/close animations

Summary:
The idea behind this autotest is to verify that different window
open/close animation effects behave similarly.

Currently, we just check whether Fade/Glide/Scale effect tries to animate
the appearing or the disappearing of toplevels. In the future, the
autotest will be extended to verify that there are no conflicts between
those three effects and the Login/Logout effect, etc.

Test Plan: Ran the test, found a bug in the Fade effect, fixed it.

Reviewers: #kwin, graesslin

Reviewed By: #kwin, graesslin

Subscribers: kwin

Tags: #kwin

Differential Revision: https://phabricator.kde.org/D17526

autotests/integration/effects/CMakeLists.txt

@@ -6,3 +6,4 @@ endif()
 integrationTest(NAME testFade SRCS fade_test.cpp)
 integrationTest(WAYLAND_ONLY NAME testEffectWindowGeometry SRCS windowgeometry_test.cpp)
 integrationTest(NAME testScriptedEffects SRCS scripted_effects_test.cpp)
+integrationTest(WAYLAND_ONLY NAME testToplevelOpenCloseAnimation SRCS toplevel_open_close_animation_test.cpp)

autotests/integration/effects/toplevel_open_close_animation_test.cpp

@@ -0,0 +1,218 @@
+/********************************************************************
+KWin - the KDE window manager
+This file is part of the KDE project.
+
+Copyright (C) 2018 Vlad Zagorodniy <vladzzag@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*********************************************************************/
+
+#include "kwin_wayland_test.h"
+
+#include "abstract_client.h"
+#include "deleted.h"
+#include "effectloader.h"
+#include "effects.h"
+#include "platform.h"
+#include "shell_client.h"
+#include "wayland_server.h"
+#include "workspace.h"
+
+#include "effect_builtins.h"
+
+#include <KWayland/Client/surface.h>
+#include <KWayland/Client/xdgshell.h>
+
+using namespace KWin;
+
+static const QString s_socketName = QStringLiteral("wayland_test_effects_toplevel_open_close_animation-0");
+
+class ToplevelOpenCloseAnimationTest : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void initTestCase();
+    void init();
+    void cleanup();
+
+    void testAnimateToplevels_data();
+    void testAnimateToplevels();
+    void testDontAnimatePopups_data();
+    void testDontAnimatePopups();
+};
+
+void ToplevelOpenCloseAnimationTest::initTestCase()
+{
+    qputenv("XDG_DATA_DIRS", QCoreApplication::applicationDirPath().toUtf8());
+
+    qRegisterMetaType<KWin::AbstractClient *>();
+    qRegisterMetaType<KWin::Deleted *>();
+    qRegisterMetaType<KWin::ShellClient *>();
+    QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
+    QVERIFY(workspaceCreatedSpy.isValid());
+    kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
+    QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
+
+    auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
+    KConfigGroup plugins(config, QStringLiteral("Plugins"));
+    ScriptedEffectLoader loader;
+    const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
+    for (const QString &name : builtinNames) {
+        plugins.writeEntry(name + QStringLiteral("Enabled"), false);
+    }
+    config->sync();
+    kwinApp()->setConfig(config);
+
+    qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
+    qputenv("KWIN_EFFECTS_FORCE_ANIMATIONS", QByteArrayLiteral("1"));
+
+    kwinApp()->start();
+    QVERIFY(workspaceCreatedSpy.wait());
+    waylandServer()->initWorkspace();
+}
+
+void ToplevelOpenCloseAnimationTest::init()
+{
+    QVERIFY(Test::setupWaylandConnection());
+}
+
+void ToplevelOpenCloseAnimationTest::cleanup()
+{
+    auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
+    QVERIFY(effectsImpl);
+    effectsImpl->unloadAllEffects();
+    QVERIFY(effectsImpl->loadedEffects().isEmpty());
+
+    Test::destroyWaylandConnection();
+}
+
+void ToplevelOpenCloseAnimationTest::testAnimateToplevels_data()
+{
+    QTest::addColumn<QString>("effectName");
+
+    QTest::newRow("Fade")   << QStringLiteral("kwin4_effect_fade");
+    QTest::newRow("Glide")  << QStringLiteral("glide");
+    QTest::newRow("Scale")  << QStringLiteral("kwin4_effect_scale");
+}
+
+void ToplevelOpenCloseAnimationTest::testAnimateToplevels()
+{
+    // This test verifies that window open/close animation effects try to
+    // animate the appearing and the disappearing of toplevel windows.
+
+    // Make sure that we have the right effects ptr.
+    auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
+    QVERIFY(effectsImpl);
+
+    // Load effect that will be tested.
+    QFETCH(QString, effectName);
+    QVERIFY(effectsImpl->loadEffect(effectName));
+    QCOMPARE(effectsImpl->loadedEffects().count(), 1);
+    QCOMPARE(effectsImpl->loadedEffects().first(), effectName);
+    Effect *effect = effectsImpl->findEffect(effectName);
+    QVERIFY(effect);
+    QVERIFY(!effect->isActive());
+
+    // Create the test client.
+    using namespace KWayland::Client;
+    QScopedPointer<Surface> surface(Test::createSurface());
+    QVERIFY(!surface.isNull());
+    QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
+    QVERIFY(!shellSurface.isNull());
+    ShellClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
+    QVERIFY(client);
+    QVERIFY(effect->isActive());
+
+    // None of effects lasts longer than 1000ms, so after that duration the effect
+    // should not be active anymore, i.e. the animation is complete.
+    QTest::qWait(1000);
+    QVERIFY(!effect->isActive());
+
+    // Close the test client, the effect should start animating the disappearing
+    // of the client.
+    QSignalSpy windowClosedSpy(client, &ShellClient::windowClosed);
+    QVERIFY(windowClosedSpy.isValid());
+    shellSurface.reset();
+    surface.reset();
+    QVERIFY(windowClosedSpy.wait());
+    QVERIFY(effect->isActive());
+
+    // None of effects lasts longer than 1000ms, so after that duration the effect
+    // should not be active anymore, i.e. the animation is complete.
+    QTest::qWait(1000);
+    QVERIFY(!effect->isActive());
+}
+
+void ToplevelOpenCloseAnimationTest::testDontAnimatePopups_data()
+{
+    QTest::addColumn<QString>("effectName");
+
+    QTest::newRow("Fade")   << QStringLiteral("kwin4_effect_fade");
+    QTest::newRow("Glide")  << QStringLiteral("glide");
+    QTest::newRow("Scale")  << QStringLiteral("kwin4_effect_scale");
+}
+
+void ToplevelOpenCloseAnimationTest::testDontAnimatePopups()
+{
+    // This test verifies that window open/close animation effects don't try
+    // to animate popups(e.g. popup menus, tooltips, etc).
+
+    // Make sure that we have the right effects ptr.
+    auto effectsImpl = qobject_cast<EffectsHandlerImpl *>(effects);
+    QVERIFY(effectsImpl);
+
+    // Create the main window.
+    using namespace KWayland::Client;
+    QScopedPointer<Surface> mainWindowSurface(Test::createSurface());
+    QVERIFY(!mainWindowSurface.isNull());
+    QScopedPointer<XdgShellSurface> mainWindowShellSurface(Test::createXdgShellStableSurface(mainWindowSurface.data()));
+    QVERIFY(!mainWindowShellSurface.isNull());
+    ShellClient *mainWindow = Test::renderAndWaitForShown(mainWindowSurface.data(), QSize(100, 50), Qt::blue);
+    QVERIFY(mainWindow);
+
+    // Load effect that will be tested.
+    QFETCH(QString, effectName);
+    QVERIFY(effectsImpl->loadEffect(effectName));
+    QCOMPARE(effectsImpl->loadedEffects().count(), 1);
+    QCOMPARE(effectsImpl->loadedEffects().first(), effectName);
+    Effect *effect = effectsImpl->findEffect(effectName);
+    QVERIFY(effect);
+    QVERIFY(!effect->isActive());
+
+    // Create a popup, it should not be animated.
+    QScopedPointer<Surface> popupSurface(Test::createSurface());
+    QVERIFY(!popupSurface.isNull());
+    XdgPositioner positioner(QSize(20, 20), QRect(0, 0, 10, 10));
+    positioner.setGravity(Qt::BottomEdge | Qt::RightEdge);
+    positioner.setAnchorEdge(Qt::BottomEdge | Qt::LeftEdge);
+    QScopedPointer<XdgShellPopup> popupShellSurface(Test::createXdgShellStablePopup(popupSurface.data(), mainWindowShellSurface.data(), positioner));
+    QVERIFY(!popupShellSurface.isNull());
+    ShellClient *popup = Test::renderAndWaitForShown(popupSurface.data(), positioner.initialSize(), Qt::red);
+    QVERIFY(popup);
+    QVERIFY(popup->isPopupWindow());
+    QCOMPARE(popup->transientFor(), mainWindow);
+    QVERIFY(!effect->isActive());
+
+    // Destroy the popup, it should not be animated.
+    QSignalSpy popupClosedSpy(popup, &ShellClient::windowClosed);
+    QVERIFY(popupClosedSpy.isValid());
+    popupShellSurface.reset();
+    popupSurface.reset();
+    QVERIFY(popupClosedSpy.wait());
+    QVERIFY(!effect->isActive());
+}
+
+WAYLANDTEST_MAIN(ToplevelOpenCloseAnimationTest)
+#include "toplevel_open_close_animation_test.moc"

effects/fade/package/contents/code/main.js

@@ -34,7 +34,7 @@ function isFadeWindow(w) {
     if (blacklist.indexOf(w.windowClass) != -1) {
         return false;
     }
-    if (w.popup) {
+    if (w.popupWindow) {
         return false;
     }
     if (w.x11Client && !w.managed) {