← Back to branch summary

~vanvugt/mir/frontend-server

« back to all changes in this revision

Viewing changes to tests/unit-tests/scene/test_surface_controller.cpp

  • Committer: Daniel van Vugt
  • Date: 2014-04-15 03:51:25 UTC
  • mfrom: (1416.1.134 development-branch)
  • Revision ID: daniel.van.vugt@canonical.com-20140415035125-qvrycnzs1b86qgc7
Merge latest development-branch and fix conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit-tests/scene/test_surface_controller.cpp
19
19
#include "src/server/scene/surface_controller.h"
20
20
#include "src/server/scene/surface_stack_model.h"
21
21
#include "mir/scene/surface_factory.h"
22
 
#include "mir/shell/surface_creation_parameters.h"
 
22
#include "mir/scene/placement_strategy.h"
 
23
#include "mir/scene/surface_creation_parameters.h"
 
24
#include "mir_test_doubles/stub_scene_session.h"
23
25
 
24
26
#include "mir_test_doubles/mock_surface.h"
25
27
#include "mir_test/fake_shared.h"
27
29
#include <gtest/gtest.h>
28
30
#include <gmock/gmock.h>
29
31
 
 
32
namespace geom = mir::geometry;
30
33
namespace mf = mir::frontend;
31
34
namespace msh = mir::shell;
32
35
namespace ms = mir::scene;
38
41
struct MockSurfaceAllocator : public ms::SurfaceFactory
39
42
{
40
43
    MOCK_METHOD1(create_surface, std::shared_ptr<ms::Surface>(
41
 
        msh::SurfaceCreationParameters const&));
 
44
        ms::SurfaceCreationParameters const&));
 
45
};
 
46
 
 
47
struct MockPlacementStrategy : public ms::PlacementStrategy
 
48
{
 
49
    MOCK_METHOD2(place, ms::SurfaceCreationParameters(ms::Session const&, ms::SurfaceCreationParameters const&));
42
50
};
43
51
 
44
52
struct MockSurfaceStackModel : public ms::SurfaceStackModel
50
58
    MOCK_METHOD1(remove_surface, void(std::weak_ptr<ms::Surface> const&));
51
59
    MOCK_METHOD1(raise, void(std::weak_ptr<ms::Surface> const&));
52
60
};
53
 
}
54
61
 
55
 
TEST(SurfaceController, add_and_remove_surface)
 
62
struct SurfaceController : testing::Test
56
63
{
57
 
    using namespace ::testing;
58
 
 
 
64
    MockPlacementStrategy placement_strategy;
59
65
    mtd::MockSurface mock_surface;
60
66
    std::shared_ptr<ms::Surface> const expect_surface = mt::fake_shared(mock_surface);
61
 
    auto const surface = std::make_shared<mtd::MockSurface>();
62
67
    testing::NiceMock<MockSurfaceAllocator> mock_surface_allocator;
63
68
    MockSurfaceStackModel model;
64
 
 
65
 
    ms::SurfaceController controller(mt::fake_shared(mock_surface_allocator), mt::fake_shared(model));
 
69
    mtd::StubSceneSession session;
 
70
    std::shared_ptr<ms::SurfaceObserver> observer;
 
71
 
 
72
    void SetUp()
 
73
    {
 
74
        using namespace ::testing;
 
75
        ON_CALL(mock_surface_allocator, create_surface(_)).WillByDefault(Return(expect_surface));
 
76
        ON_CALL(placement_strategy, place(_, _)).WillByDefault(ReturnArg<1>());
 
77
    }
 
78
};
 
79
}
 
80
 
 
81
TEST_F(SurfaceController, add_and_remove_surface)
 
