← Back to branch summary

~robert-ancell/mir/mirplatform

« back to all changes in this revision

Viewing changes to tests/unit-tests/frontend/test_session_mediator.cpp

Add protobuf message and api for requesting display configuration change.  Requests to change the display are authorized by the shell authorizer

.

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit-tests/frontend/test_session_mediator.cpp
27
27
#include "mir/graphics/platform.h"
28
28
#include "mir/graphics/platform_ipc_package.h"
29
29
#include "mir/surfaces/surface.h"
 
30
#include "mir_test_doubles/mock_display.h"
 
31
#include "mir_test_doubles/mock_display_changer.h"
30
32
#include "mir_test_doubles/null_display.h"
 
33
#include "mir_test_doubles/null_display_changer.h"
31
34
#include "mir_test_doubles/mock_display.h"
32
35
#include "mir_test_doubles/mock_shell.h"
33
36
#include "mir_test_doubles/mock_frontend_surface.h"
56
59
 
57
60
namespace
58
61
{
59
 
 
 
62
struct StubConfig : public mtd::NullDisplayConfig
 
63
{
 
64
    StubConfig(std::shared_ptr<mg::DisplayConfigurationOutput> const& conf)
 
65
       : outputs{conf, conf}
 
66
    {
 
67
    }
 
68
    virtual void for_each_output(std::function<void(mg::DisplayConfigurationOutput const&)> f) const override
 
69
    {
 
70
        for(auto const& disp : outputs)
 
71
        {
 
72
            f(*disp);
 
73
        }
 
74
    }
 
75
 
 
76
    std::vector<std::shared_ptr<mg::DisplayConfigurationOutput>> outputs;
 
77
};
 
78
 
 
79
struct MockConfig : public mg::DisplayConfiguration
 
80
{
 
81
    MOCK_CONST_METHOD1(for_each_card, void(std::function<void(mg::DisplayConfigurationCard const&)>));
 
82
    MOCK_CONST_METHOD1(for_each_output, void(std::function<void(mg::DisplayConfigurationOutput const&)>));
 
83
    MOCK_METHOD4(configure_output, void(mg::DisplayConfigurationOutputId, bool, geom::Point, size_t));
 
84
};
 
85
 
 
86
}
 
87
 
 
88
namespace
 
