~ubuntu-branches/ubuntu/utopic/mir/utopic-proposed

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Ubuntu daily release
  • Date: 2014-03-10 19:28:46 UTC
  • mto: This revision was merged to the branch mainline in revision 63.
  • Revision ID: package-import@ubuntu.com-20140310192846-rq9qm3ec26yrelo2
Tags: upstream-0.1.6+14.04.20140310
Import upstream version 0.1.6+14.04.20140310

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
/*
2
 
 * Copyright © 2012 Canonical Ltd.
 
2
 * Copyright © 2012-2014 Canonical Ltd.
3
3
 *
4
4
 * This program is free software: you can redistribute it and/or modify
5
5
 * it under the terms of the GNU General Public License version 3 as
16
16
 * Authored by: Thomas Voss <thomas.voss@canonical.com>
17
17
 */
18
18
 
19
 
#include "src/server/scene/surface_data.h"
20
19
#include "src/server/scene/surface_stack.h"
21
20
#include "src/server/scene/basic_surface_factory.h"
22
21
#include "src/server/compositor/buffer_stream_surfaces.h"
27
26
#include "mir/geometry/rectangle.h"
28
27
#include "mir/shell/surface_creation_parameters.h"
29
28
#include "src/server/compositor/renderer.h"
30
 
#include "mir/scene/scene_report.h"
 
29
#include "src/server/report/null_report_factory.h"
31
30
#include "mir/compositor/compositing_criteria.h"
32
31
#include "src/server/scene/basic_surface.h"
33
32
#include "mir/input/input_channel_factory.h"
34
33
#include "mir/input/input_channel.h"
35
 
#include "mir_test_doubles/mock_surface_renderer.h"
36
34
#include "mir_test_doubles/mock_buffer_stream.h"
37
35
#include "mir_test_doubles/stub_input_registrar.h"
38
36
#include "mir_test_doubles/stub_input_channel.h"
60
58
namespace geom = mir::geometry;
61
59
namespace mt = mir::test;
62
60
namespace mtd = mir::test::doubles;
 
61
namespace mr = mir::report;
63
62
 
64
63
namespace
65
64
{
174
173
        using namespace testing;
175
174
        default_params = msh::a_surface().of_size(geom::Size{geom::Width{1024}, geom::Height{768}});
176
175
 
177
 
        auto stub_data = std::make_shared<ms::SurfaceData>( 
178
 
            std::string("stub"), geom::Rectangle{{},{}}, [](){}, false);
179
 
        stub_surface1 = std::make_shared<ms::BasicSurface>(stub_data, std::make_shared<mtd::StubBufferStream>(), std::shared_ptr<mir::input::InputChannel>(), report);
180
 
        stub_surface2 = std::make_shared<ms::BasicSurface>(stub_data, std::make_shared<mtd::StubBufferStream>(), std::shared_ptr<mir::input::InputChannel>(), report);
181
 
        stub_surface3 = std::make_shared<ms::BasicSurface>(stub_data, std::make_shared<mtd::StubBufferStream>(), std::shared_ptr<mir::input::InputChannel>(), report);
 
176
        stub_surface1 = std::make_shared<ms::BasicSurface>(
 
177
            std::string("stub"),
 
178
            geom::Rectangle{{},{}},
 
179
            [](){},
 
180
            false,
 
181
            std::make_shared<mtd::StubBufferStream>(),
 
182
            std::shared_ptr<mir::input::InputChannel>(),
 
183
            report);
 
184
 
 
185
        stub_surface2 = std::make_shared<ms::BasicSurface>(
 
186
            std::string("stub"),
 
187
            geom::Rectangle{{},{}},
 
188
            [](){},
 
189
            false,
 
190
            std::make_shared<mtd::StubBufferStream>(),
 
191
            std::shared_ptr<mir::input::InputChannel>(),
 
192
            report);
 
193
 
 
194
        stub_surface3 = std::make_shared<ms::BasicSurface>(
 
195
            std::string("stub"),
 
196
            geom::Rectangle{{},{}},
 
197
            [](){},
 
198
            false,
 
199
            std::make_shared<mtd::StubBufferStream>(),
 
200
            std::shared_ptr<mir::input::InputChannel>(),
 
201
            report);
182
202
 
183
203
        ON_CALL(mock_surface_allocator, create_surface(_,_))
184
204
            .WillByDefault(Return(stub_surface1));
191
211
    std::shared_ptr<ms::BasicSurface> stub_surface2;
192
212
    std::shared_ptr<ms::BasicSurface> stub_surface3;
193
213
 
194
 
    std::shared_ptr<ms::SceneReport> const report = std::make_shared<ms::NullSceneReport>();
 
214
    std::shared_ptr<ms::SceneReport> const report = mr::null_scene_report();
195
215
};
196
216
 
