[autotests] Unit most scripted effects API

Summary:
Ready for QJSEngine port and upcoming other fixes.
Split as it makes it easier to do any before/after testing.

Test Plan:
All tests pass with the current QScriptEngine
Verified expected API against a wiki page and current code.

Reviewers: #kwin

Subscribers: kwin

Tags: #kwin

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

autotests/integration/effects/CMakeLists.txt

@@ -5,3 +5,4 @@ if (XCB_ICCCM_FOUND)
 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)

autotests/integration/effects/scripted_effects_test.cpp

@@ -0,0 +1,353 @@
+/********************************************************************
+KWin - the KDE window manager
+This file is part of the KDE project.
+
+Copyright (C) 2018 David Edmundson <davidedmundson@kde.org>
+
+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 "scripting/scriptedeffect.h"
+#include "libkwineffects/anidata_p.h"
+
+#include "composite.h"
+#include "cursor.h"
+#include "cursor.h"
+#include "effect_builtins.h"
+#include "effectloader.h"
+#include "effects.h"
+#include "kwin_wayland_test.h"
+#include "platform.h"
+#include "shell_client.h"
+#include "virtualdesktops.h"
+#include "wayland_server.h"
+#include "workspace.h"
+
+#include <QScriptContext>
+#include <QScriptEngine>
+#include <QScriptValue>
+
+#include <KConfigGroup>
+#include <KGlobalAccel>
+
+#include <KWayland/Client/compositor.h>
+#include <KWayland/Client/connection_thread.h>
+#include <KWayland/Client/registry.h>
+#include <KWayland/Client/slide.h>
+#include <KWayland/Client/surface.h>
+#include <KWayland/Client/xdgshell.h>
+
+using namespace KWin;
+static const QString s_socketName = QStringLiteral("wayland_test_effects_scripts-0");
+
+class ScriptedEffectsTest : public QObject
+{
+    Q_OBJECT
+private Q_SLOTS:
+    void initTestCase();
+    void init();
+    void cleanup();
+
+    void testEffectsHandler();
+    void testEffectsContext();
+    void testShortcuts();
+    void testAnimations_data();
+    void testAnimations();
+    void testScreenEdge();
+    void testScreenEdgeTouch();
+private:
+    ScriptedEffect *loadEffect(const QString &name);
+};
+
+class ScriptedEffectWithDebugSpy : public KWin::ScriptedEffect
+{
+    Q_OBJECT
+public:
+    ScriptedEffectWithDebugSpy();
+    bool load(const QString &name);
+    using AnimationEffect::state;
+signals:
+    void testOutput(const QString &data);
+};
+
+QScriptValue kwinEffectScriptTestOut(QScriptContext *context, QScriptEngine *engine)
+{
+    auto *script = qobject_cast<ScriptedEffectWithDebugSpy*>(context->callee().data().toQObject());
+    QString result;
+    for (int i = 0; i < context->argumentCount(); ++i) {
+        if (i > 0) {
+            result.append(QLatin1Char(' '));
+        }
+        result.append(context->argument(i).toString());
+    }
+    emit script->testOutput(result);
+
+    return engine->undefinedValue();
+}
+
+ScriptedEffectWithDebugSpy::ScriptedEffectWithDebugSpy()
+    : ScriptedEffect()
+{
+    QScriptValue testHookFunc = engine()->newFunction(kwinEffectScriptTestOut);
+    testHookFunc.setData(engine()->newQObject(this));
+    engine()->globalObject().setProperty(QStringLiteral("sendTestResponse"), testHookFunc);
+}
+
+bool ScriptedEffectWithDebugSpy::load(const QString &name)
+{
+    const QString path = QFINDTESTDATA("./scripts/" + name + ".js");
+    if (!init(name, path)) {
+        return false;
+    }
+
+    // inject our newly created effect to be registered with the EffectsHandlerImpl::loaded_effects
+    // this is private API so some horrible code is used to find the internal effectloader
+    // and register ourselves
+    auto c = effects->children();
+    for (auto it = c.begin(); it != c.end(); ++it) {
+        if (qstrcmp((*it)->metaObject()->className(), "KWin::EffectLoader") != 0) {
+            continue;
+        }
+        QMetaObject::invokeMethod(*it, "effectLoaded", Q_ARG(KWin::Effect*, this), Q_ARG(QString, name));
+        break;
+    }
+
+    return (static_cast<EffectsHandlerImpl*>(effects)->isEffectLoaded(name));
+}
+
+void ScriptedEffectsTest::initTestCase()
+{
+    qRegisterMetaType<KWin::ShellClient*>();
+    qRegisterMetaType<KWin::AbstractClient*>();
+    qRegisterMetaType<KWin::Effect*>();
+    QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
+    QVERIFY(workspaceCreatedSpy.isValid());
+    kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
+    QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
+
+    ScriptedEffectLoader loader;
+
+    // disable all effects - we don't want to have it interact with the rendering
+    auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
+    KConfigGroup plugins(config, QStringLiteral("Plugins"));
+    const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
+    for (QString name : builtinNames) {
+        plugins.writeEntry(name + QStringLiteral("Enabled"), false);
+    }
+
+    config->sync();
+    kwinApp()->setConfig(config);
+
+    qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
+    qputenv("KWIN_EFFECTS_FORCE_ANIMATIONS", "1");
+    kwinApp()->start();
+    QVERIFY(workspaceCreatedSpy.wait());
+    QVERIFY(Compositor::self());
+
+    KWin::VirtualDesktopManager::self()->setCount(2);
+}
+
+void ScriptedEffectsTest::init()
+{
+    QVERIFY(Test::setupWaylandConnection());
+}
+
+void ScriptedEffectsTest::cleanup()
+{
+    Test::destroyWaylandConnection();
+    auto *e = static_cast<EffectsHandlerImpl*>(effects);
+    while (!e->loadedEffects().isEmpty()) {
+        const QString effect = e->loadedEffects().first();
+        e->unloadEffect(effect);
+        QVERIFY(!e->isEffectLoaded(effect));
+    }
+}
+
+void ScriptedEffectsTest::testEffectsHandler()
+{
+    // this triggers and tests some of the signals in EffectHandler, which is exposed to JS as context property "effects"
+    auto *effect = new ScriptedEffectWithDebugSpy; // cleaned up in ::clean
+    QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
+    auto waitFor = [&effectOutputSpy, this](const QString &expected) {
+        QVERIFY(effectOutputSpy.count() == 1 || effectOutputSpy.wait());
+        QCOMPARE(effectOutputSpy.last().first(), expected);
+        effectOutputSpy.clear();
+    };
+    QVERIFY(effect->load("effectsHandler"));
+
+    // trigger windowAdded signal
+
+    // create a window
+    using namespace KWayland::Client;
+    auto *surface = Test::createSurface(Test::waylandCompositor());
+    QVERIFY(surface);
+    auto *shellSurface = Test::createXdgShellV6Surface(surface, surface);
+    QVERIFY(shellSurface);
+    shellSurface->setTitle("Window 1");
+    auto *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
+    QVERIFY(c);
+    QCOMPARE(workspace()->activeClient(), c);
+
+    waitFor("windowAdded - Window 1");
+
+    // windowMinimsed
+    c->minimize();
+    waitFor("windowMinimized - Window 1");
+
+    c->unminimize();
+    waitFor("windowUnminimized - Window 1");
+
+    surface->deleteLater();
+    waitFor("windowClosed - Window 1");
+
+    // desktop management
+    KWin::VirtualDesktopManager::self()->setCurrent(2);
+    waitFor("desktopChanged - 1 2");
+}
+
+void ScriptedEffectsTest::testEffectsContext()
+{
+    // this tests misc non-objects exposed to the script engine: animationTime, displaySize, use of external enums
+
+    auto *effect = new ScriptedEffectWithDebugSpy; // cleaned up in ::clean
+    QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
+    QVERIFY(effect->load("effectContext"));
+    QCOMPARE(effectOutputSpy[0].first(), "1280x1024");
+    QCOMPARE(effectOutputSpy[1].first(), "100");
+    QCOMPARE(effectOutputSpy[2].first(), "2");
+    QCOMPARE(effectOutputSpy[3].first(), "0");
+}
+
+void ScriptedEffectsTest::testShortcuts()
+{
+    // this tests method registerShortcut
+    auto *effect = new ScriptedEffectWithDebugSpy; // cleaned up in ::clean
+    QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
+    QVERIFY(effect->load("shortcutsTest"));
+    QCOMPARE(effect->shortcutCallbacks().count(), 1);
+    QAction *action = effect->shortcutCallbacks().keys()[0];
+    QCOMPARE(action->objectName(), "testShortcut");
+    QCOMPARE(action->text(), "Test Shortcut");
+    QCOMPARE(KGlobalAccel::self()->shortcut(action).first(), QKeySequence("Meta+Shift+Y"));
+    action->trigger();
+    QCOMPARE(effectOutputSpy[0].first(), "shortcutTriggered");
+}
+
+void ScriptedEffectsTest::testAnimations_data()
+{
+    QTest::addColumn<QString>("file");
+    QTest::addColumn<int>("animationCount");
+
+    QTest::newRow("single") << "animationTest" << 1;
+    QTest::newRow("multi")  << "animationTestMulti" << 2;
+}
+
+void ScriptedEffectsTest::testAnimations()
+{
+    // this tests animate/set/cancel
+    // methods take either an int or an array, as forced in the data above
+    // also splits animate vs effects.animate(..)
+
+    QFETCH(QString, file);
+    QFETCH(int, animationCount);
+
+    auto *effect = new ScriptedEffectWithDebugSpy;
+    QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
+    QVERIFY(effect->load(file));
+
+    // animated after window added connect
+    using namespace KWayland::Client;
+    auto *surface = Test::createSurface(Test::waylandCompositor());
+    QVERIFY(surface);
+    auto *shellSurface = Test::createXdgShellV6Surface(surface, surface);
+    QVERIFY(shellSurface);
+    shellSurface->setTitle("Window 1");
+    auto *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
+    QVERIFY(c);
+    QCOMPARE(workspace()->activeClient(), c);
+
+    // we are running the event loop during renderAndWaitForShown
+    // some time will pass with the event loop running between the window being added and getting to here
+    // anim.duration is an aboslute value, but retarget will update the duration based on time passed
+    int timePassed = 0;
+
+    {
+        const AnimationEffect::AniMap state = effect->state();
+        QCOMPARE(state.count(), 1);
+        QCOMPARE(state.firstKey(), c->effectWindow());
+        const auto &animationsForWindow = state.first().first;
+        QCOMPARE(animationsForWindow.count(), animationCount);
+        QCOMPARE(animationsForWindow[0].duration, 100);
+        QCOMPARE(animationsForWindow[0].to, FPx2(1.4));
+        QCOMPARE(animationsForWindow[0].attribute, AnimationEffect::Scale);
+        QCOMPARE(animationsForWindow[0].keepAtTarget, false);
+        timePassed = animationsForWindow[0].time;
+        if (animationCount == 2) {
+            QCOMPARE(animationsForWindow[1].duration, 100);
+            QCOMPARE(animationsForWindow[1].to, FPx2(0.0));
+            QCOMPARE(animationsForWindow[1].attribute, AnimationEffect::Opacity);
+            QCOMPARE(animationsForWindow[1].keepAtTarget, false);
+        }
+    }
+    QCOMPARE(effectOutputSpy[0].first(), "true");
+
+    // window state changes, scale should be retargetted
+
+    c->setMinimized(true);
+    {
+        const AnimationEffect::AniMap state = effect->state();
+        QCOMPARE(state.count(), 1);
+        const auto &animationsForWindow = state.first().first;
+        QCOMPARE(animationsForWindow.count(), animationCount);
+        QCOMPARE(animationsForWindow[0].duration, 200 + timePassed);
+        QCOMPARE(animationsForWindow[0].to, FPx2(1.5));
+        QCOMPARE(animationsForWindow[0].attribute, AnimationEffect::Scale);
+        QCOMPARE(animationsForWindow[0].keepAtTarget, false);
+        if (animationCount == 2) {
+            QCOMPARE(animationsForWindow[1].duration, 200 + timePassed);
+            QCOMPARE(animationsForWindow[1].to, FPx2(1.5));
+            QCOMPARE(animationsForWindow[1].attribute, AnimationEffect::Opacity);
+            QCOMPARE(animationsForWindow[1].keepAtTarget, false);
+        }
+    }
+    c->setMinimized(false);
+    {
+        const AnimationEffect::AniMap state = effect->state();
+        QCOMPARE(state.count(), 0);
+    }
+}
+
+void ScriptedEffectsTest::testScreenEdge()
+{
+    // this test checks registerScreenEdge functions
+    auto *effect = new ScriptedEffectWithDebugSpy; // cleaned up in ::clean
+    QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
+    QVERIFY(effect->load("screenEdgeTest"));
+    effect->borderActivated(KWin::ElectricTopRight);
+    QCOMPARE(effectOutputSpy.count(), 1);
+}
+
+void ScriptedEffectsTest::testScreenEdgeTouch()
+{
+    // this test checks registerTouchScreenEdge functions
+    auto *effect = new ScriptedEffectWithDebugSpy; // cleaned up in ::clean
+    QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
+    QVERIFY(effect->load("screenEdgeTouchTest"));
+    auto actions = effect->findChildren<QAction*>(QString(), Qt::FindDirectChildrenOnly);
+    actions[0]->trigger();
+    QCOMPARE(effectOutputSpy.count(), 1);
+}
+
+WAYLANDTEST_MAIN(ScriptedEffectsTest)
+#include "scripted_effects_test.moc"

autotests/integration/effects/scripts/animationTest.js

@@ -0,0 +1,12 @@
+effects.windowAdded.connect(function(w) {
+    w.anim1 = effect.animate(w, Effect.Scale, 100, 1.4, 0.2);
+    sendTestResponse(typeof(w.anim1) == "number");
+});
+
+effects.windowUnminimized.connect(function(w) {
+    cancel(w.anim1);
+});
+
+effects.windowMinimized.connect(function(w) {
+    retarget(w.anim1, 1.5, 200);
+});

autotests/integration/effects/scripts/animationTestMulti.js

@@ -0,0 +1,24 @@
+effects.windowAdded.connect(function(w) {
+    w.anim1 = animate({
+        window: w,
+        duration: 100,
+        animations: [{
+            type: Effect.Scale,
+            curve: Effect.GaussianCurve,
+            to: 1.4
+        }, {
+            type: Effect.Opacity,
+            curve: Effect.GaussianCurve,
+            to: 0.0
+        }]
+    });
+    sendTestResponse(typeof(w.anim1) == "object" && Array.isArray(w.anim1));
+});
+
+effects.windowUnminimized.connect(function(w) {
+    cancel(w.anim1);
+});
+
+effects.windowMinimized.connect(function(w) {
+    retarget(w.anim1, 1.5, 200);
+});

autotests/integration/effects/scripts/effectContext.js

@@ -0,0 +1,6 @@
+sendTestResponse(displayWidth() + "x" + displayHeight());
+sendTestResponse(animationTime(100));
+
+//test enums for Effect / QEasingCurve
+sendTestResponse(Effect.Saturation)
+sendTestResponse(QEasingCurve.Linear)

autotests/integration/effects/scripts/effectsHandler.js

@@ -0,0 +1,15 @@
+effects.windowAdded.connect(function(window) {
+    sendTestResponse("windowAdded - " + window.caption);
+});
+effects.windowClosed.connect(function(window) {
+    sendTestResponse("windowClosed - " + window.caption);
+});
+effects.windowMinimized.connect(function(window) {
+    sendTestResponse("windowMinimized - " + window.caption);
+});
+effects.windowUnminimized.connect(function(window) {
+    sendTestResponse("windowUnminimized - " + window.caption);
+});
+effects['desktopChanged(int,int)'].connect(function(old, current) {
+    sendTestResponse("desktopChanged - " + old + " " + current);
+});

autotests/integration/effects/scripts/screenEdgeTest.js

@@ -0,0 +1,3 @@
+registerScreenEdge(1, function() {
+    sendTestResponse("triggered");
+});

autotests/integration/effects/scripts/screenEdgeTouchTest.js

@@ -0,0 +1,3 @@
+registerTouchScreenEdge(1, function() {
+    sendTestResponse("triggered");
+});

autotests/integration/effects/scripts/shortcutsTest.js

@@ -0,0 +1,3 @@
+registerShortcut("testShortcut", "Test Shortcut", "Meta+Shift+Y", function() {
+    sendTestResponse("shortcutTriggered");
+});

libkwineffects/anidata_p.h

@@ -27,7 +27,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 namespace KWin {
 
-class AniData {
+class KWINEFFECTS_EXPORT AniData {
 public:
     AniData();
     AniData(AnimationEffect::Attribute a, int meta, int ms, const FPx2 &to,

libkwineffects/kwinanimationeffect.cpp

@@ -948,5 +948,11 @@ QString AnimationEffect::debug(const QString &/*parameter*/) const
     return dbg;
 }
 
