← Back to branch summary

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

« back to all changes in this revision

Viewing changes to tests/unit-tests/client/gbm/test_gbm_client_buffer.cpp

  • Committer: Package Import Robot
  • Author(s): Ubuntu daily release
  • Date: 2014-01-08 02:04:38 UTC
  • mto: This revision was merged to the branch mainline in revision 58.
  • Revision ID: package-import@ubuntu.com-20140108020438-e1npu0pm7qdv5wc4
Tags: upstream-0.1.3+14.04.20140108
Import upstream version 0.1.3+14.04.20140108

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit-tests/client/gbm/test_gbm_client_buffer.cpp
1
 
/*
2
 
 * Copyright © 2012 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 "mir_toolkit/mir_client_library.h"
20
 
#include "src/client/gbm/gbm_client_buffer.h"
21
 
#include "src/client/gbm/gbm_client_buffer_factory.h"
22
 
#include "mock_drm_fd_handler.h"
23
 
 
24
 
#include <xf86drm.h>
25
 
#include <sys/mman.h>
26
 
#include <gtest/gtest.h>
27
 
 
28
 
#include <stdexcept>
29
 
 
30
 
namespace geom=mir::geometry;
31
 
namespace mclg=mir::client::gbm;
32
 
 
33
 
struct MirGBMBufferTest : public testing::Test
34
 
{
35
 
    void SetUp()
36
 
    {
37
 
        width = geom::Width(12);
38
 
        height =geom::Height(14);
39
 
        stride = geom::Stride(66);
40
 
        pf = geom::PixelFormat::abgr_8888;
41
 
        size = geom::Size{width, height};
42
 
        drm_fd_handler = std::make_shared<testing::NiceMock<mclg::MockDRMFDHandler>>();
43
 
 
44
 
        package = std::make_shared<MirBufferPackage>();
45
 
        package->stride = stride.as_uint32_t();
46
 
        package->width = width.as_int();
47
 
        package->height = height.as_int();
48
 
 
49
 
        package_copy = std::make_shared<MirBufferPackage>(*package.get());
50
 
    }
51
 
    geom::Width width;
52
 
    geom::Height height;
53
 
    geom::Stride stride;
54
 
    geom::PixelFormat pf;
55
 
    geom::Size size;
56
 
 
57
 
    std::shared_ptr<testing::NiceMock<mclg::MockDRMFDHandler>> drm_fd_handler;
58
 
    std::shared_ptr<MirBufferPackage> package;
59
 
    std::shared_ptr<MirBufferPackage> package_copy;
60
 
 
61
 
};
62
 
 
63
 
TEST_F(MirGBMBufferTest, width_and_height)
64
 
{
65
 
    using namespace testing;
66
 
 
67
 
    mclg::GBMClientBuffer buffer(drm_fd_handler, std::move(package), size, pf);
68
 
 
69
 
    EXPECT_EQ(buffer.size().height, height);
70
 
    EXPECT_EQ(buffer.size().width, width);
71
 
    EXPECT_EQ(buffer.pixel_format(), pf);
72
 
}
73
 
 
74
 
TEST_F(MirGBMBufferTest, buffer_returns_correct_stride)
75
 
{
76
 
    using namespace testing;
77
 
 
78
 
    mclg::GBMClientBuffer buffer(drm_fd_handler, std::move(package), size, pf);
79
 
 
80
 
    EXPECT_EQ(buffer.stride(), stride);
81
 
}
82
 
 
83
 
TEST_F(MirGBMBufferTest, buffer_returns_set_package)
84
 
{
85
 
    using namespace testing;
86
 
 
87
 
    mclg::GBMClientBuffer buffer(drm_fd_handler, std::move(package), size, pf);
88
 
 
89
 
    auto package_return = buffer.native_buffer_handle();
90
 
    EXPECT_EQ(package_return->data_items, package_copy->data_items);
91
 
    EXPECT_EQ(package_return->fd_items, package_copy->fd_items);
92
 
    EXPECT_EQ(package_return->stride, package_copy->stride);
93
 
    for (auto i=0; i<mir_buffer_package_max; i++)
94
 
        EXPECT_EQ(package_return->data[i], package_copy->data[i]);
95
 
    for (auto i=0; i<mir_buffer_package_max; i++)
96
 
        EXPECT_EQ(package_return->fd[i], package_copy->fd[i]);
97
 
}
98
 
 
99
 
TEST_F(MirGBMBufferTest, secure_for_cpu_write_maps_drm_buffer)
100
 
{
101
 
    using namespace testing;
102
 
    void *map_addr{reinterpret_cast<void*>(0xabcdef)};
103
 
 
104
 
    EXPECT_CALL(*drm_fd_handler, primeFDToHandle(_,_))
105
 
        .WillOnce(Return(0));
106
 
    EXPECT_CALL(*drm_fd_handler, ioctl(DRM_IOCTL_MODE_MAP_DUMB,_))
107
 
        .WillOnce(Return(0));
108
 
    EXPECT_CALL(*drm_fd_handler, map(_,_))
109
 
        .WillOnce(Return(map_addr));
110
 
    EXPECT_CALL(*drm_fd_handler, unmap(_,_))
111
 
        .Times(1);
112
 
    EXPECT_CALL(*drm_fd_handler, ioctl(DRM_IOCTL_GEM_CLOSE,_))
113
 
        .Times(1);
114
 
 
115
 
    mclg::GBMClientBuffer buffer(drm_fd_handler, std::move(package), size, pf);
116
 
 
117
 
    auto mem_region = buffer.secure_for_cpu_write();
118
 
    ASSERT_EQ(map_addr, mem_region->vaddr.get());
119
 
    ASSERT_EQ(width, mem_region->width);
120
 
    ASSERT_EQ(height, mem_region->height);
121
 
    ASSERT_EQ(stride, mem_region->stride);
122
 
    ASSERT_EQ(pf, mem_region->format);
123
 
}
124
 
 
125
 
TEST_F(MirGBMBufferTest, secure_for_cpu_write_throws_on_prime_handle_failure)
126
 
{
127
 
    using namespace testing;
128
 
 
129
 
    EXPECT_CALL(*drm_fd_handler, primeFDToHandle(_,_))
130
 
        .WillOnce(Return(-1));
131
 
    EXPECT_CALL(*drm_fd_handler, ioctl(DRM_IOCTL_MODE_MAP_DUMB,_))
132
 
        .Times(0);
133
 
    EXPECT_CALL(*drm_fd_handler, map(_,_))
134
 
        .Times(0);
135
 
    EXPECT_CALL(*drm_fd_handler, unmap(_,_))
136
 
        .Times(0);
137
 
    EXPECT_CALL(*drm_fd_handler, ioctl(DRM_IOCTL_GEM_CLOSE,_))
138
 
        .Times(0);
139
 
 
140
 
    mclg::GBMClientBuffer buffer(drm_fd_handler, std::move(package), size, pf);
141
 
 
142
 
    EXPECT_THROW({
143
 
        buffer.secure_for_cpu_write();
144
 
    }, std::runtime_error);
145
 
}
146
 
 
147
 
TEST_F(MirGBMBufferTest, secure_for_cpu_write_throws_on_map_dumb_failure)
148
 
{
149
 
    using namespace testing;
150
 
 
151
 
    EXPECT_CALL(*drm_fd_handler, primeFDToHandle(_,_))
152
 
        .WillOnce(Return(0));
153
 
    EXPECT_CALL(*drm_fd_handler, ioctl(DRM_IOCTL_MODE_MAP_DUMB,_))
154
 
        .WillOnce(Return(1));
155
 
    EXPECT_CALL(*drm_fd_handler, map(_,_))
156
 
        .Times(0);
157
 
    EXPECT_CALL(*drm_fd_handler, unmap(_,_))
158
 
        .Times(0);
159
 
    EXPECT_CALL(*drm_fd_handler, ioctl(DRM_IOCTL_GEM_CLOSE,_))
160
 
        .Times(1);
161
 
 
162
 
    mclg::GBMClientBuffer buffer(drm_fd_handler, std::move(package), size, pf);
163
 
 
164
 
    EXPECT_THROW({
165
 
        auto mem_region = buffer.secure_for_cpu_write();
166
 
    }, std::runtime_error);
167
 
}
168
 
 
169
 
TEST_F(MirGBMBufferTest, secure_for_cpu_write_throws_on_map_failure)
170
 
{
171
 
    using namespace testing;
172
 
 
173
 
    EXPECT_CALL(*drm_fd_handler, primeFDToHandle(_,_))
174
 
        .WillOnce(Return(0));
175
 
    EXPECT_CALL(*drm_fd_handler, ioctl(DRM_IOCTL_MODE_MAP_DUMB,_))
176
 
        .WillOnce(Return(0));
177
 
    EXPECT_CALL(*drm_fd_handler, map(_,_))
178
 
        .WillOnce(Return(MAP_FAILED));
179
 
    EXPECT_CALL(*drm_fd_handler, unmap(_,_))
180
 
        .Times(0);
181
 
    EXPECT_CALL(*drm_fd_handler, ioctl(DRM_IOCTL_GEM_CLOSE,_))
182
 
        .Times(1);
183
 
 
184
 
    mclg::GBMClientBuffer buffer(drm_fd_handler, std::move(package), size, pf);
185
 
 
186
 
    EXPECT_THROW({
187
 
        auto mem_region = buffer.secure_for_cpu_write();
188
 
    }, std::runtime_error);
189
 
}
190
 
 
191
 
TEST_F(MirGBMBufferTest, prime_fd_closed_on_buffer_destruction)
192
 
{
193
 
    using namespace testing;
194
 
 
195
 
    int const prime_fd{42};
196
 
 
197
 
    package->fd[0] = prime_fd;
198
 
    package->fd_items = 1;
199
 
 
200
 
    EXPECT_CALL(*drm_fd_handler, close(prime_fd))
201
 
        .Times(1);
202
 
 
203
 
    mclg::GBMClientBuffer buffer(drm_fd_handler, package, size, pf);
204
 
}
205
 
 
206
 
TEST_F(MirGBMBufferTest, buffer_does_not_take_a_gem_reference_when_not_mapping)
207
 
{
208
 
    using namespace testing;
209
 
 
210
 
    // We don't map the buffer, so we don't need to take a GEM reference...
211
 
    EXPECT_CALL(*drm_fd_handler, primeFDToHandle(_,_))
212
 
        .Times(0);
213
 
    // We haven't taken a GEM reference, so we shouldn't close it.
214
 
    EXPECT_CALL(*drm_fd_handler, ioctl(DRM_IOCTL_GEM_CLOSE,_))
215
 
        .Times(0);
216
 
 
217
 
    mclg::GBMClientBuffer buffer(drm_fd_handler, package, size, pf);
218
 
}
219
 
 
220
 
TEST_F(MirGBMBufferTest, factory_gets_size_from_package)
221
 
{
222
 
    using namespace testing;
223
 
 
224
 
    mclg::GBMClientBufferFactory factory(drm_fd_handler);
225
 
 
226
 
    geom::Size unused_size{0, 0};
227
 
    auto buffer = factory.create_buffer(package, unused_size, pf);
228
 
 
229
 
    auto const& buf_size = buffer->size();
230
 
    EXPECT_EQ(package->width, buf_size.width.as_int());
231
 
    EXPECT_EQ(package->height, buf_size.height.as_int());
232
 
 
233
 
    EXPECT_NE(unused_size, buf_size);
234
 
}
235