89
{
60
90
class StubbedSession : public mtd::StubSession
61
91
{
62
92
public:
141
171
    SessionMediatorTest()
142
172
        : shell{std::make_shared<testing::NiceMock<mtd::MockShell>>()},
143
173
          graphics_platform{std::make_shared<testing::NiceMock<MockPlatform>>()},
144
 
          graphics_display{std::make_shared<mtd::NullDisplay>()},
 
174
          graphics_changer{std::make_shared<mtd::NullDisplayChanger>()},
145
175
          buffer_allocator{std::make_shared<testing::NiceMock<MockGraphicBufferAllocator>>()},
146
176
          report{std::make_shared<mf::NullSessionMediatorReport>()},
147
177
          resource_cache{std::make_shared<mf::ResourceCache>()},
148
 
          mediator{shell, graphics_platform, graphics_display,
 
178
          mediator{shell, graphics_platform, graphics_changer,
149
179
                   buffer_allocator, report, 
150
180
                   std::make_shared<NullEventSink>(),
151
181
                   resource_cache},
160
190
 
161
191
    std::shared_ptr<testing::NiceMock<mtd::MockShell>> const shell;
162
192
    std::shared_ptr<MockPlatform> const graphics_platform;
163
 
    std::shared_ptr<mg::Display> const graphics_display;
 
193
    std::shared_ptr<msh::DisplayChanger> const graphics_changer;
164
194
    std::shared_ptr<testing::NiceMock<MockGraphicBufferAllocator>> const buffer_allocator;
165
195
    std::shared_ptr<mf::SessionMediatorReport> const report;
166
196
    std::shared_ptr<mf::ResourceCache> const resource_cache;
299
329
    mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
300
330
}
301
331
 
302
 
namespace
303
 
{
304
 
struct StubConfig : public mg::DisplayConfiguration
305
 
{
306
 
    StubConfig(std::shared_ptr<mg::DisplayConfigurationOutput> const& conf)
307
 
       : outputs{conf, conf}
308
 
    {
309
 
    }
310
 
    virtual void for_each_card(std::function<void(mg::DisplayConfigurationCard const&)>) const
311
 
    {
312
 
    }
313
 
    virtual void for_each_output(std::function<void(mg::DisplayConfigurationOutput const&)> f) const
314
 
    {
315
 
        for (auto const& disp : outputs)
316
 
        {
317
 
            f(*disp);
318
 
        }
319
 
    }
320
 
    virtual void configure_output(mg::DisplayConfigurationOutputId, bool, geom::Point, size_t)
321
 
    {
322
 
    }
323
 
 
324
 
    std::vector<std::shared_ptr<mg::DisplayConfigurationOutput>> outputs;
325
 
};
326
 
 
327
 
}
328
 
 
329
332
TEST_F(SessionMediatorTest, connect_packs_display_output)
330
333
{
331
334
    using namespace testing;
340
343
 
341
344
    StubConfig config(mt::fake_shared(output));
342
345
 
343
 
    auto mock_display = std::make_shared<mtd::MockDisplay>();
344
 
    EXPECT_CALL(*mock_display, configuration())
 
346
    auto mock_display = std::make_shared<mtd::MockDisplayChanger>();
 
347
    EXPECT_CALL(*mock_display, active_configuration())
345
348
        .Times(1)
346
349
        .WillOnce(Return(mt::fake_shared(config)));
347
 
    mf::SessionMediator mediator{
 
350
    mf::SessionMediator mediator(
348
351
        shell, graphics_platform, mock_display,
349
352
        buffer_allocator, report, 
350
353
        std::make_shared<NullEventSink>(),
351
 
        resource_cache};
 
354
        resource_cache);
352
355
 
353
356
    mp::ConnectParameters connect_parameters;
354
357
    mp::Connection connection;
477
480
 
478
481
    mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
479
482
}
 
483
 
 
484
TEST_F(SessionMediatorTest, display_config_request)
 
485
{
 
486
    using namespace testing;
 
487
    mp::ConnectParameters connect_parameters;
 
488
    mp::Connection connection;
 
489
 
 
490
    bool used0 = false, used1 = true;
 
491
    geom::Point pt0{44,22}, pt1{3,2};
 
492
    size_t mode_index0 = 1, mode_index1 = 3; 
 
493
    mg::DisplayConfigurationOutputId id0{6}, id1{3};
 
494
 
 
495
    NiceMock<MockConfig> mock_display_config;
 
496
    auto mock_display_selector = std::make_shared<mtd::MockDisplayChanger>();
 
497
 
 
498
    Sequence seq;
 
499
    EXPECT_CALL(*mock_display_selector, active_configuration())
 
500
        .InSequence(seq)
 
501
        .WillOnce(Return(mt::fake_shared(mock_display_config))); 
 
502
    EXPECT_CALL(*mock_display_selector, active_configuration())
 
503
        .InSequence(seq)
 
504
        .WillOnce(Return(mt::fake_shared(mock_display_config))); 
 
505
    EXPECT_CALL(mock_display_config, configure_output(id0, used0, pt0, mode_index0))
 
506
        .InSequence(seq);
 
507
    EXPECT_CALL(mock_display_config, configure_output(id1, used1, pt1, mode_index1))
 
508
        .InSequence(seq);
 
509
    EXPECT_CALL(*mock_display_selector, configure(_,_))
 
510
        .InSequence(seq);
 
511
 
 
512
    mf::SessionMediator session_mediator{
 
513
            shell, graphics_platform, mock_display_selector,
 
514
            buffer_allocator, report, std::make_shared<NullEventSink>(), resource_cache};
 
515
 
 
516
    session_mediator.connect(nullptr, &connect_parameters, &connection, null_callback.get());
 
517
 
 
518
    mp::Void ignored;
 
519
    mp::DisplayConfiguration configuration; 
 
520
    auto disp0 = configuration.add_display_output();
 
521
    disp0->set_output_id(id0.as_value());
 
522
    disp0->set_used(used0);
 
523
    disp0->set_position_x(pt0.x.as_uint32_t());
 
524
    disp0->set_position_y(pt0.y.as_uint32_t());
 
525
    disp0->set_current_mode(mode_index0);
 
526
 
 
527
    auto disp1 = configuration.add_display_output();
 
528
    disp1->set_output_id(id1.as_value());
 
529
    disp1->set_used(used1);
 
530
    disp1->set_position_x(pt1.x.as_uint32_t());
 
531
    disp1->set_position_y(pt1.y.as_uint32_t());
 
532
    disp1->set_current_mode(mode_index1);
 
533
 
 
534
    session_mediator.configure_display(nullptr, &configuration, &ignored, null_callback.get());
 
535
 
 
536
    session_mediator.disconnect(nullptr, nullptr, nullptr, null_callback.get());
 
537
}