← Back to branch summary

~robertcarr/mir/add-log-all-option

« back to all changes in this revision

Viewing changes to tests/unit-tests/compositor/test_switching_bundle.cpp

Clean up constants relating to SwitchingBundle.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit-tests/compositor/test_switching_bundle.cpp
58
58
                                    geom::PixelFormat::argb_8888,
59
59
                                    mg::BufferUsage::software};
60
60
 
61
 
    for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
 
61
    for (int nbuffers = mc::SwitchingBundle::min_buffers;
 
62
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
63
         ++nbuffers)
62
64
    {
63
65
        mc::SwitchingBundle bundle(nbuffers, allocator, properties);
64
66
 
92
94
 
93
95
TEST_F(SwitchingBundleTest, client_acquire_basic)
94
96
{
95
 
    for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
 
97
    for (int nbuffers = mc::SwitchingBundle::min_buffers;
 
98
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
99
         ++nbuffers)
96
100
    {
97
101
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
98
102
 
116
120
 
117
121
TEST_F(SwitchingBundleTest, is_really_synchronous)
118
122
{
119
 
    for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
 
123
    for (int nbuffers = mc::SwitchingBundle::min_buffers;
 
124
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
125
         ++nbuffers)
120
126
    {
121
127
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
122
128
        mg::BufferID prev_id, prev_prev_id;
153
159
 
154
160
TEST_F(SwitchingBundleTest, framedropping_clients_never_block)
155
161
{
156
 
    for (int nbuffers = 2; nbuffers <= 5; nbuffers++)
 
162
    for (int nbuffers = 2;
 
163
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
164
         ++nbuffers)
157
165
    {
158
166
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
159
167
        unsigned int frameno = 0;
205
213
 
206
214
TEST_F(SwitchingBundleTest, out_of_order_client_release)
207
215
{
208
 
    for (int nbuffers = 2; nbuffers <= 5; nbuffers++)
 
216
    for (int nbuffers = 2;
 
217
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
218
         ++nbuffers)
209
219
    {
210
220
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
211
221
 
226
236
 
227
237
TEST_F(SwitchingBundleTest, compositor_acquire_basic)
228
238
{
229
 
    for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
 
239
    for (int nbuffers = mc::SwitchingBundle::min_buffers;
 
240
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
241
         ++nbuffers)
230
242
    {
231
243
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
232
244
        unsigned long frameno = 0;
247
259
 
248
260
TEST_F(SwitchingBundleTest, compositor_acquire_never_blocks)
249
261
{
250
 
    for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
 
262
    for (int nbuffers = mc::SwitchingBundle::min_buffers;
 
263
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
264
         ++nbuffers)
251
265
    {
252
266
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
253
267
        unsigned long frameno = 0;
266
280
 
267
281
TEST_F(SwitchingBundleTest, compositor_acquire_recycles_latest_ready_buffer)
268
282
{
269
 
    for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
 
283
    for (int nbuffers = mc::SwitchingBundle::min_buffers;
 
284
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
285
         ++nbuffers)
270
286
    {
271
287
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
272
288
        unsigned long frameno = 1;
296
312
 
297
313
TEST_F(SwitchingBundleTest, compositor_release_verifies_parameter)
298
314
{
299
 
    for (int nbuffers = 2; nbuffers <= 5; nbuffers++)
 
315
    for (int nbuffers = 2;
 
316
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
317
         ++nbuffers)
300
318
    {
301
319
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
302
320
        unsigned long frameno = 0;
321
339
TEST_F(SwitchingBundleTest, overlapping_compositors_get_different_frames)
322
340
{
323
341
    // This test simulates bypass behaviour
324
 
    for (int nbuffers = 2; nbuffers <= 5; nbuffers++)
 
342
    for (int nbuffers = 2;
 
343
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
344
         ++nbuffers)
325
345
    {
326
346
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
327
347
        unsigned long frameno = 1;
355
375
 
356
376
TEST_F(SwitchingBundleTest, snapshot_acquire_basic)
357
377
{
358
 
    for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
 
378
    for (int nbuffers = mc::SwitchingBundle::min_buffers;
 
379
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
380
         ++nbuffers)
359
381
    {
360
382
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
361
383
 
369
391
 
370
392
TEST_F(SwitchingBundleTest, snapshot_acquire_never_blocks)
371
393
{
372
 
    for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
 
394
    for (int nbuffers = mc::SwitchingBundle::min_buffers;
 
395
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
396
         ++nbuffers)
373
397
    {
374
398
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
375
399
        const int N = 100;
385
409
 
386
410
TEST_F(SwitchingBundleTest, snapshot_release_verifies_parameter)
387
411
{
388
 
    for (int nbuffers = 2; nbuffers <= 5; nbuffers++)
 
412
    for (int nbuffers = 2;
 
413
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
414
         ++nbuffers)
389
415
    {
390
416
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
391
417
 
468
494
 
469
495
TEST_F(SwitchingBundleTest, stress)
470
496
{
471
 
    for (int nbuffers = 2; nbuffers <= 5; nbuffers++)
 
497
    for (int nbuffers = 2;
 
498
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
499
         ++nbuffers)
472
500
    {
473
501
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
474
502
 
512
540
     * unique ones while it makes sense to do so. Buffers are big things and
513
541
     * should be allocated sparingly...
514
542
     */
515
 
    for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
 
543
    for (int nbuffers = mc::SwitchingBundle::min_buffers;
 
544
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
545
         ++nbuffers)
516
546
    {
517
547
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
518
548
        unsigned long frameno = 0;
545
575
 
546
576
TEST_F(SwitchingBundleTest, bypass_clients_get_more_than_two_buffers)
547
577
{
548
 
    for (int nbuffers = 3; nbuffers <= 5; nbuffers++)
 
578
    for (int nbuffers = 3;
 
579
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
580
         ++nbuffers)
549
581
    {
550
582
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
551
583
        unsigned long frameno = 1;
584
616
 
585
617
TEST_F(SwitchingBundleTest, framedropping_clients_get_all_buffers)
586
618
{
587
 
    const int max_nbuffers = 5;
588
 
    for (int nbuffers = 2; nbuffers <= max_nbuffers; nbuffers++)
 
619
    for (int nbuffers = 2;
 
620
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
621
         ++nbuffers)
589
622
    {
590
623
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
591
624
 
592
625
        bundle.allow_framedropping(true);
593
626
 
594
627
        const int nframes = 100;
595
 
        mg::BufferID expect[max_nbuffers];
596
 
        std::shared_ptr<mg::Buffer> buf[max_nbuffers];
 
628
        mg::BufferID expect[mc::SwitchingBundle::max_buffers];
 
629
        std::shared_ptr<mg::Buffer> buf[mc::SwitchingBundle::max_buffers];
597
630
 
598
631
        for (int b = 0; b < nbuffers; b++)
599
632
        {
618
651
 
619
652
TEST_F(SwitchingBundleTest, waiting_clients_unblock_on_shutdown)
620
653
{
621
 
    for (int nbuffers = 2; nbuffers <= 5; nbuffers++)
 
654
    for (int nbuffers = 2;
 
655
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
656
         ++nbuffers)
622
657
    {
623
658
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
624
659
 
639
674
 
640
675
TEST_F(SwitchingBundleTest, waiting_clients_unblock_on_vt_switch_not_permanent)
641
676
{   // Regression test for LP: #1207226
642
 
    for (int nbuffers = 2; nbuffers <= 5; nbuffers++)
 
677
    for (int nbuffers = 2;
 
678
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
679
         ++nbuffers)
643
680
    {
644
681
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
645
682
 
756
793
 
757
794
TEST_F(SwitchingBundleTest, resize_affects_client_acquires_immediately)
758
795
{
759
 
    for (int nbuffers = 1; nbuffers <= 5; ++nbuffers)
 
796
    for (int nbuffers = mc::SwitchingBundle::min_buffers;
 
797
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
798
         ++nbuffers)
760
799
    {
761
800
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
762
801
        unsigned long frameno = 1;
782
821
 
783
822
TEST_F(SwitchingBundleTest, compositor_acquires_resized_frames)
784
823
{
785
 
    for (int nbuffers = 1; nbuffers <= 5; ++nbuffers)
 
824
    for (int nbuffers = mc::SwitchingBundle::min_buffers;
 
825
         nbuffers <= mc::SwitchingBundle::max_buffers;
 
826
         ++nbuffers)
786
827
    {
787
828
        mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
788
829
        mg::BufferID history[5];