← Back to branch summary

~mir-team/mir/trunk

« back to all changes in this revision

Viewing changes to tests/unit-tests/shell/test_session_manager.cpp

  • Committer: Tarmac
  • Author(s): Alan Griffiths
  • Date: 2013-04-25 23:50:01 UTC
  • mfrom: (526.2.22 mir1)
  • Revision ID: tarmac-20130425235001-c3b3x2yyb3eldyx1
frontend, shell, tests: surface-states updated to avoid supplying dependencies through public member functions.

Approved by PS Jenkins bot, Chris Halse Rogers, Robert Ancell, Kevin DuBois.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit-tests/shell/test_session_manager.cpp
41
41
#include <gtest/gtest.h>
42
42
 
43
43
namespace mc = mir::compositor;
 
44
namespace me = mir::events;
44
45
namespace mf = mir::frontend;
45
46
namespace msh = mir::shell;
46
47
namespace ms = mir::surfaces;
101
102
 
102
103
    EXPECT_CALL(focus_sequence, default_focus()).WillOnce(Return((std::shared_ptr<msh::Session>())));
103
104
 
104
 
    auto session = session_manager.open_session("Visual Basic Studio");
 
105
    auto session = session_manager.open_session("Visual Basic Studio", std::shared_ptr<me::EventSink>());
105
106
    session_manager.close_session(session);
106
107
}
107
108
 
109
110
{
110
111
    using namespace ::testing;
111
112
 
112
 
    EXPECT_CALL(surface_factory, create_surface(_)).Times(1);
 
113
    EXPECT_CALL(surface_factory, create_surface(_, _, _)).Times(1);
113
114
 
114
115
    std::shared_ptr<mi::InputChannel> null_input_channel;
115
 
    ON_CALL(surface_factory, create_surface(_)).WillByDefault(
 
116
    ON_CALL(surface_factory, create_surface(_, _, _)).WillByDefault(
116
117
       Return(std::make_shared<msh::Surface>(
117
118
           mt::fake_shared(surface_builder),
118
119
           mf::a_surface(),
126
127
 
127
128
    EXPECT_CALL(focus_sequence, default_focus()).WillOnce(Return((std::shared_ptr<msh::Session>())));
128
129
 
129
 
    auto session = session_manager.open_session("Visual Basic Studio");
 
130
    auto session = session_manager.open_session("Visual Basic Studio", std::shared_ptr<me::EventSink>());
130
131
    session->create_surface(mf::a_surface().of_size(geom::Size{geom::Width{1024}, geom::Height{768}}));
131
132
 
132
133
    session_manager.close_session(session);
140
141
    EXPECT_CALL(container, insert_session(_)).Times(1);
141
142
    EXPECT_CALL(focus_setter, set_focus_to(_)).WillOnce(SaveArg<0>(&new_session));
142
143
 
143
 
    auto session = session_manager.open_session("Visual Basic Studio");
 
144
    auto session = session_manager.open_session("Visual Basic Studio", std::shared_ptr<me::EventSink>());
144
145
    EXPECT_EQ(session, new_session);
145
146
}
146
147
 
148
149
{
149
150
    using namespace ::testing;
150
151
 
151
 
    auto session1 = session_manager.open_session("Visual Basic Studio");
152
 
    auto session2 = session_manager.open_session("IntelliJ IDEA");
 
152
    auto session1 = session_manager.open_session("Visual Basic Studio", std::shared_ptr<me::EventSink>());
 
153
    auto session2 = session_manager.open_session("IntelliJ IDEA", std::shared_ptr<me::EventSink>());
153
154
 
154
155
    session_manager.tag_session_with_lightdm_id(session1, 1);
155
156
 
161
162
{
162
163
    using namespace ::testing;
163
164
 
164
 
    auto session1 = session_manager.open_session("Visual Basic Studio");
165
 
    auto session2 = session_manager.open_session("IntelliJ IDEA");
 
165
    auto session1 = session_manager.open_session("Visual Basic Studio", std::shared_ptr<me::EventSink>());
 
166
    auto session2 = session_manager.open_session("IntelliJ IDEA", std::shared_ptr<me::EventSink>());
166
167
 
167
168
    auto shell_session1 = std::dynamic_pointer_cast<msh::Session>(session1);
168
169
    auto shell_session2 = std::dynamic_pointer_cast<msh::Session>(session2);
180
181
{
181
182
    using namespace ::testing;
182
183
    std::shared_ptr<mi::InputChannel> null_input_channel;
183
 
    ON_CALL(surface_factory, create_surface(_)).WillByDefault(
 
184
    ON_CALL(surface_factory, create_surface(_, _, _)).WillByDefault(
184
185
        Return(std::make_shared<msh::Surface>(
185
186
            mt::fake_shared(surface_builder),
186
187
            mf::a_surface(),
191
192
        InSequence seq;
192
193
 
193
194
        EXPECT_CALL(focus_setter, set_focus_to(_)).Times(1); // Session creation
194
 
        EXPECT_CALL(surface_factory, create_surface(_)).Times(1);
 
195
        EXPECT_CALL(surface_factory, create_surface(_, _, _)).Times(1);
195
196
        EXPECT_CALL(focus_setter, set_focus_to(_)).Times(1); // Post Surface creation
196
197
    }
197
198
 
198
 
    auto session1 = session_manager.open_session("Weather Report");
 
199
    auto session1 = session_manager.open_session("Weather Report", std::shared_ptr<me::EventSink>());
199
200
    session_manager.create_surface_for(session1, mf::a_surface());
200
201
}
201
202
 
230
231
    using namespace ::testing;
231
232
 
232
233
    std::shared_ptr<mi::InputChannel> null_input_channel;
233
 
    ON_CALL(surface_factory, create_surface(_)).WillByDefault(
 
234
    ON_CALL(surface_factory, create_surface(_,_,_)).WillByDefault(
234
235
       Return(std::make_shared<msh::Surface>(
235
236
           mt::fake_shared(surface_builder),
236
237
           mf::a_surface(),
237
238
           null_input_channel)));
238
 
    EXPECT_CALL(surface_factory, create_surface(_)).Times(1);
 
239
    EXPECT_CALL(surface_factory, create_surface(_,_,_)).Times(1);
239
240
 
240
241
    EXPECT_CALL(focus_sequence, default_focus()).WillOnce(Return((std::shared_ptr<msh::Session>())));
241
242
    {
252
253
    }
253
254
 
254
255
    {
255
 
        auto session = session_manager.open_session("test");
 
256
        auto session = session_manager.open_session("test", std::shared_ptr<me::EventSink>());
256
257
        auto surf = session_manager.create_surface_for(session, mf::a_surface());
257
258
        session->destroy_surface(surf);
258
259
        session_manager.close_session(session);