Differential D14482 Diff 38809 autotests/integration/effects/scripted_effects_test.cpp

Changeset View

Standalone View

View Options

autotests/integration/effects/scripted_effects_test.cpp

  • This file was added.
1​/********************************************************************
2​KWin - the KDE window manager
3​This file is part of the KDE project.
4​
5​Copyright (C) 2018 David Edmundson <davidedmundson@kde.org>
6​
7​This program is free software; you can redistribute it and/or modify
8​it under the terms of the GNU General Public License as published by
9​the Free Software Foundation; either version 2 of the License, or
10​(at your option) any later version.
11​
12​This program is distributed in the hope that it will be useful,
13​but WITHOUT ANY WARRANTY; without even the implied warranty of
14​MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15​GNU General Public License for more details.
16​
17​You should have received a copy of the GNU General Public License
18​along with this program. If not, see <http://www.gnu.org/licenses/>.
19​*********************************************************************/
20​
21​#include "scripting/scriptedeffect.h"
22​#include "libkwineffects/anidata_p.h"
23​
24​#include "composite.h"
25​#include "cursor.h"
26​#include "cursor.h"
27​#include "effect_builtins.h"
28​#include "effectloader.h"
29​#include "effects.h"
30​#include "kwin_wayland_test.h"
31​#include "platform.h"
32​#include "shell_client.h"
33​#include "virtualdesktops.h"
34​#include "wayland_server.h"
35​#include "workspace.h"
36​
zzagUnsubmitted
Done

Please sort includes.

zzag: Please sort includes.
37​#include <QScriptContext>
38​#include <QScriptEngine>
39​#include <QScriptValue>
40​
41​#include <KConfigGroup>
zzagUnsubmitted
Not Done

Sort them too.

zzag: Sort them too.
42​#include <KGlobalAccel>
43​
44​#include <KWayland/Client/compositor.h>
45​#include <KWayland/Client/connection_thread.h>
46​#include <KWayland/Client/registry.h>
47​#include <KWayland/Client/slide.h>
48​#include <KWayland/Client/surface.h>
zzagUnsubmitted
Not Done

Dup.

zzag: Dup.
49​#include <KWayland/Client/xdgshell.h>
50​
51​using namespace KWin;
52​static const QString s_socketName = QStringLiteral("wayland_test_effects_scripts-0");
53​class ScriptedEffectsTest : public QObject
54​{
55​ Q_OBJECT
56​private Q_SLOTS:
57​ void initTestCase();
zzagUnsubmitted
Done

Indent it?

Also, a question: why some people don't indent Q_OBJECT, Q_PROPERTY, etc? Is there some reason?

zzag: Indent it? Also, a question: why some people don't indent Q_OBJECT, Q_PROPERTY, etc? Is there…
davidedmundsonAuthorUnsubmitted
Not Done

Also, a question: why some people don't indent Q_OBJECT, Q_PROPERTY, etc? Is there some reason?

No reason.

davidedmundson: >Also, a question: why some people don't indent Q_OBJECT, Q_PROPERTY, etc? Is there some reason?
58​ void init();
59​ void cleanup();
60​
61​ void effectHandlerTest();
62​ void effectContextTest();
63​ void shortcutsTest();
64​ void animationTest_data();
65​ void animationTest();
66​ void screenEdgeTest();
67​ void screenEdgeTouchTest();
68​private:
69​ ScriptedEffect *loadEffect(const QString &name);
70​};
71​
72​class ScriptedEffectWithDebugSpy : public KWin::ScriptedEffect
73​{
74​ Q_OBJECT
zzagUnsubmitted
Done

Please put '{' on a new line.

zzag: Please put '{' on a new line.
75​public:
76​ ScriptedEffectWithDebugSpy();
77​ bool load(const QString &name);
78​ using AnimationEffect::state;
79​signals:
80​ void testOutput(const QString &data);
81​};
82​
83​QScriptValue kwinEffectScriptTestOut(QScriptContext *context, QScriptEngine *engine)
84​{
85​ auto *script = qobject_cast<ScriptedEffectWithDebugSpy*>(context->callee().data().toQObject());
86​ QString result;
zzagUnsubmitted
Done

auto *script

zzag: `auto *script`
87​ for (int i = 0; i < context->argumentCount(); ++i) {
88​ if (i > 0) {
89​ result.append(QLatin1Char(' '));
90​ }
91​ result.append(context->argument(i).toString());
92​ }
93​ emit script->testOutput(result);
94​
95​ return engine->undefinedValue();
96​}
97​
98​ScriptedEffectWithDebugSpy::ScriptedEffectWithDebugSpy()
99​ : ScriptedEffect()
100​{
101​ QScriptValue testHookFunc = engine()->newFunction(kwinEffectScriptTestOut);
102​ testHookFunc.setData(engine()->newQObject(this));
103​ engine()->globalObject().setProperty(QStringLiteral("sendTestResponse"), testHookFunc);
104​}
105​
106​bool ScriptedEffectWithDebugSpy::load(const QString &name)
107​{
108​ const QString path = QFINDTESTDATA("./scripts/" + name + ".js");
109​ if (!init(name, path)) {
110​ return false;
111​ }
112​
113​ //inject our newly created effect to be registered with the EffectsHandlerImpl::loaded_effects
114​ //this is private API so some horrible code is used to find the internal effectloader
zzagUnsubmitted
Done

That's not really obvious way to load effects so please add a comment what's going on here. :-)

