← Back to branch summary

~vanvugt/mir/client-side-vsync-part2

« back to all changes in this revision

Viewing changes to tests/unit-tests/platforms/mesa/kms/test_display_buffer.cpp

Construct mesa::DisplayBuffer with a general transformation matrix
instead of orientation. Fixes: https://bugs.launchpad.net/bugs/1639226.

Approved by Alberto Aguirre, mir-ci-bot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit-tests/platforms/mesa/kms/test_display_buffer.cpp
31
31
#include "mir/test/doubles/stub_gbm_native_buffer.h"
32
32
#include "mir_test_framework/udev_environment.h"
33
33
#include "mir/test/doubles/fake_renderable.h"
 
34
#include "mir/graphics/transformation.h"
34
35
#include "mock_kms_output.h"
35
36
 
36
37
#include <gtest/gtest.h>
155
156
        {mock_kms_output},
156
157
        make_output_surface(),
157
158
        display_area,
158
 
        mir_orientation_normal);
 
159
        {});
159
160
 
160
161
    EXPECT_EQ(display_area, db.view_area());
161
162
}
168
169
        {mock_kms_output},
169
170
        make_output_surface(),
170
171
        display_area,
171
 
        mir_orientation_normal);
 
172
        {});
172
173
 
173
174
    auto original_count = mock_bypassable_buffer.use_count();
174
175
 
192
193
        {mock_kms_output},
193
194
        make_output_surface(),
194
195
        display_area,
195
 
        mir_orientation_normal);
 
196
        {});
196
197
 
197
198
    for (int frame = 0; frame < 5; ++frame)
198
199
    {
218
219
        {mock_kms_output},
219
220
        make_output_surface(),
220
221
        display_area,
221
 
        mir_orientation_normal);
 
222
        {});
222
223
 
223
224
    for (int frame = 0; frame < 5; ++frame)
224
225
    {
238
239
        {mock_kms_output},
239
240
        make_output_surface(),
240
241
        display_area,
241
 
        mir_orientation_normal);
 
242
        {});
242
243
 
243
244
    auto original_count = mock_bypassable_buffer.use_count();
244
245
 
251
252
    EXPECT_EQ(original_count+1, mock_bypassable_buffer.use_count());
252
253
}
253
254
 
254
 
TEST_F(MesaDisplayBufferTest, normal_orientation_with_bypassable_list_can_bypass)
 
255
TEST_F(MesaDisplayBufferTest, untransformed_with_bypassable_list_can_bypass)
255
256
{
256
257
    graphics::mesa::DisplayBuffer db(
257
258
        graphics::mesa::BypassOption::allowed,
259
260
        {mock_kms_output},
260
261
        make_output_surface(),
261
262
        display_area,
262
 
        mir_orientation_normal);
 
263
        {});
263
264
 
264
265
    EXPECT_TRUE(db.overlay(bypassable_list));
265
266
}
277
278
        {mock_kms_output},
278
279
        make_output_surface(),
279
280
        display_area,
280
 
        mir_orientation_normal);
 
281
        {});
281
282
 
282
283
    EXPECT_FALSE(db.overlay(bypassable_list));
283
284
    // And then we recover. DRM finds enough resources to AddFB ...
302
303
        {mock_kms_output},
303
304
        make_output_surface(),
304
305
        display_area,
305
 
        mir_orientation_normal);
 
306
        {});
306
307
 
307
308
    EXPECT_FALSE(db.overlay(list));
308
309
}
315
316
        {mock_kms_output},
316
317
        make_output_surface(),
317
318
        display_area,
318
 
        mir_orientation_right);
 
319
        transformation(mir_orientation_right));
319
320
 
320
321
    EXPECT_FALSE(db.overlay(bypassable_list));
321
322
}
333
334
        {mock_kms_output},
334
335
        make_output_surface(),
335
336
        display_area,
336
 
        mir_orientation_normal);
 
337
        {});
337
338
 
338
339
    EXPECT_FALSE(db.overlay(list));
339
340
}
351
352
        {mock_kms_output},
352
353
        make_output_surface(),
353
354
        display_area,
354
 
        mir_orientation_normal);
 
355
        {});
355
356
 
356
357
    // If you find yourself using gbm_ functions on a Shm buffer then you're
357
358
    // asking for a crash (LP: #1493721) ...
359
360
    db.overlay(list);
360
361
}
361
362
 
362
 
TEST_F(MesaDisplayBufferTest, orientation_not_implemented_internally)
 
363
TEST_F(MesaDisplayBufferTest, transformation_not_implemented_internally)
363
364
{
364
 
    glm::mat2 const rotate_left( 0, 1, // transposed!
365
 
                                -1, 0);
 
365
    glm::mat2 const rotate_left = transformation(mir_orientation_left);
366
366
 
367
367
    graphics::mesa::DisplayBuffer db(
368
368
        graphics::mesa::BypassOption::allowed,
370
370
        {mock_kms_output},
371
371
        make_output_surface(),
372
372
        display_area,
373
 
        mir_orientation_left);
 
373
        rotate_left);
374
374
 
375
375
    EXPECT_EQ(rotate_left, db.transformation());
376
376
}
390
390
        {mock_kms_output, mock_kms_output},
391
391
        make_output_surface(),
392
392
        display_area,
393
 
        mir_orientation_normal);
 
393
        {});
394
394
 
395
395
    db.swap_buffers();
396
396
    db.post();
409
409
        {mock_kms_output},
410
410
        make_output_surface(),
411
411
        display_area,
412
 
        mir_orientation_normal);
 
412
        {});
413
413
 
414
414
    db.swap_buffers();
415
415
    db.post();
436
436
        {mock_kms_output, mock_kms_output},
437
437
        make_output_surface(),
438
438
        display_area,
439
 
        mir_orientation_normal);
 
439
        {});
440
440
 
441
441
    db.swap_buffers();
442
442
    db.post();
458
458
        {mock_kms_output},
459
459
        make_output_surface(),
460
460
        display_area,
461
 
        mir_orientation_normal);
 
461
        {});
462
462
 
463
463
    EXPECT_FALSE(db.overlay(list));
464
464
}
483
483
        {mock_kms_output},
484
484
        make_output_surface(),
485
485
        display_area,
486
 
        mir_orientation_normal);
 
486
        {});
487
487
 
488
488
    EXPECT_FALSE(db.overlay(list));
489
489
}
499
499
        {mock_kms_output},
500
500
        make_output_surface(),
501
501
        display_area,
502
 
        mir_orientation_normal);
 
502
        {});
503
503
 
504
504
    EXPECT_FALSE(db.overlay(bypassable_list));
505
505
}