← Back to branch summary

~mir-team/mir/dev-branch-staged

« back to all changes in this revision

Viewing changes to tests/unit-tests/scene/test_application_session.cpp

  • Committer: Kevin Gunn
  • Date: 2014-04-04 18:53:56 UTC
  • mfrom: (1441.8.86 development-branch)
  • Revision ID: kevin.gunn@canonical.com-20140404185356-v1nxxq8ccugibe0t
merged dev-branch latest r1536

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit-tests/scene/test_application_session.cpp
21
21
#include "mir/shell/surface_creation_parameters.h"
22
22
#include "mir/shell/null_session_listener.h"
23
23
#include "mir_test/fake_shared.h"
24
 
#include "mir_test_doubles/mock_surface_factory.h"
 
24
#include "mir_test_doubles/mock_surface_coordinator.h"
25
25
#include "mir_test_doubles/mock_surface.h"
26
26
#include "mir_test_doubles/mock_session_listener.h"
27
 
#include "mir_test_doubles/stub_surface_builder.h"
28
 
#include "mir_test_doubles/stub_surface_ranker.h"
29
27
#include "mir_test_doubles/stub_display_configuration.h"
30
28
#include "mir_test_doubles/null_snapshot_strategy.h"
31
29
#include "mir_test_doubles/null_event_sink.h"
32
30
 
33
 
#include "mir/shell/surface.h"
34
 
 
35
31
#include <gmock/gmock.h>
36
32
#include <gtest/gtest.h>
37
33
 
