← Back to branch summary

~andreas-pokorny/mir/libinput-integration

« back to all changes in this revision

Viewing changes to tests/unit-tests/graphics/android/test_fb_simple_swapper.cpp

  • Committer: Andreas Pokorny
  • Date: 2015-01-16 08:46:11 UTC
  • mfrom: (2098.1.21 evdev-input-platform)
  • Revision ID: andreas.pokorny@canonical.com-20150116084611-x06398gryu87ojeh
merged prereq

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit-tests/graphics/android/test_fb_simple_swapper.cpp
19
19
#include "src/platforms/android/framebuffers.h"
20
20
#include "src/platforms/android/graphic_buffer_allocator.h"
21
21
#include "mir_test_doubles/mock_buffer.h"
22
 
#include "mir_test_doubles/mock_egl.h"
23
 
#include "mir_test_doubles/mock_fb_hal_device.h"
24
22
 
25
23
#include <future>
26
24
#include <initializer_list>
42
40
        geom::Size, MirPixelFormat, mga::BufferUsage use));
43
41
};
44
42
 
45
 
static int const display_width = 180;
46
 
static int const display_height = 1010101;
47
 
 
48
43
class PostingFBBundleTest : public ::testing::Test
49
44
{
50
45
public:
51
46
    virtual void SetUp()
52
47
    {
53
48
        using namespace testing;
54
 
        fbnum = 2;
55
 
        format = HAL_PIXEL_FORMAT_RGBA_8888;
56
49
        buffer1 = std::make_shared<mtd::MockBuffer>();
57
50
        buffer2 = std::make_shared<mtd::MockBuffer>();
58
51
        buffer3 = std::make_shared<mtd::MockBuffer>();
59
 
        mock_allocator = std::make_shared<MockGraphicBufferAllocator>();
60
 
        mock_fb_hal = std::make_shared<mtd::MockFBHalDevice>(display_width, display_height, format, fbnum);
61
 
        EXPECT_CALL(*mock_allocator, alloc_buffer_platform(_,_,_))
 
52
        EXPECT_CALL(mock_allocator, alloc_buffer_platform(_,_,_))
62
53
            .Times(AtLeast(0))
63
54
            .WillOnce(Return(buffer1))
64
55
            .WillOnce(Return(buffer2))
65
56
            .WillRepeatedly(Return(buffer3));
66
57
    }
67
58
 
68
 
    int format;
69
 
    int fbnum;
 
59
    MirPixelFormat format{mir_pixel_format_abgr_8888};
70
60
    double vrefresh_hz{55.330};
71
 
    std::shared_ptr<mtd::MockFBHalDevice> mock_fb_hal;
72
 
    std::shared_ptr<MockGraphicBufferAllocator> mock_allocator;
 
61
    MockGraphicBufferAllocator mock_allocator;
73
62
    std::shared_ptr<mg::Buffer> buffer1;
74
63
    std::shared_ptr<mg::Buffer> buffer2;
75
64
    std::shared_ptr<mg::Buffer> buffer3;
76
 
    geom::Size display_size{display_width, display_height};
77
 
    testing::NiceMock<mtd::MockEGL> mock_egl;
 
65
    geom::Size display_size{180, 222};
78
66
};
79
 
 
80
67
}
81
68
 
82
69
TEST_F(PostingFBBundleTest, hwc_fb_size_allocation)
83
70
{
84
71
    using namespace testing;
85
72
 
86
 
    EXPECT_CALL(*mock_allocator, alloc_buffer_platform(display_size, _, mga::BufferUsage::use_framebuffer_gles))
 
73
    EXPECT_CALL(mock_allocator, alloc_buffer_platform(display_size, _, mga::BufferUsage::use_framebuffer_gles))
87
74
        .Times(2)
88
75
        .WillRepeatedly(Return(nullptr));
89
76
 
90
 
    mga::Framebuffers framebuffers(mock_allocator, display_size, vrefresh_hz, 2u);
 
77
    mga::Framebuffers framebuffers(mock_allocator, display_size, format, vrefresh_hz, 2u);
91
78
    EXPECT_EQ(display_size, framebuffers.fb_size());
92
79
    EXPECT_EQ(vrefresh_hz, framebuffers.fb_refresh_rate());
93
80
}
94
81
 
