← Back to branch summary

~kdub/mir/fix-1301040

« back to all changes in this revision

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

  • Committer: Tarmac
  • Author(s): Alan Griffiths
  • Date: 2014-04-01 17:40:49 UTC
  • mfrom: (1513.3.10 mir1)
  • Revision ID: tarmac-20140401174049-vj1jmakptw9v31qg
scene: Simplify BasicSurface creation by separating out an initial cut of SurfaceObserver.

Approved by Andreas Pokorny, Alexandros Frantzis, Gerry Boland, PS Jenkins bot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit-tests/scene/test_surface.cpp
21
21
#include "mir/frontend/event_sink.h"
22
22
#include "mir/shell/surface_creation_parameters.h"
23
23
#include "mir/scene/surface_configurator.h"
 
24
#include "mir/scene/surface_event_source.h"
24
25
#include "mir/input/input_channel.h"
25
26
 
26
27
#include "mir_test_doubles/mock_buffer_stream.h"
209
210
    std::function<void()> change_notification;
210
211
    int notification_count;
211
212
    mtd::StubBuffer stub_buffer;
212
 
    std::shared_ptr<StubEventSink> const stub_event_sink = std::make_shared<StubEventSink>();
213
213
    std::shared_ptr<StubSurfaceConfigurator> const stub_configurator = std::make_shared<StubSurfaceConfigurator>();
214
214
};
215
215
 
