← Back to branch summary

~albaguirre/mir/backport-fixes-to-0.11

« back to all changes in this revision

Viewing changes to tests/unit-tests/graphics/android/test_hwc_device.cpp

  • Committer: Tarmac
  • Author(s): Kevin DuBois
  • Date: 2015-01-29 16:35:31 UTC
  • mfrom: (2215.3.26 pull-list-from-device)
  • Revision ID: tarmac-20150129163531-oklyqevk921mxuq3
android: pull the mga::LayerList instance from the mga::HwcDevice to the mga::DisplayBuffer.

Approved by Alan Griffiths, Alexandros Frantzis, PS Jenkins bot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit-tests/graphics/android/test_hwc_device.cpp
112
112
    std::shared_ptr<mtd::StubRenderable> const stub_renderable1;
113
113
    std::shared_ptr<mtd::StubRenderable> const stub_renderable2;
114
114
    std::shared_ptr<mtd::MockHWCDeviceWrapper> const mock_device;
115
 
    mtd::StubSwappingGLContext stub_context;
 
115
    mtd::StubSwappingGLContext const stub_context;
116
116
    mg::RenderableList renderlist;
117
117
    std::shared_ptr<mga::LayerAdapter> const layer_adapter;
 
118
    mga::DisplayName primary{mga::DisplayName::primary};
118
119
};
119
120
}
120
121
 
130
131
    EXPECT_CALL(*mock_device, prepare(MatchesPrimaryList(expected_list)))
131
132
        .Times(1);
132
133
 
133
 
    mga::HwcDevice device(mock_device, layer_adapter);
134
 
    device.post_gl(stub_context);
 
134
    mga::LayerList list(layer_adapter, {});
 
135
    mga::HwcDevice device(mock_device);
 
136
    device.commit(primary, list, stub_context, stub_compositor);
135
137
}
136
138
 
137
139
TEST_F(HwcDevice, calls_backup_compositor_when_overlay_rejected)
164
166
    EXPECT_CALL(mock_compositor, render(expected_renderable_list,Ref(stub_context)))
165
167
        .InSequence(seq);
166
168
 
167
 
    mga::HwcDevice device(mock_device, layer_adapter);
168
 
    EXPECT_TRUE(device.post_overlays(stub_context, renderlist, mock_compositor));
 
169
    mga::LayerList list(layer_adapter, renderlist);
 
170
    mga::HwcDevice device(mock_device);
 
171
    device.commit(primary, list, stub_context, mock_compositor);
 
172
}
 
173
 
 
174
TEST_F(HwcDevice, swaps_buffers_directly_when_no_renderables)
 
175
{
 
176
    using namespace testing;
 
177
    mtd::MockRenderableListCompositor mock_compositor;
 
178
    mtd::MockSwappingGLContext mock_context;
 
179
    ON_CALL(mock_context, last_rendered_buffer())
 
180
        .WillByDefault(Return(stub_fb_buffer));
 
181
 
 
182
    EXPECT_CALL(mock_compositor, render(_,_))
 
183
        .Times(0);
 
184
    EXPECT_CALL(mock_context, swap_buffers());
 
185
 
 
186
    mga::LayerList list(layer_adapter, {});
 
187
    mga::HwcDevice device(mock_device);
 
188
    device.commit(primary, list, mock_context, mock_compositor);
169
189
}
170
190
 
171
191
TEST_F(HwcDevice, resets_layers_when_prepare_gl_called)
189
209
        .InSequence(seq);
190
210
    EXPECT_CALL(*mock_device, prepare(MatchesPrimaryList(expected_list2)))
191
211
        .InSequence(seq);
192
 
    mga::HwcDevice device(mock_device, layer_adapter);
193
212
 
194
 
    EXPECT_TRUE(device.post_overlays(stub_context, renderlist, stub_compositor));
195
 
    device.post_gl(stub_context);
 
213
    mga::HwcDevice device(mock_device);
 
214
    mga::LayerList list(layer_adapter, renderlist);
 
215
    device.commit(primary, list, stub_context, stub_compositor);
 
216
    list.update_list({});
 
217
    device.commit(primary, list, stub_context, stub_compositor);
196
218
}
197
219
 