zzag: That's not really obvious way to load effects so please add a comment what's going on here. :-)
115​ //and register ourselves
116​ auto c = effects->children();
117​ for (auto it = c.begin(); it != c.end(); ++it) {
118​ if (qstrcmp((*it)->metaObject()->className(), "KWin::EffectLoader") != 0) {
119​ continue;
120​ }
121​ QMetaObject::invokeMethod(*it, "effectLoaded", Q_ARG(KWin::Effect*, this), Q_ARG(QString, name));
122​ break;
123​ }
124​
125​ return (static_cast<EffectsHandlerImpl*>(effects)->isEffectLoaded(name));
126​}
127​
128​void ScriptedEffectsTest::initTestCase()
129​{
130​ qRegisterMetaType<KWin::ShellClient*>();
131​ qRegisterMetaType<KWin::AbstractClient*>();
132​ qRegisterMetaType<KWin::Effect*>();
133​ QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
134​ QVERIFY(workspaceCreatedSpy.isValid());
135​ kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
136​ QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
137​
138​ ScriptedEffectLoader loader;
139​
140​ // disable all effects - we don't want to have it interact with the rendering
141​ auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
142​ KConfigGroup plugins(config, QStringLiteral("Plugins"));
143​ const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
144​ for (QString name : builtinNames) {
145​ plugins.writeEntry(name + QStringLiteral("Enabled"), false);
146​ }
147​
148​ config->sync();
149​ kwinApp()->setConfig(config);
150​
151​ qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
152​ qputenv("KWIN_EFFECTS_FORCE_ANIMATIONS", "1");
153​ kwinApp()->start();
154​ QVERIFY(workspaceCreatedSpy.wait());
155​ QVERIFY(Compositor::self());
156​
157​ KWin::VirtualDesktopManager::self()->setCount(2);
158​}
159​
160​void ScriptedEffectsTest::init()
161​{
162​ QVERIFY(Test::setupWaylandConnection());
163​}
164​
165​void ScriptedEffectsTest::cleanup()
166​{
167​ Test::destroyWaylandConnection();
zzagUnsubmitted
Done

auto *e

zzag: `auto *e`
168​ auto *e = static_cast<EffectsHandlerImpl*>(effects);
169​ while (!e->loadedEffects().isEmpty()) {
170​ const QString effect = e->loadedEffects().first();
171​ e->unloadEffect(effect);
172​ QVERIFY(!e->isEffectLoaded(effect));
173​ }
174​}
175​
176​void ScriptedEffectsTest::effectHandlerTest()
177​{
178​ //this triggers and tests some of the signals in EffectHandler, which is exposed to JS as context property "effects"
zzagUnsubmitted
Done

Please keep '*'. In some cases, '*' matters.

zzag: Please keep '*'. In some cases, '*' matters.
179​ auto *effect = new ScriptedEffectWithDebugSpy; //cleaned up in ::clean
180​ QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
181​ auto waitFor = [&effectOutputSpy, this](const QString &expected) {
182​ QVERIFY(effectOutputSpy.count() == 1 || effectOutputSpy.wait());
183​ QCOMPARE(effectOutputSpy.last().first(), expected);
184​ effectOutputSpy.clear();
185​ };
zzagUnsubmitted
Not Done

Please use QStringLiteral.

zzag: Please use QStringLiteral.
davidedmundsonAuthorUnsubmitted
Not Done

It's not going to do speed optimisations in unit tests

davidedmundson: It's not going to do speed optimisations in unit tests
186​ QVERIFY(effect->load("effectsHandler"));
187​
188​ //trigger windowAdded signal
189​
190​ // create a window
191​ using namespace KWayland::Client;
192​ auto *surface = Test::createSurface(Test::waylandCompositor());
193​ QVERIFY(surface);
194​ auto *shellSurface = Test::createXdgShellV6Surface(surface, surface);
195​ QVERIFY(shellSurface);
196​ shellSurface->setTitle("Window 1");
197​ auto *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
zzagUnsubmitted
Done

auto *

zzag: `auto *`
198​ QVERIFY(c);
199​ QCOMPARE(workspace()->activeClient(), c);
200​
zzagUnsubmitted
Done

auto *

zzag: `auto *`
201​ waitFor("windowAdded - Window 1");
202​
203​ //windowMinimsed
204​ c->minimize();
205​ waitFor("windowMinimized - Window 1");
206​
207​ c->unminimize();
208​ waitFor("windowUnminimized - Window 1");
209​
210​ surface->deleteLater();
211​ waitFor("windowClosed - Window 1");
212​
213​ //desktop management
214​ KWin::VirtualDesktopManager::self()->setCurrent(2);
215​ waitFor("desktopChanged - 1 2");
216​}
217​
218​void ScriptedEffectsTest::effectContextTest()
219​{
220​ //this tests misc non-objects exposed to the script engine: animationTime, displaySize
221​ auto *effect = new ScriptedEffectWithDebugSpy; //cleaned up in ::clean
222​ QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
223​ QVERIFY(effect->load("effectContext"));
224​ QCOMPARE(effectOutputSpy[0].first(), "1280x1024");
225​ QCOMPARE(effectOutputSpy[1].first(), "100");
226​ QCOMPARE(effectOutputSpy[2].first(), "2");
227​ QCOMPARE(effectOutputSpy[3].first(), "0");
228​}
229​
230​void ScriptedEffectsTest::shortcutsTest()
231​{
232​ //this tests method registerShortcut
233​ auto *effect = new ScriptedEffectWithDebugSpy; //cleaned up in ::clean
234​ QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
235​ QVERIFY(effect->load("shortcutsTest"));
236​ QCOMPARE(effect->shortcutCallbacks().count(), 1);
237​ QAction *action = effect->shortcutCallbacks().keys()[0];
238​ QCOMPARE(action->objectName(), "testShortcut");
239​ QCOMPARE(action->text(), "Test Shortcut");
240​ QCOMPARE(KGlobalAccel::self()->shortcut(action).first(), QKeySequence("Meta+Shift+Y"));
zzagUnsubmitted
Done

auto *. (It's QAction*, right? I use vim, so it's a little bit problematic to deduce type of action)

zzag: `auto *`. (It's `QAction*`, right? I use vim, so it's a little bit problematic to deduce type…
241​ action->trigger();
242​ QCOMPARE(effectOutputSpy[0].first(), "shortcutTriggered");
243​}
244​
245​void ScriptedEffectsTest::animationTest_data()
246​{
247​ QTest::addColumn<QString>("file");
248​ QTest::addColumn<int>("animationCount");
249​
250​ QTest::newRow("single") << "animationTest" << 1;
251​ QTest::newRow("multi") << "animationTestMulti" << 2;
252​}
253​
254​void ScriptedEffectsTest::animationTest()
255​{
256​ //this tests animate/set/cancel
257​ //methods take either an int or an array, as forced in the data above
258​ //also splits animate vs effects.animate(..)
259​
260​ QFETCH(QString, file);
261​ QFETCH(int, animationCount);
262​
263​ auto *effect = new ScriptedEffectWithDebugSpy;
264​ QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
265​ QVERIFY(effect->load(file));
266​
267​ //animated after window added connect
268​ using namespace KWayland::Client;
269​ auto *surface = Test::createSurface(Test::waylandCompositor());
270​ QVERIFY(surface);
271​ auto *shellSurface = Test::createXdgShellV6Surface(surface, surface);
272​ QVERIFY(shellSurface);
273​ shellSurface->setTitle("Window 1");
274​ auto *c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
275​ QVERIFY(c);
276​ QCOMPARE(workspace()->activeClient(), c);
277​
278​ //we are running the event loop during renderAndWaitForShown
279​ //some time will pass with the event loop running between the window being added and getting to here
280​ //anim.duration is an aboslute value, but retarget will update the duration based on time passed
281​ int timePassed = 0;
282​
283​ {
284​ const AnimationEffect::AniMap state = effect->state();
285​ QCOMPARE(state.count(), 1);
286​ QCOMPARE(state.firstKey(), c->effectWindow());
287​ const auto &animationsForWindow = state.first().first;
zzagUnsubmitted
Done

Please use concrete type here too.

zzag: Please use concrete type here too.
288​ QCOMPARE(animationsForWindow.count(), animationCount);
289​ QCOMPARE(animationsForWindow[0].duration, 100);
290​ QCOMPARE(animationsForWindow[0].to, FPx2(1.4));
291​ QCOMPARE(animationsForWindow[0].attribute, AnimationEffect::Scale);
292​ QCOMPARE(animationsForWindow[0].keepAtTarget, false);
293​ timePassed = animationsForWindow[0].time;
294​ if (animationCount == 2) {
295​ QCOMPARE(animationsForWindow[1].duration, 100);
296​ QCOMPARE(animationsForWindow[1].to, FPx2(0.0));
297​ QCOMPARE(animationsForWindow[1].attribute, AnimationEffect::Opacity);
298​ QCOMPARE(animationsForWindow[1].keepAtTarget, false);
299​ }
zzagUnsubmitted
Not Done

const auto state or even better const AniMap state.

zzag: `const auto state` or even better `const AniMap state`.
300​ }
301​ QCOMPARE(effectOutputSpy[0].first(), "true");
302​
303​ //window state changes, scale should be retargetted
broulikUnsubmitted
Not Done

This is flaky, fails every second time getting 201 instead of 200. (Javascript…)

broulik: This is flaky, fails every second time getting `201` instead of `200`. (Javascript…)
zzagUnsubmitted
Done

You don't take into account that compositeTimer can be triggered during testing. Probably, you should subtract time, e.g.

QCOMPARE(animationsForWindow[0].duration - animationsForWindow[0].time, 200);
zzag: You don't take into account that compositeTimer can be triggered during testing. Probably, you…
zzagUnsubmitted
Done

Still, not sure if it's right (to subtract time). retarget is a little bit interesting...

zzag: Still, not sure if it's right (to subtract time). retarget is a little bit interesting...
davidedmundsonAuthorUnsubmitted
Done

Whilst storing ints in doubles (which JS will do) can lead to loss, the first 2^53 values will always be correct. 200 shouldn't get corrupted anywhere.

Timer being the cause makes more sense, I'm running the event loop during renderAndWaitForShown and showing will be after the window is added.

In retarget: anim->duration = anim->time + newRemainingTime;

There's no event loop after we read the first values, so offsetting should be easy.

davidedmundson: Whilst storing ints in doubles (which JS will do) can lead to loss, the first 2^53 values will…
304​
305​ c->setMinimized(true);
306​ {
307​ const AnimationEffect::AniMap state = effect->state();
308​ QCOMPARE(state.count(), 1);
309​ const auto &animationsForWindow = state.first().first;
310​ QCOMPARE(animationsForWindow.count(), animationCount);
311​ QCOMPARE(animationsForWindow[0].duration, 200 + timePassed);
312​ QCOMPARE(animationsForWindow[0].to, FPx2(1.5));
313​ QCOMPARE(animationsForWindow[0].attribute, AnimationEffect::Scale);
314​ QCOMPARE(animationsForWindow[0].keepAtTarget, false);
315​ if (animationCount == 2) {
316​ QCOMPARE(animationsForWindow[1].duration, 200 + timePassed);
317​ QCOMPARE(animationsForWindow[1].to, FPx2(1.5));
318​ QCOMPARE(animationsForWindow[1].attribute, AnimationEffect::Opacity);
319​ QCOMPARE(animationsForWindow[1].keepAtTarget, false);
320​ }
321​ }
322​ c->setMinimized(false);
323​ {
324​ const AnimationEffect::AniMap state = effect->state();
325​ QCOMPARE(state.count(), 0);
326​ }
327​}
328​
329​void ScriptedEffectsTest::screenEdgeTest()
330​{
331​ auto *effect = new ScriptedEffectWithDebugSpy; //cleaned up in ::clean
332​ QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
333​ QVERIFY(effect->load("screenEdgeTest"));
334​ effect->borderActivated(KWin::ElectricTopRight);
335​ QCOMPARE(effectOutputSpy.count(), 1);
336​}
337​
338​void ScriptedEffectsTest::screenEdgeTouchTest()
339​{
340​ auto *effect = new ScriptedEffectWithDebugSpy; //cleaned up in ::clean
341​ QSignalSpy effectOutputSpy(effect, &ScriptedEffectWithDebugSpy::testOutput);
342​ QVERIFY(effect->load("screenEdgeTouchTest"));
343​ auto actions = effect->findChildren<QAction*>(QString(), Qt::FindDirectChildrenOnly);
344​ actions[0]->trigger();
345​ QCOMPARE(effectOutputSpy.count(), 1);
346​}
347​
348​WAYLANDTEST_MAIN(ScriptedEffectsTest)
349​#include "scripted_effects_test.moc"