219
219
{
220
220
    using namespace testing;
221
221
    ms::BasicSurface surf(
222
 
        mf::SurfaceId(),
223
222
        surface_name,
224
223
        rect,
225
224
        false,
226
225
        mock_buffer_stream,
227
226
        std::shared_ptr<mi::InputChannel>(),
228
 
        stub_event_sink,
229
227
        stub_configurator,
230
228
        report);
231
229
 
241
239
TEST_F(SurfaceCreation, test_surface_gets_right_name)
242
240
{
243
241
    ms::BasicSurface surf(
244
 
        mf::SurfaceId(),
245
242
        surface_name,
246
243
        rect,
247
244
        false,
248
245
        mock_buffer_stream,
249
246
        std::shared_ptr<mi::InputChannel>(),
250
 
        stub_event_sink,
251
247
        stub_configurator,
252
248
        report);
253
249
 
257
253
TEST_F(SurfaceCreation, test_surface_queries_state_for_size)
258
254
{
259
255
    ms::BasicSurface surf(
260
 
        mf::SurfaceId(),
261
256
        surface_name,
262
257
        rect,
263
258
        false,
264
259
        mock_buffer_stream,
265
260
        std::shared_ptr<mi::InputChannel>(),
266
 
        stub_event_sink,
267
261
        stub_configurator,
268
262
        report);
269
263
 
274
268
{
275
269
    using namespace testing;
276
270
    ms::BasicSurface surf(
277
 
        mf::SurfaceId(),
278
271
        surface_name,
279
272
        rect,
280
273
        false,
281
274
        mock_buffer_stream,
282
275
        std::shared_ptr<mi::InputChannel>(),
283
 
        stub_event_sink,
284
276
        stub_configurator,
285
277
        report);
286
278
 
302
294
    mtd::StubBuffer stub_buffer;
303
295
 
304
296
    ms::BasicSurface surf(
305
 
        mf::SurfaceId(),
306
297
        surface_name,
307
298
        rect,
308
299
        false,
309
300
        mock_buffer_stream,
310
301
        std::shared_ptr<mi::InputChannel>(),
311
 
        stub_event_sink,
312
302
        stub_configurator,
313
303
        report);
314
304
 
324
314
TEST_F(SurfaceCreation, test_surface_gets_top_left)
325
315
{
326
316
    ms::BasicSurface surf(
327
 
        mf::SurfaceId(),
328
317
        surface_name,
329
318
        rect,
330
319
        false,
331
320
        mock_buffer_stream,
332
321
        std::shared_ptr<mi::InputChannel>(),
333
 
        stub_event_sink,
334
322
        stub_configurator,
335
323
        report);
336
324
 
343
331
    geom::Point p{55, 66};
344
332
 
345
333
    ms::BasicSurface surf(
346
 
        mf::SurfaceId(),
347
334
        surface_name,
348
335
        rect,
349
336
        false,
350
337
        mock_buffer_stream,
351
338
        std::shared_ptr<mi::InputChannel>(),
352
 
        stub_event_sink,
353
339
        stub_configurator,
354
340
        report);
355
341
 
366
352
        .Times(1);
367
353
 
368
354
    auto const mock_event_sink = std::make_shared<MockEventSink>();
 
355
    auto const observer = std::make_shared<ms::SurfaceEventSource>(mf::SurfaceId(), mock_event_sink);
369
356
 
370
357
    ms::BasicSurface surf(
371
 
        mf::SurfaceId(),
372
358
        surface_name,
373
359
        rect,
374
360
        false,
375
361
        mock_buffer_stream,
376
362
        std::shared_ptr<mi::InputChannel>(),
377
 
        mock_event_sink,
378
363
        stub_configurator,
379
364
        report);
380
365
 
 
366
    surf.add_observer(observer);
 
367
 
381
368
    ASSERT_THAT(surf.size(), Ne(new_size));
382
369
 
383
370
    EXPECT_CALL(*mock_event_sink, handle_event(_)).Times(1);
390
377
    using namespace testing;
391
378
    geom::Size const new_size{123, 456};
392
379
    auto const mock_event_sink = std::make_shared<MockEventSink>();
 
380
    auto const observer = std::make_shared<ms::SurfaceEventSource>(mf::SurfaceId(), mock_event_sink);
393
381
 
394
382
    ms::BasicSurface surf(
395
 
        mf::SurfaceId(),
396
383
        surface_name,
397
384
        rect,
398
385
        false,
399
386
        mock_buffer_stream,
400
387
        std::shared_ptr<mi::InputChannel>(),
401
 
        mock_event_sink,
402
388
        stub_configurator,
403
389
        report);
404
390
 
 
391
    surf.add_observer(observer);
 
392
 
405
393
    ASSERT_THAT(surf.size(), Ne(new_size));
406
394
 
407
395
    EXPECT_CALL(*mock_buffer_stream, resize(new_size)).Times(1);
428
416
        .WillOnce(Throw(std::runtime_error("bad resize")));
429
417
 
430
418
    ms::BasicSurface surf(
431
 
        mf::SurfaceId(),
432
419
        surface_name,
433
420
        rect,
434
421
        false,
435
422
        mock_buffer_stream,
436
423
        std::shared_ptr<mi::InputChannel>(),
437
 
        stub_event_sink,
438
424
        stub_configurator,
439
425
        report);
440
426
 
459
445
    };
460
446
 
461
447
    ms::BasicSurface surf(
462
 
        mf::SurfaceId(),
463
448
        surface_name,
464
449
        rect,
465
450
        false,
466
451
        mock_buffer_stream,
467
452
        std::shared_ptr<mi::InputChannel>(),
468
 
        stub_event_sink,
469
453
        stub_configurator,
470
454
        report);
471
455
 
484
468
{
485
469
    auto mock_channel = std::make_shared<MockInputChannel>();
486
470
    ms::BasicSurface surf(
487
 
        mf::SurfaceId(),
488
471
        surface_name,
489
472
        rect,
490
473
        false,
491
474
        mock_buffer_stream,
492
475
        mock_channel,
493
 
        stub_event_sink,
494
476
        stub_configurator,
495
477
        report);
496
478
 
503
485
 
504
486
    float alpha = 0.5f;
505
487
    ms::BasicSurface surf(
506
 
        mf::SurfaceId(),
507
488
        surface_name,
508
489
        rect,
509
490
        false,
510
491
        mock_buffer_stream,
511
492
        std::shared_ptr<mi::InputChannel>(),
512
 
        stub_event_sink,
513
493
        stub_configurator,
514
494
        report);
515
495
 
524
504
    EXPECT_CALL(*mock_buffer_stream, force_requests_to_complete()).Times(Exactly(1));
525
505
 
526
506
    ms::BasicSurface surf(
527
 
        mf::SurfaceId(),
528
507
        surface_name,
529
508
        rect,
530
509
        false,
531
510
        mock_buffer_stream,
532
511
        std::shared_ptr<mi::InputChannel>(),
533
 
        stub_event_sink,
534
512
        stub_configurator,
535
513
        report);
536
514
 
545
523
        .Times(1);
546
524
 
547
525
    ms::BasicSurface surf(
548
 
        mf::SurfaceId(),
549
526
        surface_name,
550
527
        rect,
551
528
        false,
552
529
        mock_buffer_stream,
553
530
        std::shared_ptr<mi::InputChannel>(),
554
 
        stub_event_sink,
555
531
        stub_configurator,
556
532
        report);
557
533
 
561
537
TEST_F(SurfaceCreation, test_surface_next_buffer_tells_state_on_first_frame)
562
538
{
563
539
    ms::BasicSurface surf(
564
 
        mf::SurfaceId(),
565
540
        surface_name,
566
541
        rect,
567
542
        false,
568
543
        mock_buffer_stream,
569
544
        std::shared_ptr<mi::InputChannel>(),
570
 
        stub_event_sink,
571
545
        stub_configurator,
572
546
        report);
573
547
 
589
563
    using namespace testing;
590
564
 
591
565
    ms::BasicSurface surf(
592
 
        mf::SurfaceId(),
593
566
        surface_name,
594
567
        rect,
595
568
        false,
596
569
        mock_buffer_stream,
597
570
        std::shared_ptr<mi::InputChannel>(),
598
 
        stub_event_sink,
599
571
        stub_configurator,
600
572
        report);
601
573
 
608
580
    EXPECT_CALL(channel, client_fd()).Times(1).WillOnce(Return(client_fd));
609
581
 
610
582
    ms::BasicSurface input_surf(
611
 
        mf::SurfaceId(),
612
583
        surface_name,
613
584
        rect,
614
585
        false,
615
586
        mock_buffer_stream,mt::fake_shared(channel),
616
 
        stub_event_sink,
617
587
        stub_configurator,
618
588
        report);
619
589