← Back to branch summary

~robertcarr/mir/client-focus-notifications

« back to all changes in this revision

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

  • Committer: Robert Carr
  • Date: 2013-08-13 18:30:53 UTC
  • Revision ID: robert.carr@canonical.com-20130813183053-pp2hzgm46uvmc4x8
Revert to r762

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit-tests/graphics/gbm/test_gbm_display_configuration.cpp
104
104
 
105
105
    void setup_sample_modes()
106
106
    {
107
 
        using fake = mtd::FakeDRMResources;
108
 
 
109
107
        /* Add DRM modes */
110
 
        modes0.push_back(fake::create_mode(1920, 1080, 138500, 2080, 1111, fake::NormalMode));
111
 
        modes0.push_back(fake::create_mode(1920, 1080, 148500, 2200, 1125, fake::PreferredMode));
112
 
        modes0.push_back(fake::create_mode(1680, 1050, 119000, 1840, 1080, fake::NormalMode));
113
 
        modes0.push_back(fake::create_mode(832, 624, 57284, 1152, 667, fake::NormalMode));
 
108
        modes0.push_back(mtd::FakeDRMResources::create_mode(1920, 1080, 138500, 2080, 1111));
 
109
        modes0.push_back(mtd::FakeDRMResources::create_mode(1920, 1080, 148500, 2200, 1125));
 
110
        modes0.push_back(mtd::FakeDRMResources::create_mode(1680, 1050, 119000, 1840, 1080));
 
111
        modes0.push_back(mtd::FakeDRMResources::create_mode(832, 624, 57284, 1152, 667));
114
112
 
115
113
        /* Add the DisplayConfiguration modes corresponding to the DRM modes */
116
114
        for (auto const& mode : modes0)
148
146
    geom::Size const connector2_physical_size_mm{};
149
147
    std::vector<uint32_t> possible_encoder_ids_empty;
150
148
    uint32_t const possible_crtcs_mask_empty{0};
151
 
    size_t const max_simultaneous_outputs{1};
152
149
 
153
150
    mtd::FakeDRMResources& resources(mock_drm.fake_drm);
154
151
 
159
156
    resources.add_encoder(encoder0_id, crtc0_id, possible_crtcs_mask_empty);
160
157
    resources.add_encoder(encoder1_id, invalid_id, possible_crtcs_mask_empty);
161
158
 
162
 
    resources.add_connector(connector0_id, DRM_MODE_CONNECTOR_HDMIA,
163
 
                            DRM_MODE_CONNECTED, encoder0_id,
 
159
    resources.add_connector(connector0_id, DRM_MODE_CONNECTED, encoder0_id,
164
160
                            modes0, possible_encoder_ids_empty,
165
161
                            connector0_physical_size_mm);
166
 
    resources.add_connector(connector1_id, DRM_MODE_CONNECTOR_Unknown,
167
 
                            DRM_MODE_DISCONNECTED, invalid_id,
 
162
    resources.add_connector(connector1_id, DRM_MODE_DISCONNECTED, invalid_id,
168
163
                            modes_empty, possible_encoder_ids_empty,
169
164
                            connector1_physical_size_mm);
170
 
    resources.add_connector(connector2_id, DRM_MODE_CONNECTOR_eDP,
171
 
                            DRM_MODE_DISCONNECTED, encoder1_id,
 
165
    resources.add_connector(connector2_id, DRM_MODE_DISCONNECTED, encoder1_id,
172
166
                            modes_empty, possible_encoder_ids_empty,
173
167
                            connector2_physical_size_mm);
174
168
 
175
169
    resources.prepare();
176
170
 
177
171
    /* Expected results */
178
 
    std::vector<mg::DisplayConfigurationCard> const expected_cards =
179
 
    {
180
 
        {
181
 
            mg::DisplayConfigurationCardId{0},
182
 
            max_simultaneous_outputs
183
 
        }
184
 
    };
185
 
 
186
172
    std::vector<mg::DisplayConfigurationOutput> const expected_outputs =
187
173
    {
188
174
        {
189
175
            mg::DisplayConfigurationOutputId{connector0_id},
190
176
            mg::DisplayConfigurationCardId{0},
191
 
            mg::DisplayConfigurationOutputType::hdmia,
192
177
            {},
193
178
            conf_modes0,
194
 
            1,
195
179
            connector0_physical_size_mm,
196
180
            true,
197
181
            true,
202
186
        {
203
187
            mg::DisplayConfigurationOutputId{connector1_id},
204
188
            mg::DisplayConfigurationCardId{0},
205
 
            mg::DisplayConfigurationOutputType::unknown,
206
189
            {},
207
190
            std::vector<mg::DisplayConfigurationMode>(),
208
 
            std::numeric_limits<size_t>::max(),
209
191
            connector1_physical_size_mm,
210
192
            false,
211
193
            false,
216
198
        {
217
199
            mg::DisplayConfigurationOutputId{connector2_id},
218
200
            mg::DisplayConfigurationCardId{0},
219
 
            mg::DisplayConfigurationOutputType::edp,
220
201
            {},
221
202
            std::vector<mg::DisplayConfigurationMode>(),
222
 
            std::numeric_limits<size_t>::max(),
223
203
            connector2_physical_size_mm,
224
204
            false,
225
205
            false,
234
214
 
235
215
    auto conf = display->configuration();
236
216
 
237
 
    size_t card_count{0};
238
 
 
239
 
    conf->for_each_card([&](mg::DisplayConfigurationCard const& card)
240
 
    {
241
 
        ASSERT_LT(card_count, expected_cards.size());
242
 
        EXPECT_EQ(expected_cards[card_count], card) << "card_count: " << card_count;
243
 
        ++card_count;
244
 
    });
245
 
 
246
217
    size_t output_count{0};
247
218
 
248
219
    conf->for_each_output([&](mg::DisplayConfigurationOutput const& output)
272
243
    resources.add_encoder(encoder0_id, crtc0_id, possible_crtcs_mask_empty);
273
244
    for (auto id : connector_ids)
274
245
    {
275
 
        resources.add_connector(id, DRM_MODE_CONNECTOR_DVID,
276
 
                                DRM_MODE_CONNECTED, encoder0_id,
 
246
        resources.add_connector(id, DRM_MODE_CONNECTED, encoder0_id,
277
247
                                modes0, encoder_ids,
278
248
                                geom::Size());
279
249
    }
315
285
    resources.add_encoder(encoder0_id, crtc0_id, possible_crtcs_mask_empty);
316
286
    for (auto id : connector_ids)
317
287
    {
318
 
        resources.add_connector(id, DRM_MODE_CONNECTOR_VGA,
319
 
                                DRM_MODE_CONNECTED, encoder0_id,
 
288
        resources.add_connector(id, DRM_MODE_CONNECTED, encoder0_id,
320
289
                                modes0, encoder_ids,
321
290
                                geom::Size());
322
291
    }
353
322
    };
354
323
    std::vector<uint32_t> possible_encoder_ids_empty;
355
324
    uint32_t const possible_crtcs_mask_empty{0};
356
 
    size_t const max_simultaneous_outputs{1};
357
325
 
358
326
    /* Expected results */
359
 
    std::vector<mg::DisplayConfigurationCard> const expected_cards =
360
 
    {
361
 
        {
362
 
            mg::DisplayConfigurationCardId{0},
363
 
            max_simultaneous_outputs
364
 
        }
365
 
    };
366
 
 
367
327
    std::vector<mg::DisplayConfigurationOutput> const expected_outputs_before =
368
328
    {
369
329
        {
370
330
            mg::DisplayConfigurationOutputId(connector_ids[0]),
371
331
            mg::DisplayConfigurationCardId{0},
372
 
            mg::DisplayConfigurationOutputType::composite,
373
332
            {},
374
333
            conf_modes0,
375
 
            1,
376
334
            connector_physical_sizes_mm_before[0],
377
335
            true,
378
336
            true,
383
341
        {
384
342
            mg::DisplayConfigurationOutputId(connector_ids[1]),
385
343
            mg::DisplayConfigurationCardId{0},
386
 
            mg::DisplayConfigurationOutputType::vga,
387
344
            {},
388
345
            std::vector<mg::DisplayConfigurationMode>(),
389
 
            std::numeric_limits<size_t>::max(),
390
346
            connector_physical_sizes_mm_before[1],
391
347
            false,
392
348
            false,
401
357
        {
402
358
            mg::DisplayConfigurationOutputId(connector_ids[0]),
403
359
            mg::DisplayConfigurationCardId{0},
404
 
            mg::DisplayConfigurationOutputType::composite,
405
360
            {},
406
361
            std::vector<mg::DisplayConfigurationMode>(),
407
 
            std::numeric_limits<size_t>::max(),
408
362
            connector_physical_sizes_mm_after[0],
409
363
            false,
410
364
            true,
415
369
        {
416
370
            mg::DisplayConfigurationOutputId(connector_ids[1]),
417
371
            mg::DisplayConfigurationCardId{0},
418
 
            mg::DisplayConfigurationOutputType::vga,
419
372
            {},
420
373
            conf_modes0,
421
 
            1,
422
374
            connector_physical_sizes_mm_after[1],
423
375
            true,
424
376
            false,
438
390
    resources.add_encoder(encoder_ids[0], crtc_ids[0], possible_crtcs_mask_empty);
439
391
    resources.add_encoder(encoder_ids[1], invalid_id, possible_crtcs_mask_empty);
440
392
 
441
 
    resources.add_connector(connector_ids[0], DRM_MODE_CONNECTOR_Composite,
442
 
                            DRM_MODE_CONNECTED, encoder_ids[0],
 
393
    resources.add_connector(connector_ids[0], DRM_MODE_CONNECTED, encoder_ids[0],
443
394
                            modes0, possible_encoder_ids_empty,
444
395
                            connector_physical_sizes_mm_before[0]);
445
 
    resources.add_connector(connector_ids[1], DRM_MODE_CONNECTOR_VGA,
446
 
                            DRM_MODE_DISCONNECTED, invalid_id,
 
396
    resources.add_connector(connector_ids[1], DRM_MODE_DISCONNECTED, invalid_id,
447
397
                            modes_empty, possible_encoder_ids_empty,
448
398
                            connector_physical_sizes_mm_before[1]);
449
399
 
453
403
 
454
404
    auto conf = display->configuration();
455
405
 
456
 
    size_t card_count{0};
457
 
 
458
 
    conf->for_each_card([&](mg::DisplayConfigurationCard const& card)
459
 
    {
460
 
        ASSERT_LT(card_count, expected_cards.size());
461
 
        EXPECT_EQ(expected_cards[card_count], card) << "card_count: " << card_count;
462
 
        ++card_count;
463
 
    });
464
 
 
465
406
    size_t output_count{0};
466
407
 
467
408
    conf->for_each_output([&](mg::DisplayConfigurationOutput const& output)
481
422
    resources.add_encoder(encoder_ids[0], invalid_id, possible_crtcs_mask_empty);
482
423
    resources.add_encoder(encoder_ids[1], crtc_ids[1], possible_crtcs_mask_empty);
483
424
 
484
 
    resources.add_connector(connector_ids[0], DRM_MODE_CONNECTOR_Composite,
485
 
                            DRM_MODE_DISCONNECTED, invalid_id,
 
425
    resources.add_connector(connector_ids[0], DRM_MODE_DISCONNECTED, invalid_id,
486
426
                            modes_empty, possible_encoder_ids_empty,
487
427
                            connector_physical_sizes_mm_after[0]);
488
 
    resources.add_connector(connector_ids[1], DRM_MODE_CONNECTOR_VGA,
489
 
                            DRM_MODE_CONNECTED, encoder_ids[1],
 
428
    resources.add_connector(connector_ids[1], DRM_MODE_CONNECTED, encoder_ids[1],
490
429
                            modes0, possible_encoder_ids_empty,
491
430
                            connector_physical_sizes_mm_after[1]);
492
431
 
494
433
 
495
434
    conf = display->configuration();
496
435
 
497
 
    card_count = 0;
498
 
 
499
 
    conf->for_each_card([&](mg::DisplayConfigurationCard const& card)
500
 
    {
501
 
        ASSERT_LT(card_count, expected_cards.size());
502
 
        EXPECT_EQ(expected_cards[card_count], card) << "card_count: " << card_count;
503
 
        ++card_count;
504
 
    });
505
 
 
506
436
    output_count = 0;
507
437
 
508
438
    conf->for_each_output([&](mg::DisplayConfigurationOutput const& output)