← Back to branch summary

~andreas-pokorny/mir/use-ld-preload-in-test-script

« back to all changes in this revision

Viewing changes to tests/unit-tests/client/test_client_surface_interpreter.cpp

  • Committer: Daniel van Vugt
  • Date: 2013-03-13 04:54:15 UTC
  • mfrom: (493 trunk)
  • mto: This revision was merged to the branch mainline in revision 526.
  • Revision ID: daniel.van.vugt@canonical.com-20130313045415-7hi608meaybiafx0
Merge latest lp:mir

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit-tests/client/test_client_surface_interpreter.cpp
 
1
/*
 
2
 * Copyright © 2013 Canonical Ltd.
 
3
 *
 
4
 * This program is free software: you can redistribute it and/or modify
 
5
 * it under the terms of the GNU General Public License version 3 as
 
6
 * published by the Free Software Foundation.
 
7
 *
 
8
 * This program is distributed in the hope that it will be useful,
 
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
 * GNU General Public License for more details.
 
12
 *
 
13
 * You should have received a copy of the GNU General Public License
 
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
15
 *
 
16
 * Authored by: Kevin DuBois <kevin.dubois@canonical.com>
 
17
 */
 
18
 
 
19
#include "src/client/mir_client_surface.h"
 
20
#include "src/client/client_buffer.h"
 
21
#include "src/client/android/client_surface_interpreter.h"
 
22
#include <system/window.h>
 
23
#include <gmock/gmock.h>
 
24
#include <gtest/gtest.h>
 
25
 
 
26
namespace mcl=mir::client;
 
27
namespace mcla=mir::client::android;
 
28
namespace geom=mir::geometry;
 
29
 
 
30
namespace
 
31
{
 
32
struct MockClientBuffer : public mcl::ClientBuffer
 
33
{
 
34
    MockClientBuffer()
 
35
    {
 
36
        using namespace testing;
 
37
        ON_CALL(*this, get_native_handle())
 
38
            .WillByDefault(Return(&buffer));
 
39
    }
 
40
    MOCK_METHOD0(secure_for_cpu_write, std::shared_ptr<mcl::MemoryRegion>());
 
41
    MOCK_CONST_METHOD0(size, geom::Size());
 
42
    MOCK_CONST_METHOD0(stride, geom::Stride());
 
43
    MOCK_CONST_METHOD0(pixel_format, geom::PixelFormat());
 
44
 
 
45
    MOCK_CONST_METHOD0(get_buffer_package, std::shared_ptr<MirBufferPackage>());
 
46
    MOCK_METHOD0(get_native_handle, ANativeWindowBuffer*());
 
47
 
 
48
    ANativeWindowBuffer buffer;
 
49
    native_handle_t handle;
 
50
};
 
51
 
 
52
struct MockMirSurface : public mcl::ClientSurface
 
53
{
 
54
    MockMirSurface(MirSurfaceParameters params)
 
55
     : params(params)
 
56
    {
 
57
        using namespace testing;
 
58
        ON_CALL(*this, get_parameters())
 
59
            .WillByDefault(Return(params));
 
60
        ON_CALL(*this, get_current_buffer())
 
61
            .WillByDefault(Return(
 
62
                std::make_shared<NiceMock<MockClientBuffer>>()));
 
63
    }
 
64
 
 
65
    MOCK_CONST_METHOD0(get_parameters, MirSurfaceParameters());
 
66
    MOCK_METHOD0(get_current_buffer, std::shared_ptr<mcl::ClientBuffer>());
 
67
    MOCK_METHOD2(next_buffer, MirWaitHandle*(mir_surface_lifecycle_callback callback, void * context));
 
68
 
 
69
    MirSurfaceParameters params;
 
70
};
 
71
}
 
72
 
 
73
class AndroidInterpreterTest : public ::testing::Test
 
74
{
 
75
protected:
 
76
    virtual void SetUp()
 
77
    {
 
78
        using namespace testing;
 
79
        surf_params.width = 530;
 
80
        surf_params.height = 715;
 
81
        surf_params.pixel_format = mir_pixel_format_abgr_8888;
 
82
 
 
83
        mock_client_buffer = std::make_shared<NiceMock<MockClientBuffer>>();
 
84
    }
 
85
 
 
86
    MirSurfaceParameters surf_params;
 
87
    std::shared_ptr<MockClientBuffer> mock_client_buffer;
 
88
};
 
89
 
 
90
TEST_F(AndroidInterpreterTest, native_window_dequeue_calls_surface_get_current)
 
