← Back to branch summary

~brandontschaefer/mir/lp.1233089-fix-v-h-scroll

« back to all changes in this revision

Viewing changes to tests/unit-tests/graphics/gbm/test_gbm_display_multi_monitor.cpp

  • Committer: Tarmac
  • Author(s): Kevin DuBois, Alan Griffiths, Alexandros Frantzis, Robert Ancell, Daniel d'Andrada
  • Date: 2013-09-26 04:50:57 UTC
  • mfrom: (1081.3.8 development-branch)
  • Revision ID: tarmac-20130926045057-w43xdxtxz8lhy8fg
frontend, config: Mechanism for connecting via a socket pair.
graphics: android: stop nex4 from tearing
gbm: Blank unused connected outputs.
compositor: tidy up configuration logic for initializing bypass flag.
tests: Add tests for Android's InputReader & friends
Bump libmirserver soname and Mir project version.

Approved by kevin gunn, PS Jenkins bot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit-tests/graphics/gbm/test_gbm_display_multi_monitor.cpp
147
147
        return platform->create_display(conf_policy);
148
148
    }
149
149
 
150
 
    void setup_outputs(int n)
 
150
    void setup_outputs(int connected, int disconnected)
151
151
    {
152
152
        using fake = mtd::FakeDRMResources;
153
153
 
167
167
        uint32_t const encoder_base_id{20};
168
168
        uint32_t const connector_base_id{30};
169
169
 
170
 
        for (int i = 0; i < n; i++)
 
170
        for (int i = 0; i < connected; i++)
171
171
        {
172
172
            uint32_t const crtc_id{crtc_base_id + i};
173
173
            uint32_t const encoder_id{encoder_base_id + i};
180
180
            resources.add_encoder(encoder_id, crtc_id, all_crtcs_mask);
181
181
        }
182
182
 
183
 
        for (int i = 0; i < n; i++)
 
183
        for (int i = 0; i < connected; i++)
184
184
        {
185
185
            uint32_t const connector_id{connector_base_id + i};
186
186
 
190
190
                                    modes0, encoder_ids, connector_physical_size_mm);
191
191
        }
192
192
 
 
193
        for (int i = 0; i < disconnected; i++)
 
194
        {
 
195
            uint32_t const connector_id{connector_base_id + connected + i};
 
196
 
 
197
            connector_ids.push_back(connector_id);
 
198
            resources.add_connector(connector_id, DRM_MODE_CONNECTOR_VGA,
 
199
                                    DRM_MODE_DISCONNECTED, 0,
 
200
                                    modes_empty, encoder_ids, geom::Size{});
 
201
        }
 
202
 
193
203
        resources.prepare();
194
204
    }
195
205
 