95
 
TEST_F(PostingFBBundleTest, hwc_fb_format_selection)
96
 
{
97
 
    using namespace testing;
98
 
    EGLint const expected_egl_config_attr [] =
99
 
    {
100
 
        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
101
 
        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
102
 
        EGL_FRAMEBUFFER_TARGET_ANDROID, EGL_TRUE,
103
 
        EGL_NONE
104
 
    };
105
 
 
106
 
    int visual_id = HAL_PIXEL_FORMAT_BGRA_8888;
107
 
    EGLDisplay fake_display = reinterpret_cast<EGLDisplay>(0x11235813);
108
 
    EGLConfig fake_egl_config = reinterpret_cast<EGLConfig>(0x44);
109
 
 
110
 
    Sequence seq;
111
 
    EXPECT_CALL(mock_egl, eglGetDisplay(EGL_DEFAULT_DISPLAY))
112
 
        .InSequence(seq)
113
 
        .WillOnce(Return(fake_display));
114
 
    EXPECT_CALL(mock_egl, eglInitialize(fake_display,_,_))
115
 
        .InSequence(seq);
116
 
    EXPECT_CALL(mock_egl, eglChooseConfig(fake_display,mtd::AttrMatches(expected_egl_config_attr),_,1,_))
117
 
        .InSequence(seq)
118
 
        .WillOnce(DoAll(SetArgPointee<2>(fake_egl_config), SetArgPointee<4>(1), Return(EGL_TRUE)));
119
 
    EXPECT_CALL(mock_egl, eglGetConfigAttrib(fake_display, fake_egl_config, EGL_NATIVE_VISUAL_ID, _))
120
 
        .InSequence(seq)
121
 
        .WillOnce(DoAll(SetArgPointee<3>(visual_id), Return(EGL_TRUE)));
122
 
    EXPECT_CALL(mock_egl, eglTerminate(fake_display))
123
 
        .InSequence(seq);
124
 
 
125
 
    mga::Framebuffers framebuffers(mock_allocator, display_size, vrefresh_hz, 2u);
126
 
    EXPECT_EQ(mir_pixel_format_argb_8888, framebuffers.fb_format());
127
 
}
128
 
 
129
 
//not all hwc11 implementations give a hint about their framebuffer formats in their configuration.
130
 
//prefer abgr_8888 if we can't figure things out
131
 
TEST_F(PostingFBBundleTest, hwc_version_11_format_selection_failure)
132
 
{
133
 
    using namespace testing;
134
 
    EGLDisplay fake_display = reinterpret_cast<EGLDisplay>(0x11235813);
135
 
 
136
 
    Sequence seq;
137
 
    EXPECT_CALL(mock_egl, eglGetDisplay(EGL_DEFAULT_DISPLAY))
138
 
        .InSequence(seq)
139
 
        .WillOnce(Return(fake_display));
140
 
    EXPECT_CALL(mock_egl, eglInitialize(fake_display,_,_))
141
 
        .InSequence(seq);
142
 
    EXPECT_CALL(mock_egl, eglChooseConfig(_,_,_,_,_))
143
 
        .InSequence(seq)
144
 
        .WillOnce(DoAll(SetArgPointee<4>(0), Return(EGL_TRUE)));
145
 
    EXPECT_CALL(mock_egl, eglTerminate(fake_display))
146
 
        .InSequence(seq);
147
 
 
148
 
    mga::Framebuffers framebuffers(mock_allocator, display_size, vrefresh_hz, 2u);
149
 
    EXPECT_EQ(mir_pixel_format_abgr_8888, framebuffers.fb_format());
150
 
}
151
 
 
152
 