197
217
}
237
257
        report);
238
258
 
239
259
    auto s1 = stack.create_surface(default_params);
240
 
    auto criteria1 = s1.lock()->compositing_criteria();
 
260
    auto criteria1 = s1.lock();
241
261
    auto stream1 = s1.lock()->buffer_stream();
242
262
    auto s2 = stack.create_surface(default_params);
243
 
    auto criteria2 = s2.lock()->compositing_criteria();
 
263
    auto criteria2 = s2.lock();
244
264
    auto stream2 = s2.lock()->buffer_stream();
245
265
    auto s3 = stack.create_surface(default_params);
246
 
    auto criteria3 = s3.lock()->compositing_criteria();
 
266
    auto criteria3 = s3.lock();
247
267
    auto stream3 = s3.lock()->buffer_stream();
248
268
 
249
269
    MockFilterForScene filter;
282
302
        report);
283
303
 
284
304
    auto s1 = stack.create_surface(default_params);
285
 
    auto criteria1 = s1.lock()->compositing_criteria();
 
305
    auto criteria1 = s1.lock();
286
306
    auto stream1 = s1.lock()->buffer_stream();
287
307
    auto s2 = stack.create_surface(default_params);
288
 
    auto criteria2 = s2.lock()->compositing_criteria();
 
308
    auto criteria2 = s2.lock();
289
309
    auto stream2 = s2.lock()->buffer_stream();
290
310
    auto s3 = stack.create_surface(default_params);
291
 
    auto criteria3 = s3.lock()->compositing_criteria();
 
311
    auto criteria3 = s3.lock();
292
312
    auto stream3 = s3.lock()->buffer_stream();
293
313
 
294
314
    MockFilterForScene filter;
329
349
        report);
330
350
 
331
351
    auto s1 = stack.create_surface(default_params);
332
 
    auto criteria1 = s1.lock()->compositing_criteria();
 
352
    auto criteria1 = s1.lock();
333
353
    auto stream1 = s1.lock()->buffer_stream();
334
354
    auto s2 = stack.create_surface(default_params);
335
 
    auto criteria2 = s2.lock()->compositing_criteria();
 
355
    auto criteria2 = s2.lock();
336
356
    auto stream2 = s2.lock()->buffer_stream();
337
357
    auto s3 = stack.create_surface(default_params);
338
 
    auto criteria3 = s3.lock()->compositing_criteria();
 
358
    auto criteria3 = s3.lock();
339
359
    auto stream3 = s3.lock()->buffer_stream();
340
360
 
341
361
    StubFilterForScene filter;
369
389
        report);
370
390
 
371
391
    auto s1 = stack.create_surface(default_params);
372
 
    auto criteria1 = s1.lock()->compositing_criteria();
 
392
    auto criteria1 = s1.lock();
373
393
    auto stream1 = s1.lock()->buffer_stream();
374
394
    auto s2 = stack.create_surface(default_params);
375
 
    auto criteria2 = s2.lock()->compositing_criteria();
 
395
    auto criteria2 = s2.lock();
376
396
    auto stream2 = s2.lock()->buffer_stream();