198
220
TEST_F(HwcDevice, sets_and_updates_fences)
222
244
    EXPECT_CALL(*mock_native_buffer3, update_usage(fb_release_fence, mga::BufferAccess::read))
223
245
        .InSequence(seq);
224
246
 
225
 
    mga::HwcDevice device(mock_device, layer_adapter);
226
 
    device.post_gl(stub_context);
 
247
    mga::HwcDevice device(mock_device);
 
248
    mga::LayerList list(layer_adapter, {});
 
249
    device.commit(primary, list, stub_context, stub_compositor);
227
250
 
228
251
    //check that the retire fence is closed
229
252
    bool retire_fence_was_closed{fcntl(hwc_retire_fence, F_GETFD) == -1};
254
277
        &target_layer
255
278
    };
256
279
 
257
 
    mga::HwcDevice device(mock_device, layer_adapter);
258
280
 
259
281
    EXPECT_CALL(*mock_native_buffer1, copy_fence())
260
282
        .Times(0);
273
295
    EXPECT_CALL(*mock_native_buffer3, update_usage(fb_release_fence, mga::BufferAccess::read))
274
296
        .InSequence(seq);
275
297
 
276
 
    EXPECT_TRUE(device.post_overlays(stub_context, {stub_renderable1}, stub_compositor));
 
298
    mga::HwcDevice device(mock_device);
 
299
    mga::LayerList list(layer_adapter, {stub_renderable1});
 
300
    device.commit(primary, list, stub_context, stub_compositor);
277
301
}
278
302
 
279
303
TEST_F(HwcDevice, commits_correct_list_when_all_accepted_as_overlays)
308
332
        &target_layer
309
333
    };
310
334
 
311
 
    mga::HwcDevice device(mock_device, layer_adapter);
312
 
 
313
335
    EXPECT_CALL(*mock_native_buffer3, copy_fence())
314
336
        .Times(0);
315
337
    int invalid{-1};
336
358
    EXPECT_CALL(*mock_native_buffer2, update_usage(release_fence2, mga::BufferAccess::read))
337
359
        .InSequence(seq);
338
360
 
339
 
    EXPECT_TRUE(device.post_overlays(stub_context, renderlist, stub_compositor));
340
 
}
341
 
 
342
 
TEST_F(HwcDevice, discards_second_set_if_all_overlays_and_nothing_has_changed)
343
 
{
344
 
    using namespace testing;
345
 
    ON_CALL(*mock_device, prepare(_))
346
 
        .WillByDefault(Invoke(set_all_layers_to_overlay));
347
 
    EXPECT_CALL(*mock_device, set(_))
348
 
        .Times(1);
349
 
 
350
 
    mga::HwcDevice device(mock_device, layer_adapter);
351
 
    EXPECT_TRUE(device.post_overlays(stub_context, renderlist, stub_compositor));
352
 
    EXPECT_FALSE(device.post_overlays(stub_context, renderlist, stub_compositor));
 
361
    mga::HwcDevice device(mock_device);
 
362
    mga::LayerList list(layer_adapter, renderlist);
 
363
    device.commit(primary, list, stub_context, stub_compositor);
353
364
}
354
365
 
