← Back to branch summary

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

« back to all changes in this revision

Viewing changes to tests/unit-tests/graphics/gbm/test_internal_native_surface.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/graphics/gbm/test_internal_native_surface.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/server/graphics/gbm/internal_native_surface.h"
20
 
#include "mir/graphics/platform.h"
21
 
#include "mir/graphics/platform_ipc_package.h"
22
 
#include "mir/graphics/internal_surface.h"
23
 
 
24
 
#include "mir_toolkit/mesa/native_display.h"
25
 
 
26
 
#include "mir_test/fake_shared.h"
27
 
#include "mir_test_doubles/stub_surface_builder.h"
28
 
#include "mir_test_doubles/mock_frontend_surface.h"
29
 
#include "mir_test_doubles/mock_buffer.h"
30
 
 
31
 
#include <gtest/gtest.h>
32
 
#include <gmock/gmock.h>
33
 
 
34
 
namespace mg = mir::graphics;
35
 
namespace mgg = mir::graphics::gbm;
36
 
namespace mc = mir::compositor;
37
 
namespace msh = mir::shell;
38
 
namespace geom = mir::geometry;
39
 
namespace mt = mir::test;
40
 
namespace mtd = mt::doubles;
41
 
 
42
 
namespace
43
 
{
44
 
class MockInternalSurface : public mg::InternalSurface
45
 
{
46
 
public:
47
 
    MOCK_CONST_METHOD0(size, geom::Size());
48
 
    MOCK_CONST_METHOD0(pixel_format, MirPixelFormat());
49
 
    MOCK_METHOD0(advance_client_buffer, std::shared_ptr<mg::Buffer>());
50
 
};
51
 
 
52
 
struct InternalNativeSurface : public testing::Test
53
 
{
54
 
    void SetUp()
55
 
    {
56
 
        using namespace ::testing;
57
 
        mock_surface = std::make_shared<MockInternalSurface>();
58
 
    }
59
 
 
60
 
    std::shared_ptr<MockInternalSurface> mock_surface;
61
 
};
62
 
 
63
 
MATCHER_P(ParametersHaveSize, size, "")
64
 
{
65
 
    if (static_cast<uint32_t>(arg.width) != size.width.as_uint32_t())
66
 
        return false;
67
 
    if (static_cast<uint32_t>(arg.height) != size.height.as_uint32_t())
68
 
        return false;
69
 
    return true;
70
 
}
71
 
}
72
 
 
73
 
TEST_F(InternalNativeSurface, surface_advance_buffer_packaging)
74
 
{
75
 
    using namespace ::testing;
76
 
    
77
 
    auto buffer = std::make_shared<mtd::MockBuffer>();
78
 
    
79
 
    auto test_buffer_package = std::make_shared<MirBufferPackage>();    
80
 
    test_buffer_package->data_items = 2;
81
 
    test_buffer_package->data[0] = 1;
82
 
    test_buffer_package->data[1] = 2;
83
 
    test_buffer_package->fd_items = 2;
84
 
    test_buffer_package->fd[0] = 3;
85
 
    test_buffer_package->fd[1] = 4;
86
 
    test_buffer_package->stride = 77;
87
 
 
88
 
    mgg::InternalNativeSurface native_surface(mock_surface); 
89
 
    
90
 
    EXPECT_CALL(*buffer, native_buffer_handle())
91
 
        .WillOnce(Return(test_buffer_package)); 
92
 
    EXPECT_CALL(*mock_surface, advance_client_buffer())
93
 
        .Times(1)
94
 
        .WillOnce(Return(buffer));
95
 
 
96
 
    MirBufferPackage buffer_package;
97
 
    memset(&buffer_package, 0, sizeof(MirBufferPackage));
98
 
    native_surface.surface_advance_buffer(&native_surface, &buffer_package);
99
 
 
100
 
    EXPECT_EQ(test_buffer_package->data_items, buffer_package.data_items);
101
 
    EXPECT_EQ(test_buffer_package->data[0], buffer_package.data[0]);
102
 
    EXPECT_EQ(test_buffer_package->data[1], buffer_package.data[1]);
103
 
    EXPECT_EQ(test_buffer_package->fd_items, buffer_package.fd_items);
104
 
    EXPECT_EQ(test_buffer_package->fd[0], buffer_package.fd[0]);
105
 
    EXPECT_EQ(test_buffer_package->fd[1], buffer_package.fd[1]);
106
 
    EXPECT_EQ(test_buffer_package->stride, buffer_package.stride);
107
 
}
108
 
 
109
 
TEST_F(InternalNativeSurface, surface_advance_buffer_secures_resource)
110
 
{
111
 
    using namespace ::testing; 
112
 
    mgg::InternalNativeSurface native_surface(mock_surface); 
113
 
    auto stub_buffer1 = std::make_shared<mtd::MockBuffer>();
114
 
    auto stub_buffer2 = std::make_shared<mtd::MockBuffer>();
115
 
 
116
 
    auto test_buffer_package = std::make_shared<MirBufferPackage>();    
117
 
    EXPECT_CALL(*stub_buffer1, native_buffer_handle())
118
 
        .WillOnce(Return(test_buffer_package)); 
119
 
    EXPECT_CALL(*stub_buffer2, native_buffer_handle())
120
 
        .WillOnce(Return(test_buffer_package)); 
121
 
    EXPECT_CALL(*mock_surface, advance_client_buffer())
122
 
        .Times(2)
123
 
        .WillOnce(Return(stub_buffer1))
124
 
        .WillOnce(Return(stub_buffer2));
125
 
 
126
 
    auto use_count_1 = stub_buffer1.use_count(); 
127
 
    auto use_count_2 = stub_buffer2.use_count();
128
 
    
129
 
    MirBufferPackage buffer_package;
130
 
    native_surface.surface_advance_buffer(&native_surface, &buffer_package);
131
 
    EXPECT_EQ(use_count_1 + 1, stub_buffer1.use_count());
132
 
 
133
 
    native_surface.surface_advance_buffer(&native_surface, &buffer_package);
134
 
    EXPECT_EQ(use_count_1, stub_buffer1.use_count());
135
 
    EXPECT_EQ(use_count_2 + 1, stub_buffer2.use_count());
136
 
}
137
 
 
138
 
TEST_F(InternalNativeSurface, surface_get_parameters)
139
 
{
140
 
    using namespace ::testing;
141
 
 
142
 
    geom::Size const test_surface_size{17, 29};
143
 
    MirPixelFormat const test_pixel_format = mir_pixel_format_xrgb_8888;
144
 
    EXPECT_CALL(*mock_surface, size())
145
 
        .Times(1)
146
 
        .WillOnce(Return(test_surface_size));
147
 
    EXPECT_CALL(*mock_surface, pixel_format())
148
 
        .Times(1)
149
 
        .WillOnce(Return(test_pixel_format));
150
 
 
151
 
    mgg::InternalNativeSurface native_surface(mock_surface); 
152
 
 
153
 
    MirSurfaceParameters parameters;
154
 
    memset(&parameters, 0, sizeof(MirSurfaceParameters));
155
 
    native_surface.surface_get_parameters(&native_surface, &parameters);
156
 
 
157
 
    EXPECT_THAT(parameters, ParametersHaveSize(test_surface_size));
158
 
    EXPECT_EQ(parameters.pixel_format, mir_pixel_format_xrgb_8888);
159
 
    // TODO: What to do about buffer usage besides hardware? ~racarr
160
 
    EXPECT_EQ(parameters.buffer_usage, mir_buffer_usage_hardware);
161
 
}