377
397
    auto s3 = stack.create_surface(default_params);
378
 
    auto criteria3 = s3.lock()->compositing_criteria();
 
398
    auto criteria3 = s3.lock();
379
399
    auto stream3 = s3.lock()->buffer_stream();
380
400
 
381
401
    StubFilterForScene filter;
423
443
        report);
424
444
 
425
445
    auto s1 = stack.create_surface(default_params.of_depth(ms::DepthId{0}));
426
 
    auto criteria1 = s1.lock()->compositing_criteria();
 
446
    auto criteria1 = s1.lock();
427
447
    auto stream1 = s1.lock()->buffer_stream();
428
448
    auto s2 = stack.create_surface(default_params.of_depth(ms::DepthId{1}));
429
 
    auto criteria2 = s2.lock()->compositing_criteria();
 
449
    auto criteria2 = s2.lock();
430
450
    auto stream2 = s2.lock()->buffer_stream();
431
451
    auto s3 = stack.create_surface(default_params.of_depth(ms::DepthId{0}));
432
 
    auto criteria3 = s3.lock()->compositing_criteria();
 
452
    auto criteria3 = s3.lock();
433
453
    auto stream3 = s3.lock()->buffer_stream();
434
454
 
435
455
    StubFilterForScene filter;
502
522
        report);
503
523
 
504
524
    auto s1 = stack.create_surface(default_params);
505
 
    auto criteria1 = s1.lock()->compositing_criteria();
 
525
    auto criteria1 = s1.lock();
506
526
    auto stream1 = s1.lock()->buffer_stream();
507
527
    auto s2 = stack.create_surface(default_params);
508
 
    auto criteria2 = s2.lock()->compositing_criteria();
 
528
    auto criteria2 = s2.lock();
509
529
    auto stream2 = s2.lock()->buffer_stream();
510
530
    auto s3 = stack.create_surface(default_params);
511
 
    auto criteria3 = s3.lock()->compositing_criteria();
 
531
    auto criteria3 = s3.lock();
512
532
    auto stream3 = s3.lock()->buffer_stream();
513
533
 
514
534
    StubFilterForScene filter;
549
569
        report);
550
570
 
551
571
    auto s1 = stack.create_surface(default_params.of_depth(ms::DepthId{0}));
552
 
    auto criteria1 = s1.lock()->compositing_criteria();
 
572
    auto criteria1 = s1.lock();
553
573
    auto stream1 = s1.lock()->buffer_stream();
554
574
    auto s2 = stack.create_surface(default_params.of_depth(ms::DepthId{0}));
555
 
    auto criteria2 = s2.lock()->compositing_criteria();
 
575
    auto criteria2 = s2.lock();
556
576
    auto stream2 = s2.lock()->buffer_stream();
557
577
    auto s3 = stack.create_surface(default_params.of_depth(ms::DepthId{1}));
558
 
    auto criteria3 = s3.lock()->compositing_criteria();
 
578
    auto criteria3 = s3.lock();
559
579
    auto stream3 = s3.lock()->buffer_stream();
560
580
 
561
581
    StubFilterForScene filter;
645
665
        report);
646
666
 
647
667
    auto s1 = stack.create_surface(default_params);
648
 
    auto criteria1 = s1.lock()->compositing_criteria();
 
668
    auto criteria1 = s1.lock();
649
669
    auto stream1 = s1.lock()->buffer_stream();
650
670
    auto s2 = stack.create_surface(default_params);
651
 
    auto criteria2 = s2.lock()->compositing_criteria();
 
671
    auto criteria2 = s2.lock();
652
672
    auto stream2 = s2.lock()->buffer_stream();
653
673
    auto s3 = stack.create_surface(default_params);
654
 
    auto criteria3 = s3.lock()->compositing_criteria();
 
674
    auto criteria3 = s3.lock();
655
675
    auto stream3 = s3.lock()->buffer_stream();
656
676
 
657
677
    MockFilterForScene filter;