82
{
 
83
    using namespace ::testing;
 
84
 
 
85
    ms::SurfaceController controller(
 
86
        mt::fake_shared(mock_surface_allocator),
 
87
        mt::fake_shared(placement_strategy),
 
88
        mt::fake_shared(model));
66
89
 
67
90
    InSequence seq;
 
91
    EXPECT_CALL(placement_strategy, place(_, _)).Times(1);
68
92
    EXPECT_CALL(mock_surface_allocator, create_surface(_)).Times(1).WillOnce(Return(expect_surface));
69
93
    EXPECT_CALL(mock_surface, add_observer(_)).Times(1);
70
94
    EXPECT_CALL(model, add_surface(_,_,_)).Times(1);
71
95
    EXPECT_CALL(model, remove_surface(_)).Times(1);
72
96
 
73
 
    auto actual_surface = controller.add_surface(msh::a_surface(), std::shared_ptr<ms::SurfaceObserver>());
 
97
    auto actual_surface = controller.add_surface(ms::a_surface(), &session, observer);
74
98
 
75
99
    EXPECT_THAT(actual_surface, Eq(expect_surface));
76
100
    controller.remove_surface(actual_surface);
77
101
}
78
102
 
79
 
TEST(SurfaceController, raise_surface)
 
103
TEST_F(SurfaceController, raise_surface)
80
104
{
81
105
    using namespace ::testing;
82
106
 
83
 
    testing::NiceMock<MockSurfaceAllocator> mock_surface_allocator;
84
 
    MockSurfaceStackModel model;
85
 
 
86
 
    ms::SurfaceController controller(mt::fake_shared(mock_surface_allocator), mt::fake_shared(model));
 
107
    ms::SurfaceController controller(
 
108
        mt::fake_shared(mock_surface_allocator),
 
109
        mt::fake_shared(placement_strategy),
 
110
        mt::fake_shared(model));
87
111
 
88
112
    EXPECT_CALL(model, raise(_)).Times(1);
89
113
 
90
114
    controller.raise(std::weak_ptr<ms::Surface>());
91
115
}
 
116
 
 
117
TEST_F(SurfaceController, offers_create_surface_parameters_to_placement_strategy)
 
118
{
 
119
    using namespace ::testing;
 
120
    EXPECT_CALL(mock_surface, add_observer(_)).Times(AnyNumber());
 
121
    EXPECT_CALL(model, add_surface(_,_,_)).Times(AnyNumber());
 
122
 
 
123
    ms::SurfaceController controller(
 
124
        mt::fake_shared(mock_surface_allocator),
 
125
        mt::fake_shared(placement_strategy),
 
126
        mt::fake_shared(model));
 
127
 
 
128
    auto params = ms::a_surface();
 
129
    EXPECT_CALL(placement_strategy, place(Ref(session), Ref(params))).Times(1)
 
130
        .WillOnce(Return(ms::a_surface()));
 
131
 
 
132
    controller.add_surface(params, &session, observer);
 
133
}
 
134
 
 
135
TEST_F(SurfaceController, forwards_create_surface_parameters_from_placement_strategy_to_underlying_factory)
 
136
{
 
137
    using namespace ::testing;
 
138
    EXPECT_CALL(mock_surface, add_observer(_)).Times(AnyNumber());
 
139
    EXPECT_CALL(model, add_surface(_,_,_)).Times(AnyNumber());
 
140
 
 
141
    ms::SurfaceController controller(
 
142
        mt::fake_shared(mock_surface_allocator),
 
143
        mt::fake_shared(placement_strategy),
 
144
        mt::fake_shared(model));
 
145
 
 
146
    auto params = ms::a_surface();
 
147
    auto placed_params = params;
 
148
    placed_params.size.width = geom::Width{100};
 
149
 
 
150
    EXPECT_CALL(placement_strategy, place(_, Ref(params))).Times(1)
 
151
        .WillOnce(Return(placed_params));
 
152
    EXPECT_CALL(mock_surface_allocator, create_surface(placed_params));
 
153
 
 
154
    controller.add_surface(params, &session, observer);
 
155
}