355
366
TEST_F(HwcDevice, submits_every_time_if_at_least_one_layer_is_gl_rendered)
356
367
{
357
368
    using namespace testing;
358
 
    mga::HwcDevice device(mock_device, layer_adapter);
 
369
    mga::HwcDevice device(mock_device);
359
370
 
360
371
    ON_CALL(*mock_device, prepare(_))
361
372
        .WillByDefault(Invoke([&](std::array<hwc_display_contents_1_t*, HWC_NUM_DISPLAY_TYPES> const& contents)
369
380
    EXPECT_CALL(*mock_device, set(_))
370
381
        .Times(2);
371
382
 
372
 
    EXPECT_TRUE(device.post_overlays(stub_context, renderlist, stub_compositor));
373
 
    EXPECT_TRUE(device.post_overlays(stub_context, renderlist, stub_compositor));
 
383
    mga::LayerList list(layer_adapter, renderlist);
 
384
    device.commit(primary, list, stub_context, stub_compositor);
 
385
    list.update_list(renderlist);
 
386
    device.commit(primary, list, stub_context, stub_compositor);
374
387
}
375
388
 
376
389
TEST_F(HwcDevice, resets_composition_type_with_prepare) //lp:1314399
378
391
    using namespace testing;
379
392
    mg::RenderableList renderlist({stub_renderable1});
380
393
    mg::RenderableList renderlist2({stub_renderable2});
381
 
    mga::HwcDevice device(mock_device, layer_adapter);
 
394
    mga::HwcDevice device(mock_device);
382
395
 
383
396
    std::list<hwc_layer_1_t*> expected_list1 { &layer, &target_layer };
384
397
    std::list<hwc_layer_1_t*> expected_list2 { &layer2, &target_layer };
390
403
    EXPECT_CALL(*mock_device, prepare(MatchesPrimaryList(expected_list2)))
391
404
        .InSequence(seq);
392
405
 
393
 
    EXPECT_TRUE(device.post_overlays(stub_context, renderlist, stub_compositor));
394
 
    EXPECT_TRUE(device.post_overlays(stub_context, renderlist2, stub_compositor));
 
406
    mga::LayerList list(layer_adapter, renderlist);
 
407
    device.commit(primary, list, stub_context, stub_compositor);
 
408
    list.update_list(renderlist2);
 
409
    device.commit(primary, list, stub_context, stub_compositor);
395
410
}
396
411
 
397
412
//note: HWC models overlay layer buffers as owned by the display hardware until a subsequent set.
402
417
        .WillOnce(Invoke(set_all_layers_to_overlay))
403
418
        .WillOnce(Return());
404
419
 
405
 
    mga::HwcDevice device(mock_device, layer_adapter);
 
420
    mga::HwcDevice device(mock_device);
406
421
 
407
422
    auto use_count_before = stub_buffer1.use_count();
408
 
    EXPECT_TRUE(device.post_overlays(stub_context, {stub_renderable1}, stub_compositor));
 
423
    mga::LayerList list(layer_adapter, {stub_renderable1});
 
424
    device.commit(primary, list, stub_context, stub_compositor);
409
425
    EXPECT_THAT(stub_buffer1.use_count(), Gt(use_count_before));
410
 
 
411
 
    EXPECT_TRUE(device.post_overlays(stub_context, {stub_renderable2}, stub_compositor));
 
426
    list.update_list({stub_renderable1});
 
427
    device.commit(primary, list, stub_context, stub_compositor);
412
428
    EXPECT_THAT(stub_buffer1.use_count(), Eq(use_count_before));
413
429
}
414
430
 
485
501
        .InSequence(seq)
486
502
        .WillOnce(Invoke(set_fences_fn));
487
503
 
488
 
    mga::HwcDevice device(mock_device, layer_adapter);
489
 
    EXPECT_TRUE(device.post_overlays(stub_context, renderlist, stub_compositor));
 
504
    mga::HwcDevice device(mock_device);
 
505
    mga::LayerList list(layer_adapter, renderlist);
 
506
    device.commit(primary, list, stub_context, stub_compositor);
490
507
    //set only the 2nd layer to a new buffer. the first buffer has the same buffer, and would 
491
508
    //still be onscreen if this wasn't against a mock
492
509
    stub_renderable1->set_buffer(updated_buffer);
493
 
    EXPECT_TRUE(device.post_overlays(stub_context, renderlist, stub_compositor));
 
510
    list.update_list(renderlist);
 
511
    device.commit(primary, list, stub_context, stub_compositor);
494
512
}
495
513
 
496
514
TEST_F(HwcDevice, does_not_own_framebuffer_buffers_past_set)
504
522
            contents[0]->hwLayers[1].compositionType = HWC_FRAMEBUFFER_TARGET;
505
523
        }));
506
524
 
507
 
    mga::HwcDevice device(mock_device, layer_adapter);
 
525
    mga::HwcDevice device(mock_device);
508
526
 
509
527
    auto use_count_before = stub_buffer1.use_count();
510
 
    EXPECT_TRUE(device.post_overlays(stub_context, {stub_renderable1}, stub_compositor));
 
528
 
 
529
    mga::LayerList list(layer_adapter, {stub_renderable1});
 
530
    device.commit(primary, list, stub_context, stub_compositor);
511
531
    EXPECT_THAT(stub_buffer1.use_count(), Eq(use_count_before));
512
532
}
513
533
 