214
224
{
215
225
    using namespace testing;
216
226
 
217
 
    int const num_outputs{3};
 
227
    int const num_connected_outputs{3};
 
228
    int const num_disconnected_outputs{2};
218
229
    uint32_t const fb_id{66};
219
230
 
220
 
    setup_outputs(num_outputs);
 
231
    setup_outputs(num_connected_outputs, num_disconnected_outputs);
221
232
 
222
233
    /* Create DRM FBs */
223
234
    EXPECT_CALL(mock_drm, drmModeAddFB(mock_drm.fake_drm.fd(),
227
238
    ExpectationSet crtc_setups;
228
239
 
229
240
    /* All crtcs are set */
230
 
    for (int i = 0; i < num_outputs; i++)
 
241
    for (int i = 0; i < num_connected_outputs; i++)
231
242
    {
232
243
        crtc_setups += EXPECT_CALL(mock_drm,
233
244
                                   drmModeSetCrtc(mock_drm.fake_drm.fd(),
239
250
    }
240
251
 
241
252
    /* All crtcs are restored at teardown */
242
 
    for (int i = 0; i < num_outputs; i++)
 
253
    for (int i = 0; i < num_connected_outputs; i++)
243
254
    {
244
255
        EXPECT_CALL(mock_drm, drmModeSetCrtc(mock_drm.fake_drm.fd(),
245
256
                                             crtc_ids[i], Ne(fb_id),
257
268
{
258
269
    using namespace testing;
259
270
 
260
 
    int const num_outputs{3};
 
271
    int const num_connected_outputs{3};
 
272
    int const num_disconnected_outputs{2};
261
273
    EGLContext const shared_context{reinterpret_cast<EGLContext>(0x77)};
262
274
 
263
 
    setup_outputs(num_outputs);
 
275
    setup_outputs(num_connected_outputs, num_disconnected_outputs);
264
276
 
265
277
    /* Will create only one shared context */
266
278
    EXPECT_CALL(mock_egl, eglCreateContext(_, _, EGL_NO_CONTEXT, _))
303
315
{
304
316
    using namespace testing;
305
317
 
306
 
    int const num_outputs{3};
 
318
    int const num_connected_outputs{3};
 
319
    int const num_disconnected_outputs{2};
307
320
    uint32_t const fb_id{66};
308
 
    std::vector<void*> user_data(num_outputs, nullptr);
 
321
    std::vector<void*> user_data(num_connected_outputs, nullptr);
309
322
 
310
 
    setup_outputs(num_outputs);
 
323
    setup_outputs(num_connected_outputs, num_disconnected_outputs);
311
324
 
312
325
    /* Create DRM FBs */
313
326
    EXPECT_CALL(mock_drm, drmModeAddFB(mock_drm.fake_drm.fd(),
315
328
        .WillRepeatedly(DoAll(SetArgPointee<7>(fb_id), Return(0)));
316
329
 
317
330
    /* All crtcs are flipped */
318
 
    for (int i = 0; i < num_outputs; i++)
 
331
    for (int i = 0; i < num_connected_outputs; i++)
319
332
    {
320
333
        EXPECT_CALL(mock_drm, drmModePageFlip(mock_drm.fake_drm.fd(),
321
334
                                              crtc_ids[i], fb_id,
329
342
 
330
343
    /* Handle the events properly */
331
344
    EXPECT_CALL(mock_drm, drmHandleEvent(mock_drm.fake_drm.fd(), _))
332
 
        .Times(num_outputs)
 
345
        .Times(num_connected_outputs)
333
346
        .WillOnce(DoAll(InvokePageFlipHandler(&user_data[0]), Return(0)))
334
347
        .WillOnce(DoAll(InvokePageFlipHandler(&user_data[1]), Return(0)))
335
348
        .WillOnce(DoAll(InvokePageFlipHandler(&user_data[2]), Return(0)));
382
395
{
383
396
    using namespace testing;
384
397
 
385
 
    int const num_outputs{3};
 
398
    int const num_connected_outputs{3};
 
399
    int const num_disconnected_outputs{2};
386
400
    uint32_t const base_fb_id{66};
387
401
    FBIDContainer fb_id_container{base_fb_id};
388
402
 
389
 
    setup_outputs(num_outputs);
 
403
    setup_outputs(num_connected_outputs, num_disconnected_outputs);
390
404
 
391
405
    /* Create DRM FBs */
392
406
    EXPECT_CALL(mock_drm, drmModeAddFB(mock_drm.fake_drm.fd(),
393
407
                                       _, _, _, _, _, _, _))
394
 
        .Times(num_outputs)
 
408
        .Times(num_connected_outputs)
395
409
        .WillRepeatedly(Invoke(&fb_id_container, &FBIDContainer::add_fb));
396
410
 
397
411
    ExpectationSet crtc_setups;
398
412
 
399
413
    /* All crtcs are set */
400
 
    for (int i = 0; i < num_outputs; i++)
 
414
    for (int i = 0; i < num_connected_outputs; i++)
401
415
    {
402
416
        crtc_setups += EXPECT_CALL(mock_drm,
403
417
                                   drmModeSetCrtc(mock_drm.fake_drm.fd(),
410
424
    }
411
425
 
412
426
    /* All crtcs are restored at teardown */
413
 
    for (int i = 0; i < num_outputs; i++)
 
427
    for (int i = 0; i < num_connected_outputs; i++)
414
428
    {
415
429
        EXPECT_CALL(mock_drm, drmModeSetCrtc(mock_drm.fake_drm.fd(),
416
430
                                             crtc_ids[i], 0,
423
437
 
424
438
    auto display = create_display_side_by_side(create_platform());
425
439
}
 
440
 
 
441
TEST_F(GBMDisplayMultiMonitorTest, configure_clears_unused_connected_outputs)
 
442
{
 
443
    using namespace testing;
 
444
 
 
445
    int const num_connected_outputs{3};
 
446
    int const num_disconnected_outputs{2};
 
447
 
 
448
    setup_outputs(num_connected_outputs, num_disconnected_outputs);
 
449
 
 
450
    auto display = create_display_cloned(create_platform());
 
451
 
 
452
    Mock::VerifyAndClearExpectations(&mock_drm);
 
453
 
 
454
    /* All unused connected outputs are cleared */
 
455
    for (int i = 0; i < num_connected_outputs; i++)
 
456
    {
 
457
        EXPECT_CALL(mock_drm,
 
458
                    drmModeSetCursor(mock_drm.fake_drm.fd(),
 
459
                                     crtc_ids[i], 0, 0, 0))
 
460
                        .Times(1);
 
461
        EXPECT_CALL(mock_drm,
 
462
                    drmModeSetCrtc(mock_drm.fake_drm.fd(),
 
463
                                   crtc_ids[i], 0, 0, 0,
 
464
                                   nullptr, 0, nullptr))
 
465
                        .Times(1);
 
466
    }
 
467
 
 
468
    /* Set all outputs to unused */
 
469
    auto conf = display->configuration();
 
470
 
 
471
    conf->for_each_output(
 
472
        [&](mg::DisplayConfigurationOutput const& conf_output)
 
473
        {
 
474
            conf->configure_output(conf_output.id, false, conf_output.top_left,
 
475
                                   conf_output.preferred_mode_index, mir_power_mode_on);
 
476
        });
 
477
 
 
478
    display->configure(*conf);
 
479
 
 
480
    Mock::VerifyAndClearExpectations(&mock_drm);
 
481
 
 
482
    /* All crtcs are restored at teardown */
 
483
    for (int i = 0; i < num_connected_outputs; i++)
 
484
    {
 
485
        EXPECT_CALL(mock_drm,
 
486
                    drmModeSetCrtc(mock_drm.fake_drm.fd(), crtc_ids[i],
 
487
                                   0, _, _, Pointee(connector_ids[i]),
 
488
                                   _, _))
 
489
                        .Times(1);
 
490
    }
 
491
}
 
492
 
 
493
TEST_F(GBMDisplayMultiMonitorTest, resume_clears_unused_connected_outputs)
 
494
{
 
495
    using namespace testing;
 
496
 
 
497
    int const num_connected_outputs{3};
 
498
    int const num_disconnected_outputs{2};
 
499
 
 
500
    setup_outputs(num_connected_outputs, num_disconnected_outputs);
 
501
 
 
502
    auto display = create_display_cloned(create_platform());
 
503
 
 
504
    /* Set all outputs to unused */
 
505
    auto conf = display->configuration();
 
506
 
 
507
    conf->for_each_output(
 
508
        [&](mg::DisplayConfigurationOutput const& conf_output)
 
509
        {
 
510
            conf->configure_output(conf_output.id, false, conf_output.top_left,
 
511
                                   conf_output.preferred_mode_index, mir_power_mode_on);
 
512
        });
 
513
 
 
514
    display->configure(*conf);
 
515
 
 
516
    display->pause();
 
517
 
 
518
    Mock::VerifyAndClearExpectations(&mock_drm);
 
519
 
 
520
    /* All unused connected outputs are cleared */
 
521
    for (int i = 0; i < num_connected_outputs; i++)
 
522
    {
 
523
        EXPECT_CALL(mock_drm,
 
524
                    drmModeSetCrtc(mock_drm.fake_drm.fd(),
 
525
                                   crtc_ids[i], 0, 0, 0,
 
526
                                   nullptr, 0, nullptr))
 
527
                        .Times(1);
 
528
    }
 
529
 
 
530
    display->resume();
 
531
 
 
532
    Mock::VerifyAndClearExpectations(&mock_drm);
 
533
 
 
534
    /* All crtcs are restored at teardown */
 
535
    for (int i = 0; i < num_connected_outputs; i++)
 
536
    {
 
537
        EXPECT_CALL(mock_drm,
 
538
                    drmModeSetCrtc(mock_drm.fake_drm.fd(), crtc_ids[i],
 
539
                                   0, _, _, Pointee(connector_ids[i]),
 
540
                                   _, _))
 
541
                        .Times(1);
 
542
    }
 
543
}