47
43
{
48
44
static std::shared_ptr<mtd::MockSurface> make_mock_surface()
49
45
{
50
 
    return std::make_shared<mtd::MockSurface>(std::make_shared<mtd::StubSurfaceBuilder>());
 
46
    return std::make_shared<mtd::MockSurface>();
51
47
}
52
48
 
53
49
class MockSnapshotStrategy : public ms::SnapshotStrategy
84
80
    auto mock_surface = make_mock_surface();
85
81
 
86
82
    mtd::NullEventSink sender;
87
 
    mtd::MockSurfaceFactory surface_factory;
 
83
    mtd::MockSurfaceCoordinator surface_coordinator;
88
84
 
89
 
    EXPECT_CALL(surface_factory, create_surface(_, _, _, _))
 
85
    EXPECT_CALL(surface_coordinator, add_surface(_, _, _))
90
86
        .WillOnce(Return(mock_surface));
91
87
 
92
88
    mtd::MockSessionListener listener;
96
92
        .Times(1);
97
93
 
98
94
    ms::ApplicationSession session(
99
 
        mt::fake_shared(surface_factory),
 
95
        mt::fake_shared(surface_coordinator),
100
96
        __LINE__,
101
97
        "Foo",
102
98
        std::make_shared<mtd::NullSnapshotStrategy>(),
116
112
    auto mock_surface = make_mock_surface();
117
113
 
118
114
    mtd::NullEventSink sender;
119
 
    mtd::MockSurfaceFactory surface_factory;
120
 
    ON_CALL(surface_factory, create_surface(_,_,_,_)).WillByDefault(Return(mock_surface));
 
115
    mtd::MockSurfaceCoordinator surface_coordinator;
 
116
    ON_CALL(surface_coordinator, add_surface(_,_,_)).WillByDefault(Return(mock_surface));
121
117
 
122
 
    EXPECT_CALL(surface_factory, create_surface(_, _, _, _));
 
118
    EXPECT_CALL(surface_coordinator, add_surface(_, _, _));
123
119
 
124
120
    mtd::MockSessionListener listener;
125
121
    EXPECT_CALL(listener, surface_created(_, _)).Times(1);
127
123
 
128
124
    {
129
125
        ms::ApplicationSession session(
130
 
            mt::fake_shared(surface_factory),
 
126
            mt::fake_shared(surface_coordinator),
131
127
            __LINE__,
132
128
            "Foo",
133
129
            std::make_shared<mtd::NullSnapshotStrategy>(),
144
140
    using namespace ::testing;
145
141
 
146
142
    mtd::NullEventSink sender;
147
 
    mtd::MockSurfaceFactory surface_factory;
 
143
    mtd::MockSurfaceCoordinator surface_coordinator;
148
144
 
149
145
    {
150
146
        InSequence seq;
151
 
        EXPECT_CALL(surface_factory, create_surface(_, _, _, _)).Times(1)
152
 
            .WillOnce(Return(make_mock_surface()));
153
 
        EXPECT_CALL(surface_factory, create_surface(_, _, _, _)).Times(1)
154
 
            .WillOnce(Return(make_mock_surface()));
155
 
        EXPECT_CALL(surface_factory, create_surface(_, _, _, _)).Times(1)
 
147
        EXPECT_CALL(surface_coordinator, add_surface(_, _, _)).Times(1)
 
148
            .WillOnce(Return(make_mock_surface()));
 
149
        EXPECT_CALL(surface_coordinator, add_surface(_, _, _)).Times(1)
 
150
            .WillOnce(Return(make_mock_surface()));
 
151
        EXPECT_CALL(surface_coordinator, add_surface(_, _, _)).Times(1)
156
152
            .WillOnce(Return(make_mock_surface()));
157
153
    }
158
154
 
159
155
    ms::ApplicationSession app_session(
160
 
        mt::fake_shared(surface_factory),
 
156
        mt::fake_shared(surface_coordinator),
161
157
        __LINE__,
162
158
        "Foo",
163
159
        std::make_shared<mtd::NullSnapshotStrategy>(),
190
186
    mtd::NullEventSink sender;
191
187
    auto mock_surface = make_mock_surface();
192
188
 
193
 
    mtd::MockSurfaceFactory surface_factory;
194
 
    ON_CALL(surface_factory, create_surface(_, _, _, _)).WillByDefault(Return(mock_surface));
 
189
    mtd::MockSurfaceCoordinator surface_coordinator;
 
190
    ON_CALL(surface_coordinator, add_surface(_, _, _)).WillByDefault(Return(mock_surface));
195
191
 
196
192
    ms::ApplicationSession app_session(
197
 
        mt::fake_shared(surface_factory),
 
193
        mt::fake_shared(surface_coordinator),
198
194
        __LINE__,
199
195
        "Foo",
200
196
        std::make_shared<mtd::NullSnapshotStrategy>(),
201
197
        std::make_shared<msh::NullSessionListener>(),
202
198
        mt::fake_shared(sender));
203
199
 
204
 
    EXPECT_CALL(surface_factory, create_surface(_, _, _, _));
 
200
    EXPECT_CALL(surface_coordinator, add_surface(_, _, _));
205
201
 
206
202
    {
207
203
        InSequence seq;
223
219
    using namespace ::testing;
224
220
 
225
221
    mtd::NullEventSink sender;
226
 
    mtd::MockSurfaceFactory surface_factory;
 
222
    mtd::MockSurfaceCoordinator surface_coordinator;
227
223
    ms::ApplicationSession app_session(
228
 
        mt::fake_shared(surface_factory),
 
224
        mt::fake_shared(surface_coordinator),
229
225
        __LINE__,
230
226
        "Foo",
231
227
        std::make_shared<mtd::NullSnapshotStrategy>(),
244
240
    using namespace ::testing;
245
241
 
246
242
    mtd::NullEventSink sender;
247
 
    mtd::MockSurfaceFactory surface_factory;
 
243
    mtd::MockSurfaceCoordinator surface_coordinator;
248
244
    ms::ApplicationSession app_session(
249
 
        mt::fake_shared(surface_factory),
 
245
        mt::fake_shared(surface_coordinator),
250
246
        __LINE__,
251
247
        "Foo",
252
248
        std::make_shared<mtd::NullSnapshotStrategy>(),
264
260
{
265
261
    using namespace ::testing;
266
262
 
267
 
    mtd::MockSurfaceFactory surface_factory;
 
263
    mtd::MockSurfaceCoordinator surface_coordinator;
268
264
    mtd::NullEventSink sender;
269
265
    auto const default_surface = make_mock_surface();
270
266
    auto const default_surface_buffer_access =
271
267
        std::static_pointer_cast<msh::SurfaceBufferAccess>(default_surface);
272
268
    auto const snapshot_strategy = std::make_shared<MockSnapshotStrategy>();
273
269
 
274
 
    EXPECT_CALL(surface_factory, create_surface(_,_,_,_))
 
270
    EXPECT_CALL(surface_coordinator, add_surface(_,_,_))
275
271
        .WillOnce(Return(default_surface));
276
272
 
277
273
    EXPECT_CALL(*snapshot_strategy,
278
274
                take_snapshot_of(default_surface_buffer_access, _));
279
275
 
280
276
    ms::ApplicationSession app_session(
281
 
        mt::fake_shared(surface_factory),
 
277
        mt::fake_shared(surface_coordinator),
282
278
        __LINE__,
283
279
        "Foo",
284
280
        snapshot_strategy,
295
291
    using namespace ::testing;
296
292
 
297
293
    mtd::NullEventSink sender;
298
 
    mtd::MockSurfaceFactory surface_factory;
 
294
    mtd::MockSurfaceCoordinator surface_coordinator;
299
295
    auto snapshot_strategy = std::make_shared<MockSnapshotStrategy>();
300
296
    MockSnapshotCallback mock_snapshot_callback;
301
297
 
302
298
    ms::ApplicationSession app_session(
303
 
        mt::fake_shared(surface_factory),
 
299
        mt::fake_shared(surface_coordinator),
304
300
        __LINE__,
305
301
        "Foo",
306
302
        snapshot_strategy,
328
324
    using namespace ::testing;
329
325
 
330
326
    mtd::StubDisplayConfig stub_config;
331
 
    mtd::MockSurfaceFactory surface_factory;
 
327
    mtd::MockSurfaceCoordinator surface_coordinator;
332
328
    MockEventSink sender;
333
329
 
334
330
    EXPECT_CALL(sender, handle_display_config_change(testing::Ref(stub_config)))
335
331
        .Times(1);
336
332
 
337
333
    ms::ApplicationSession app_session(
338
 
        mt::fake_shared(surface_factory),
 
334
        mt::fake_shared(surface_coordinator),
339
335
        __LINE__,
340
336
        "Foo",
341
337
        std::make_shared<mtd::NullSnapshotStrategy>(),
350
346
    using namespace ::testing;
351
347
 
352
348
    MirLifecycleState exp_state = mir_lifecycle_state_will_suspend;
353
 
    mtd::MockSurfaceFactory surface_factory;
 
349
    mtd::MockSurfaceCoordinator surface_coordinator;
354
350
    MockEventSink sender;
355
351
 
356
352
    ms::ApplicationSession app_session(
357
 
        mt::fake_shared(surface_factory),
 
353
        mt::fake_shared(surface_coordinator),
358
354
        __LINE__,
359
355
        "Foo",
360
356
        std::make_shared<mtd::NullSnapshotStrategy>(),
372
368
 
373
369
    pid_t const pid{__LINE__};
374
370
 
375
 
    mtd::MockSurfaceFactory surface_factory;
 
371
    mtd::MockSurfaceCoordinator surface_coordinator;
376
372
    MockEventSink sender;
377
373
 
378
374
    ms::ApplicationSession app_session(
379
 
        mt::fake_shared(surface_factory),
 
375
        mt::fake_shared(surface_coordinator),
380
376
        pid,
381
377
        "Foo",
382
378
        std::make_shared<mtd::NullSnapshotStrategy>(),