+AnimationEffect::AniMap AnimationEffect::state() const
+{
+    Q_D(const AnimationEffect);
+    return d->m_animations;
+}
+
 
 #include "moc_kwinanimationeffect.cpp"

libkwineffects/kwinanimationeffect.h

@@ -97,6 +97,8 @@ class KWINEFFECTS_EXPORT AnimationEffect : public Effect
     Q_ENUMS(Attribute)
     Q_ENUMS(MetaType)
 public:
+    typedef QMap< EffectWindow*, QPair<QList<AniData>, QRect> > AniMap;
+
     enum Anchor { Left = 1<<0, Top = 1<<1, Right = 1<<2, Bottom = 1<<3,
                   Horizontal = Left|Right, Vertical = Top|Bottom, Mouse = 1<<4  };
     enum Attribute {
@@ -205,6 +207,9 @@ protected:
     virtual void genericAnimation( EffectWindow *w, WindowPaintData &data, float progress, uint meta )
     {Q_UNUSED(w); Q_UNUSED(data); Q_UNUSED(progress); Q_UNUSED(meta);}
 
+    //Internal for unit tests
+    AniMap state() const;
+
 private:
     quint64 p_animate( EffectWindow *w, Attribute a, uint meta, int ms, FPx2 to, QEasingCurve curve, int delay, FPx2 from, bool keepAtTarget );
     QRect clipRect(const QRect &windowRect, const AniData&) const;
@@ -222,7 +227,6 @@ private Q_SLOTS:
     void _expandedGeometryChanged(KWin::EffectWindow *w, const QRect &old);
 private:
     static QElapsedTimer s_clock;
-    typedef QMap< EffectWindow*, QPair<QList<AniData>, QRect> > AniMap;
     AnimationEffectPrivate * const d_ptr;
     Q_DECLARE_PRIVATE(AnimationEffect)
 };

scripting/scriptedeffect.cpp

@@ -678,4 +678,9 @@ bool ScriptedEffect::unregisterTouchScreenCallback(int edge)
     return true;
 }
 
+QScriptEngine *ScriptedEffect::engine() const
+{
+    return m_engine;
+}
+
 } // namespace

scripting/scriptedeffect.h

@@ -109,14 +109,15 @@ Q_SIGNALS:
     void animationEnded(KWin::EffectWindow *w, quint64 animationId);
 
 protected:
+    ScriptedEffect();
+    QScriptEngine *engine() const;
+    bool init(const QString &effectName, const QString &pathToScript);
     void animationEnded(KWin::EffectWindow *w, Attribute a, uint meta);
 
 private Q_SLOTS:
     void signalHandlerException(const QScriptValue &value);
     void globalShortcutTriggered();
 private:
-    ScriptedEffect();
-    bool init(const QString &effectName, const QString &pathToScript);
     QScriptEngine *m_engine;
     QString m_effectName;
     QString m_scriptFile;