514
534
TEST_F(HwcDevice, rejects_empty_list)
515
535
{
516
 
    mga::HwcDevice device(mock_device, layer_adapter);
517
 
 
 
536
    mga::HwcDevice device(mock_device);
518
537
    std::list<std::shared_ptr<mg::Renderable>> renderlist{};
519
 
    EXPECT_FALSE(device.post_overlays(stub_context, renderlist, stub_compositor));
 
538
    EXPECT_FALSE(device.compatible_renderlist(renderlist));
520
539
}
521
540
 
522
541
//TODO: we could accept a 90 degree transform
523
542
TEST_F(HwcDevice, rejects_list_containing_transformed)
524
543
{
525
 
    mga::HwcDevice device(mock_device, layer_adapter);
 
544
    mga::HwcDevice device(mock_device);
526
545
 
527
546
    auto renderable = std::make_shared<mtd::StubTransformedRenderable>();
528
547
    mg::RenderableList renderlist{renderable};
529
 
    EXPECT_FALSE(device.post_overlays(stub_context, renderlist, stub_compositor));
 
548
    EXPECT_FALSE(device.compatible_renderlist(renderlist));
530
549
}
531
550
 
532
551
//TODO: support plane alpha for hwc 1.2 and later
533
552
TEST_F(HwcDevice, rejects_list_containing_plane_alpha)
534
553
{
535
 
    using namespace testing;
536
 
 
537
 
    mga::HwcDevice device(mock_device, layer_adapter);
538
 
 
 
554
    mga::HwcDevice device(mock_device);
539
555
    mg::RenderableList renderlist{std::make_shared<mtd::PlaneAlphaRenderable>()};
540
 
    EXPECT_FALSE(device.post_overlays(stub_context, renderlist, stub_compositor));
 
556
    EXPECT_FALSE(device.compatible_renderlist(renderlist));
541
557
}
542
558
 
543
559
TEST_F(HwcDevice, does_not_own_overlay_buffers_after_screen_off)
546
562
    EXPECT_CALL(*mock_device, prepare(_))
547
563
        .WillOnce(Invoke(set_all_layers_to_overlay));
548
564
 
549
 
    mga::HwcDevice device(mock_device, layer_adapter);
 
565
    mga::HwcDevice device(mock_device);
550
566
 
551
567
    auto use_count_before = stub_buffer1.use_count();
552
 
    EXPECT_TRUE(device.post_overlays(stub_context, {stub_renderable1}, stub_compositor));
 
568
    mga::LayerList list(layer_adapter, {stub_renderable1});
 
569
    device.commit(primary, list, stub_context, stub_compositor);
553
570
    EXPECT_THAT(stub_buffer1.use_count(), Gt(use_count_before));
554
571
 
555
572
    device.content_cleared();
641
658
        .InSequence(seq);
642
659
    //end second post
643
660
 
644
 
    mga::HwcDevice device(mock_device, layer_adapter);
645
 
    EXPECT_TRUE(device.post_overlays(stub_context, renderlist1, stub_compositor));
646
 
 
647
 
    EXPECT_TRUE(device.post_overlays(stub_context, renderlist2, stub_compositor));
 
661
    mga::HwcDevice device(mock_device);
 
662
    mga::LayerList list(layer_adapter, renderlist1);
 
663
    device.commit(primary, list, stub_context, stub_compositor);
 
664
    list.update_list(renderlist2);
 
665
    device.commit(primary, list, stub_context, stub_compositor);
648
666
}
649
667
 
650
668
TEST_F(HwcDevice, tracks_hwc_owned_fences_across_list_rearrange)
743
761
        .InSequence(seq);
744
762
    //end second post
745
763
 
746
 
    mga::HwcDevice device(mock_device, layer_adapter);
747
 
    EXPECT_TRUE(device.post_overlays(stub_context, renderlist, stub_compositor));
748
 
    EXPECT_TRUE(device.post_overlays(stub_context, renderlist2, stub_compositor));
 
764
    mga::HwcDevice device(mock_device);
 
765
    mga::LayerList list(layer_adapter, renderlist);
 
766
    device.commit(primary, list, stub_context, stub_compositor);
 
767
    list.update_list(renderlist2);
 
768
    device.commit(primary, list, stub_context, stub_compositor);
749
769
}