← Back to branch summary

~allanlesage/unity8/dash-apps-visible-ordering

« back to all changes in this revision

Viewing changes to tests/qmltests/Dash/Apps/tst_RunningApplicationsGrid.qml

  • Committer: Allan LeSage
  • Date: 2014-04-02 17:57:38 UTC
  • mfrom: (784.1.25 unity8)
  • Revision ID: allan.lesage@canonical.com-20140402175738-ocei683rve0pj7wz
Merged trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/qmltests/Dash/Apps/tst_RunningApplicationsGrid.qml
18
18
import QtTest 1.0
19
19
import "../../../../qml/Dash/Apps"
20
20
import Unity.Test 0.1 as UT
 
21
import Unity.Application 0.1
21
22
 
22
 
Item {
 
23
// Using Rectangle to have an opaque surface because AppManager paints app surfaces behind it.
 
24
Rectangle {
23
25
    width: units.gu(50)
24
26
    height: units.gu(40)
25
27
 
26
 
    QtObject {
27
 
        id: fakeApplicationManager
28
 
 
29
 
        property bool sideStageEnabled: false
30
 
 
31
 
        function stopApplication(appId) {
32
 
            for (var i=0, len=fakeRunningAppsModel.count; i<len; i++) {
33
 
                if (appId == fakeRunningAppsModel.get(i).appId) {
34
 
                    fakeRunningAppsModel.remove(i)
35
 
                }
36
 
            }
37
 
        }
38
 
    }
39
 
 
40
 
    QtObject {
41
 
        id: shell
42
 
        property bool dashShown: true
43
 
        property bool stageScreenshotsReady: false
44
 
        property var applicationManager: fakeApplicationManager
45
 
 
46
 
        function activateApplication(appId) {
47
 
        }
48
 
    }
49
 
 
50
 
    ListModel {
51
 
        id: fakeRunningAppsModel
52
 
 
53
 
        function contains(appId) {
54
 
            for (var i=0, len=fakeRunningAppsModel.count; i<len; i++) {
55
 
                if (appId == fakeRunningAppsModel.get(i).appId) {
56
 
                    return true;
57
 
                }
58
 
            }
59
 
            return false;
60
 
        }
61
 
 
62
 
        function rePopulate() {
63
 
            for (var i=0, len=availableAppsModel.count; i<len; i++) {
64
 
                fakeRunningAppsModel.append(availableAppsModel.get(i));
65
 
            }
66
 
        }
67
 
    }
68
 
 
69
 
    ListModel {
70
 
        id: availableAppsModel
71
 
        ListElement {
72
 
            name: "Phone"
73
 
            icon: "phone-app"
74
 
            exec: "/usr/bin/phone-app"
75
 
            appId: "phone"
76
 
            imageQml: "import QtQuick 2.0\n \
77
 
                       Rectangle { \n \
78
 
                          anchors.fill:parent \n \
79
 
                          color:'darkgreen' \n \
80
 
                          Text { anchors.centerIn: parent; text: 'PHONE' } \n \
81
 
                      }"
82
 
        }
83
 
 
84
 
        ListElement {
85
 
            name: "Calendar"
86
 
            icon: "calendar-app"
87
 
            exec: "/usr/bin/calendar-app"
88
 
            appId: "calendar"
89
 
            imageQml: "import QtQuick 2.0\n \
90
 
                       Rectangle { \n \
91
 
                           anchors.fill:parent \n \
92
 
                           color:'darkblue' \n \
93
 
                           Text { anchors.centerIn: parent; text: 'CALENDAR'\n \
94
 
                                  color:'white'} \n \
95
 
                      }"
96
 
        }
97
 
    }
98
 
 
99
28
    function resetRunningApplications() {
100
 
        fakeRunningAppsModel.clear()
101
 
        fakeRunningAppsModel.rePopulate()
 
29
        while (ApplicationManager.count > 0) {
 
30
            ApplicationManager.stopApplication(ApplicationManager.get(0).appId)
 
31
        }
 
32
 
 
33
        ApplicationManager.startApplication("phone-app");
 
34
        ApplicationManager.startApplication("webbrowser-app");
102
35
    }
103
36
 
104
37
    Component.onCompleted: {
109
42
    RunningApplicationsGrid {
110
43
        id: runningApplicationsGrid
111
44
        anchors.fill: parent
112
 
        firstModel: fakeRunningAppsModel
 
45
        model: ApplicationManager
113
46
    }
114
47
 
115
48
    UT.UnityTestCase {
121
54
            resetRunningApplications()
122
55
        }
123
56
 
124
 
        property var calendarTile
 
57
        property var browserTile
125
58
        property var phoneTile
126
59
 
127
 
        property var isCalendarLongPressed: false
128
 
        function onCalendarLongPressed() {isCalendarLongPressed = true}
 
60
        property var isBrowserLongPressed: false
 
61
        function onBrowserLongPressed() {isBrowserLongPressed = true}
129
62
 
130
63
        property var isPhoneLongPressed: false
131
64
        function onPhoneLongPressed() {isPhoneLongPressed = true}
133
66
        // Tiles should go to termination mode when any one of them is long-pressed.
134
67
        // Long-pressing when they're in termination mode brings them back to activation mode
135
68
        function test_enterTerminationMode() {
136
 
            calendarTile = findChild(runningApplicationsGrid, "runningAppTile Calendar")
137
 
            verify(calendarTile != undefined)
138
 
            calendarTile.onPressAndHold.connect(onCalendarLongPressed)
 
69
            browserTile = findChild(runningApplicationsGrid, "runningAppTile Browser")
 
70
            verify(browserTile != undefined)
 
71
            browserTile.onPressAndHold.connect(onBrowserLongPressed)
139
72
 
140
73
            phoneTile = findChild(runningApplicationsGrid, "runningAppTile Phone")
141
74
            verify(phoneTile != undefined)
142
75
            phoneTile.onPressAndHold.connect(onPhoneLongPressed)
143
76
 
144
 
            compare(calendarTile.terminationModeEnabled, false)
 
77
            compare(browserTile.terminationModeEnabled, false)
145
78
            compare(phoneTile.terminationModeEnabled, false)
146
79
            compare(runningApplicationsGrid.terminationModeEnabled, false)
147
80
 
148
 
            isCalendarLongPressed = false
149
 
            mousePress(calendarTile, calendarTile.width/2, calendarTile.height/2)
 
81
            isBrowserLongPressed = false
 
82
            mousePress(browserTile, browserTile.width/2, browserTile.height/2)
150
83
            tryCompareFunction(checkSwitchToTerminationModeAfterLongPress, true)
151
84
 
152
 
            mouseRelease(calendarTile, calendarTile.width/2, calendarTile.height/2)
 
85
            mouseRelease(browserTile, browserTile.width/2, browserTile.height/2)
153
86
 
154
 
            compare(calendarTile.terminationModeEnabled, true)
 
87
            compare(browserTile.terminationModeEnabled, true)
155
88
            compare(phoneTile.terminationModeEnabled, true)
156
89
            compare(runningApplicationsGrid.terminationModeEnabled, true)
157
90
 
161
94
 
162
95
            mouseRelease(phoneTile, phoneTile.width/2, phoneTile.height/2)
163
96
 
164
 
            compare(calendarTile.terminationModeEnabled, false)
 
97
            compare(browserTile.terminationModeEnabled, false)
165
98
            compare(phoneTile.terminationModeEnabled, false)
166
99
            compare(runningApplicationsGrid.terminationModeEnabled, false)
167
100
 
168
 
            calendarTile.onPressAndHold.disconnect(onCalendarLongPressed)
 
101
            browserTile.onPressAndHold.disconnect(onBrowserLongPressed)
169
102
            phoneTile.onPressAndHold.disconnect(onPhoneLongPressed)
170
103
        }
171
104
 
172
105
        // Checks that components swicth to termination mode after (and only after) a long
173
 
        // press happens on Calendar tile.
 
106
        // press happens on Browser tile.
174
107
        function checkSwitchToTerminationModeAfterLongPress() {
175
 
            compare(calendarTile.terminationModeEnabled, isCalendarLongPressed)
176
 
            compare(phoneTile.terminationModeEnabled, isCalendarLongPressed)
177
 
            compare(runningApplicationsGrid.terminationModeEnabled, isCalendarLongPressed)
 
108
            compare(browserTile.terminationModeEnabled, isBrowserLongPressed)
 
109
            compare(phoneTile.terminationModeEnabled, isBrowserLongPressed)
 
110
            compare(runningApplicationsGrid.terminationModeEnabled, isBrowserLongPressed)
178
111
 
179
 
            return isCalendarLongPressed &&
180
 
                calendarTile.terminationModeEnabled &&
 
112
            return isBrowserLongPressed &&
 
113
                browserTile.terminationModeEnabled &&
181
114
                phoneTile.terminationModeEnabled &&
182
115
                runningApplicationsGrid.terminationModeEnabled
183
116
        }
185
118
        // Checks that components swicth to activation mode after (and only after) a long
186
119
        // press happens on Phone tile.
187
120
        function checkSwitchToActivationModeAfterLongPress() {
188
 
            compare(calendarTile.terminationModeEnabled, !isPhoneLongPressed)
 
121
            compare(browserTile.terminationModeEnabled, !isPhoneLongPressed)
189
122
            compare(phoneTile.terminationModeEnabled, !isPhoneLongPressed)
190
123
            compare(runningApplicationsGrid.terminationModeEnabled, !isPhoneLongPressed)
191
124
 
192
125
            return isPhoneLongPressed &&
193
 
                !calendarTile.terminationModeEnabled &&
 
126
                !browserTile.terminationModeEnabled &&
194
127
                !phoneTile.terminationModeEnabled &&
195
128
                !runningApplicationsGrid.terminationModeEnabled
196
129
        }
200
133
        function test_clickTileNotClose() {
201
134
            runningApplicationsGrid.terminationModeEnabled = true
202
135
 
203
 
            var calendarTile = findChild(runningApplicationsGrid, "runningAppTile Calendar")
204
 
            verify(calendarTile != undefined)
205
 
 
206
 
            verify(fakeRunningAppsModel.contains("calendar"))
207
 
 
208
 
            mouseClick(calendarTile, calendarTile.width/2, calendarTile.height/2)
209
 
 
210
 
            verify(fakeRunningAppsModel.contains("calendar"))
211
 
 
212
 
            // The tile for the Calendar app should stay there
213
 
            tryCompareFunction(checkCalendarTileExists, true)
 
136
            var browserTile = findChild(runningApplicationsGrid, "runningAppTile Browser")
 
137
            verify(browserTile != undefined)
 
138
 
 
139
            verify(ApplicationManager.findApplication("webbrowser-app") !== null)
 
140
 
 
141
            mouseClick(browserTile, browserTile.width/2, browserTile.height/2)
 
142
 
 
143
            verify(ApplicationManager.findApplication("webbrowser-app") !== null)
 
144
 
 
145
            // The tile for the Browser app should stay there
 
146
            tryCompareFunction(checkBrowserTileExists, true)
214
147
        }
215
148
 
216
149
        // While in termination mode, clicking on a running application tile's close icon
218
151
        function test_clickCloseIconToTerminateApp() {
219
152
            runningApplicationsGrid.terminationModeEnabled = true
220
153
 
221
 
            var calendarTile = findChild(runningApplicationsGrid, "runningAppTile Calendar")
222
 
            var calendarTileCloseButton = findChild(runningApplicationsGrid, "closeIcon Calendar")
223
 
 
224
 
            verify(calendarTile != undefined)
225
 
            verify(calendarTileCloseButton != undefined)
226
 
            verify(fakeRunningAppsModel.contains("calendar"))
227
 
 
228
 
            mouseClick(calendarTileCloseButton, calendarTileCloseButton.width/2, calendarTileCloseButton.height/2)
 
154
            var browserTile = findChild(runningApplicationsGrid, "runningAppTile Browser")
 
155
            var browserTileCloseButton = findChild(runningApplicationsGrid, "closeIcon Browser")
 
156
 
 
157
            verify(browserTile != undefined)
 
158
            verify(browserTileCloseButton != undefined)
 
159
            verify(ApplicationManager.findApplication("webbrowser-app") !== 0)
 
160
 
 
161
            mouseClick(browserTileCloseButton, browserTileCloseButton.width/2, browserTileCloseButton.height/2)
229
162
            wait(0) // spin event loop to start any pending animation
230
163
 
231
 
            verify(!fakeRunningAppsModel.contains("calendar"))
 
164
            verify(ApplicationManager.findApplication("webbrowser-app") === null)
232
165
 
233
 
            // The tile for the Calendar app should eventually vanish since the
 
166
            // The tile for the Browser app should eventually vanish since the
234
167
            // application has been terminated.
235
 
            tryCompareFunction(checkCalendarTileExists, false)
 
168
            tryCompareFunction(checkBrowserTileExists, false)
236
169
        }
237
170
 
238
 
        function checkCalendarTileExists() {
239
 
            return findChild(runningApplicationsGrid, "runningAppTile Calendar")
 
171
        function checkBrowserTileExists() {
 
172
            return findChild(runningApplicationsGrid, "runningAppTile Browser")
240
173
                    != undefined
241
174
        }
242
175
 
245
178
        function test_clickOutsideTilesDisablesTerminationMode() {
246
179
            runningApplicationsGrid.terminationModeEnabled = true
247
180
 
248
 
            var calendarTile = findChild(runningApplicationsGrid, "runningAppTile Calendar")
249
 
            verify(calendarTile != undefined)
 
181
            var browserTile = findChild(runningApplicationsGrid, "runningAppTile Browser")
 
182
            verify(browserTile != undefined)
250
183
 
251
184
            verify(runningApplicationsGrid.terminationModeEnabled);
252
185