← Back to branch summary

~ubuntu-branches/ubuntu/wily/mir/wily-proposed

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): CI Train Bot
  • Date: 2015-05-12 13:12:55 UTC
  • mto: This revision was merged to the branch mainline in revision 96.
  • Revision ID: package-import@ubuntu.com-20150512131255-y7z12i8n4pbvo70x
Tags: upstream-0.13.0+15.10.20150512
Import upstream version 0.13.0+15.10.20150512

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit-tests/frontend/test_event_sender.cpp
16
16
 * Authored by: Kevin DuBois <kevin.dubois@canonical.com>
17
17
 */
18
18
 
19
 
#define MIR_INCLUDE_DEPRECATED_EVENT_HEADER
 
19
#include "mir_protobuf.pb.h"
 
20
#include "mir_protobuf_wire.pb.h"
20
21
 
21
22
#include "src/server/frontend/message_sender.h"
22
23
#include "src/server/frontend/event_sender.h"
23
 
#include "mir_test_doubles/stub_display_configuration.h"
 
24
 
 
25
#include "mir/events/event_builders.h"
 
26
 
24
27
#include "mir_test/display_config_matchers.h"
25
28
#include "mir_test/fake_shared.h"
 
29
#include "mir_test_doubles/stub_display_configuration.h"
26
30
 
27
 
#include "mir_protobuf.pb.h"
28
 
#include "mir_protobuf_wire.pb.h"
29
31
#include <gtest/gtest.h>
30
32
#include <gmock/gmock.h>
31
33
 
32
 
namespace mt=mir::test;
33
 
namespace mtd=mir::test::doubles;
34
 
namespace mf=mir::frontend;
35
 
namespace mfd=mf::detail;
36
 
namespace geom=mir::geometry;
 
34
namespace mt = mir::test;
 
35
namespace mtd = mir::test::doubles;
 
36
namespace mf = mir::frontend;
 
37
namespace mfd = mf::detail;
 
38
namespace mev = mir::events;
 
39
namespace geom = mir::geometry;
37
40
 
38
41
namespace
39
42
{
41
44
{
42
45
    MOCK_METHOD3(send, void(char const*, size_t, mfd::FdSets const&));
43
46
};
 
47
struct EventSender : public testing::Test
 
48
{
 
49
    EventSender()
 
50
        : event_sender(mt::fake_shared(mock_msg_sender))
 
51
    {
 
52
    }
 
53
    MockMsgSender mock_msg_sender;
 
54
    mfd::EventSender event_sender;
 
55
};
44
56
}
45
57
 
46
 
TEST(TestEventSender, display_send)
 
58
TEST_F(EventSender, display_send)
47
59
{
48
60
    using namespace testing;
49
61
 
50
62
    mtd::StubDisplayConfig config;
51
 
    MockMsgSender mock_msg_sender;
52
63
 
53
64
    auto msg_validator = [&config](char const* data, size_t len){
54
65
        mir::protobuf::wire::Result wire;
63
74
        .Times(1)
64
75
        .WillOnce(WithArgs<0,1>(Invoke(msg_validator)));
65
76
 
66
 
    mfd::EventSender sender(mt::fake_shared(mock_msg_sender));
67
 
 
68
 
    sender.handle_display_config_change(config);
 
77
    event_sender.handle_display_config_change(config);
69
78
}
70
79
 
71
 
TEST(TestEventSender, sends_noninput_events)
 
80
TEST_F(EventSender, sends_noninput_events)
72
81
{
73
82
    using namespace testing;
74
83
 
75
 
    auto msg_sender = std::make_shared<MockMsgSender>();
76
 
    mfd::EventSender event_sender(msg_sender);
77
 
 
78
 
    MirEvent event;
79
 
    memset(&event, 0, sizeof event);
80
 
 
81
 
    EXPECT_CALL(*msg_sender, send(_, _, _))
 
84
    auto surface_ev = mev::make_event(mf::SurfaceId{1}, mir_surface_attrib_focus, mir_surface_focused);
 
85
    auto resize_ev = mev::make_event(mf::SurfaceId{1}, {10, 10});
 
86
 
 
87
    EXPECT_CALL(mock_msg_sender, send(_, _, _))
82
88
        .Times(2);
83
 
    event.type = mir_event_type_surface;
84
 
    event_sender.handle_event(event);
85
 
    event.type = mir_event_type_resize;
86
 
    event_sender.handle_event(event);
 
89
    event_sender.handle_event(*surface_ev);
 
90
    event_sender.handle_event(*resize_ev);
87
91
}
88
92
 
89
 
TEST(TestEventSender, never_sends_input_events)
 
93
TEST_F(EventSender, never_sends_input_events)
90
94
{
91
95
    using namespace testing;
92
96
 
93
 
    auto msg_sender = std::make_shared<MockMsgSender>();
94
 
    mfd::EventSender event_sender(msg_sender);
95
 
 
96
 
    MirEvent event;
97
 
    memset(&event, 0, sizeof event);
98
 
 
99
 
    EXPECT_CALL(*msg_sender, send(_, _, _))
 
97
    auto ev = mev::make_event(MirInputDeviceId(), 0, MirKeyboardAction(),
 
98
                              0, 0, MirInputEventModifiers());
 
99
 
 
100
    EXPECT_CALL(mock_msg_sender, send(_, _, _))
100
101
        .Times(0);
101
 
    event.type = mir_event_type_key;
102
 
    event_sender.handle_event(event);
103
 
    event.type = mir_event_type_motion;
104
 
    event_sender.handle_event(event);
 
102
    event_sender.handle_event(*ev);
105
103
}