91
{
 
92
    using namespace testing;
 
93
    MockMirSurface mock_surface{surf_params};
 
94
    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
 
95
 
 
96
    EXPECT_CALL(mock_surface, get_current_buffer())
 
97
        .Times(1)
 
98
        .WillOnce(Return(mock_client_buffer));
 
99
 
 
100
    interpreter.driver_requests_buffer();
 
101
}
 
102
 
 
103
TEST_F(AndroidInterpreterTest, native_window_dequeue_gets_native_handle_from_returned_buffer)
 
104
{
 
105
    using namespace testing;
 
106
    native_handle_t handle;
 
107
    ANativeWindowBuffer buffer;
 
108
    buffer.handle = &handle;
 
109
 
 
110
    MockMirSurface mock_surface{surf_params};
 
111
    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
 
112
 
 
113
    EXPECT_CALL(*mock_client_buffer, get_native_handle())
 
114
        .Times(1)
 
115
        .WillOnce(Return(&buffer));
 
116
    EXPECT_CALL(mock_surface, get_current_buffer())
 
117
        .Times(1)
 
118
        .WillOnce(Return(mock_client_buffer));
 
119
 
 
120
    auto returned_buffer = interpreter.driver_requests_buffer();
 
121
    EXPECT_EQ(&buffer, returned_buffer);
 
122
}
 
123
 
 
124
TEST_F(AndroidInterpreterTest, native_window_queue_advances_buffer)
 
125
{
 
126
    using namespace testing;
 
127
    ANativeWindowBuffer buffer;
 
128
    int fence_fd = -1;
 
129
 
 
130
    MockMirSurface mock_surface{surf_params};
 
131
    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
 
132
 
 
133
    EXPECT_CALL(mock_surface, next_buffer(_,_))
 
134
        .Times(1);
 
135
 
 
136
    interpreter.driver_returns_buffer(&buffer, fence_fd);
 
137
}
 
138
 
 
139
/* format is an int that is set by the driver. these are not the HAL_PIXEL_FORMATS in android */
 
140
TEST_F(AndroidInterpreterTest, native_window_perform_remembers_format)
 
141
{
 
142
    int format = 945;
 
143
    MockMirSurface mock_surface{surf_params};
 
144
    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
 
145
 
 
146
    interpreter.dispatch_driver_request_format(format);
 
147
    auto tmp_format = interpreter.driver_requests_info(NATIVE_WINDOW_FORMAT);
 
148
 
 
149
    EXPECT_EQ(format, tmp_format);
 
150
}
 
151
 
 
152
TEST_F(AndroidInterpreterTest, native_window_hint_query_hook)
 
153
{
 
154
    MockMirSurface mock_surface{surf_params};
 
155
    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
 
156
    /* transform hint is a bitmask of a few options for rotation/flipping buffer. a value
 
157
       of zero is no transform */
 
158
    int transform_hint_zero = 0;
 
159
    auto transform = interpreter.driver_requests_info(NATIVE_WINDOW_TRANSFORM_HINT);
 
160
 
 
161
    EXPECT_EQ(transform_hint_zero, transform);
 
162
}
 
163
 
 
164
TEST_F(AndroidInterpreterTest, native_window_default_width_query_hook)
 
165
{
 
166
    MockMirSurface mock_surface{surf_params};
 
167
    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
 
168
 
 
169
    auto default_width = interpreter.driver_requests_info(NATIVE_WINDOW_DEFAULT_WIDTH);
 
170
 
 
171
    EXPECT_EQ(surf_params.width, default_width);
 
172
}
 
173
 
 
174
TEST_F(AndroidInterpreterTest, native_window_default_height_query_hook)
 
175
{
 
176
    MockMirSurface mock_surface{surf_params};
 
177
    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
 
178
 
 
179
    auto default_height = interpreter.driver_requests_info(NATIVE_WINDOW_DEFAULT_HEIGHT);
 
180
 
 
181
    EXPECT_EQ(surf_params.height, default_height);
 
182
}
 
183
 
 
184
TEST_F(AndroidInterpreterTest, native_window_width_query_hook)
 
185
{
 
186
    MockMirSurface mock_surface{surf_params};
 
187
    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
 
188
 
 
189
    auto width = interpreter.driver_requests_info(NATIVE_WINDOW_WIDTH);
 
190
 
 
191
    EXPECT_EQ(surf_params.width, width);
 
192
}
 
193
 
 
194
TEST_F(AndroidInterpreterTest, native_window_height_query_hook)
 
195
{
 
196
    MockMirSurface mock_surface{surf_params};
 
197
    mcla::ClientSurfaceInterpreter interpreter(mock_surface);
 
198
 
 
199
    auto height = interpreter.driver_requests_info(NATIVE_WINDOW_HEIGHT);
 
200
 
 
201
    EXPECT_EQ(surf_params.height, height);
 
202
}