TEST_F(PostingFBBundleTest, bundle_from_fb)
153
 
{
154
 
    using namespace testing;
155
 
    auto display_size = geom::Size{display_width, display_height};
156
 
    EXPECT_CALL(*mock_allocator, alloc_buffer_platform(display_size, mir_pixel_format_abgr_8888, mga::BufferUsage::use_framebuffer_gles))
157
 
        .Times(fbnum)
158
 
        .WillRepeatedly(Return(nullptr));
159
 
 
160
 
    mga::Framebuffers framebuffers(mock_allocator, display_size, vrefresh_hz, mock_fb_hal);
161
 
    EXPECT_EQ(display_size, framebuffers.fb_size());
162
 
    EXPECT_EQ(mir_pixel_format_abgr_8888, framebuffers.fb_format());
163
 
}
164
 
 
165
 
//some drivers incorrectly report 0 buffers available. if this is true, we should alloc 2, the minimum requirement
166
 
TEST_F(PostingFBBundleTest, determine_fbnum_always_reports_2_minimum)
167
 
{
168
 
    using namespace testing;
169
 
    auto slightly_malformed_fb_hal_mock = std::make_shared<mtd::MockFBHalDevice>(display_width, display_height, format, 0);
170
 
    EXPECT_CALL(*mock_allocator, alloc_buffer_platform(_,_,_))
171
 
        .Times(2)
172
 
        .WillRepeatedly(Return(nullptr));
173
 
 
174
 
    mga::Framebuffers framebuffers(mock_allocator, display_size, vrefresh_hz, slightly_malformed_fb_hal_mock);
175
 
}
176
 
 
177
82
TEST_F(PostingFBBundleTest, last_rendered_returns_valid)
178
83
{
179
 
    mga::Framebuffers framebuffers(mock_allocator, display_size, vrefresh_hz, mock_fb_hal);
 
84
    mga::Framebuffers framebuffers(mock_allocator, display_size, format, vrefresh_hz, 2u);
180
85
 
181
86
    auto test_buffer = framebuffers.last_rendered_buffer();
182
87
    EXPECT_TRUE((test_buffer == buffer1) || (test_buffer == buffer2));
190
95
 
191
96
TEST_F(PostingFBBundleTest, last_rendered_is_first_returned_from_driver)
192
97
{
193
 
    mga::Framebuffers framebuffers(mock_allocator, display_size, vrefresh_hz, 2u);
 
98
    mga::Framebuffers framebuffers(mock_allocator, display_size, format, vrefresh_hz, 2u);
194
99
    auto buffer1 = framebuffers.buffer_for_render().get();
195
100
    EXPECT_EQ(buffer1, framebuffers.last_rendered_buffer().get());
196
101
    auto buffer2 = framebuffers.buffer_for_render().get();
199
104
 
200
105
TEST_F(PostingFBBundleTest, no_rendering_returns_same_buffer)
201
106
{
202
 
    mga::Framebuffers framebuffers(mock_allocator, display_size, vrefresh_hz, 2u);
 
107
    mga::Framebuffers framebuffers(mock_allocator, display_size, format, vrefresh_hz, 2u);
203
108
    framebuffers.buffer_for_render().get();
204
109
    auto buffer = framebuffers.last_rendered_buffer();
205
110
    EXPECT_EQ(buffer, framebuffers.last_rendered_buffer());
207
112
 
208
113
TEST_F(PostingFBBundleTest, three_buffers_for_hwc)
209
114
{
210
 
    mga::Framebuffers framebuffers(mock_allocator, display_size, vrefresh_hz, 3u);
 
115
    mga::Framebuffers framebuffers(mock_allocator, display_size, format, vrefresh_hz, 3u);
211
116
 
212
117
    auto buffer1 = framebuffers.buffer_for_render().get();
213
118
    framebuffers.buffer_for_render();