1
=== modified file 'include/platform/mir/graphics/gamma_curves.h'
2
--- include/platform/mir/graphics/gamma_curves.h	2016-10-31 02:37:31 +0000
3
+++ include/platform/mir/graphics/gamma_curves.h	2017-01-16 15:30:49 +0000
4
@@ -33,16 +33,27 @@
5
33
{
33
{
6
34
public:
34
public:
7
35
    GammaCurves() = default;
35
    GammaCurves() = default;
8
36
    GammaCurves(GammaCurves const& other) = default;
9
37
    GammaCurves(GammaCurves&& other) = default;
10
36
38
11
37
    GammaCurves(GammaCurve const& red,
39
    GammaCurves(GammaCurve const& red,
12
38
                GammaCurve const& green,
40
                GammaCurve const& green,
13
39
                GammaCurve const& blue);
41
                GammaCurve const& blue);
14
40
42
15
43
    GammaCurves& operator=(GammaCurves const& other) = default;
16
44
    GammaCurves& operator=(GammaCurves&& other) = default;
17
45
18
41
    GammaCurve red;
46
    GammaCurve red;
19
42
    GammaCurve green;
47
    GammaCurve green;
20
43
    GammaCurve blue;
48
    GammaCurve blue;
21
44
};
49
};
22
45
50
23
51
class LinearGammaLUTs : public GammaCurves
24
52
{
25
53
public:
26
54
    explicit LinearGammaLUTs(int size);
27
55
};
28
56
29
46
}
57
}
30
47
}
58
}
31
48
59
32
49
60
33
=== modified file 'src/platform/graphics/gamma_curves.cpp'
34
--- src/platform/graphics/gamma_curves.cpp	2016-10-31 02:37:31 +0000
35
+++ src/platform/graphics/gamma_curves.cpp	2017-01-16 15:30:49 +0000
36
@@ -19,10 +19,27 @@
37
19
#include "mir/graphics/gamma_curves.h"
19
#include "mir/graphics/gamma_curves.h"
38
20
20
39
21
#include <boost/throw_exception.hpp>
21
#include <boost/throw_exception.hpp>
40
22
41
23
#include <algorithm>
42
22
#include <stdexcept>
24
#include <stdexcept>
43
23
25
44
24
namespace mg = mir::graphics;
26
namespace mg = mir::graphics;
45
25
27
46
28
namespace
47
29
{
48
30
mg::GammaCurves make_linear_ramp(int size)
49
31
{
50
32
    if (size < 2)
51
33
        BOOST_THROW_EXCEPTION(std::logic_error("gamma LUT size is too small"));
52
34
53
35
    mg::GammaCurve ramp(size);
54
36
    auto const step = std::numeric_limits<mg::GammaCurve::value_type>::max() / (size - 1);
55
37
    mg::GammaCurve::value_type n = 0;
56
38
    std::generate(ramp.begin(), ramp.end(), [&n, step]{ auto current = n; n += step; return current; });
57
39
58
40
    return {ramp, ramp, ramp};
59
41
}
60
42
}
61
26
mg::GammaCurves::GammaCurves(GammaCurve const& red,
43
mg::GammaCurves::GammaCurves(GammaCurve const& red,
62
27
                             GammaCurve const& green,
44
                             GammaCurve const& green,
63
28
                             GammaCurve const& blue) :
45
                             GammaCurve const& blue) :
64
@@ -36,3 +53,8 @@
65
36
        BOOST_THROW_EXCEPTION(std::logic_error("Different gamma LUT sizes"));
53
        BOOST_THROW_EXCEPTION(std::logic_error("Different gamma LUT sizes"));
66
37
    }
54
    }
67
38
}
55
}
68
56
69
57
mg::LinearGammaLUTs::LinearGammaLUTs(int size)
70
58
  : GammaCurves(make_linear_ramp(size))
71
59
{
72
60
}
73
39
61
74
=== modified file 'src/platform/symbols.map'
75
--- src/platform/symbols.map	2016-11-16 13:24:41 +0000
76
+++ src/platform/symbols.map	2017-01-16 15:30:49 +0000
77
@@ -67,6 +67,7 @@
78
67
    mir::graphics::GraphicBufferAllocator::GraphicBufferAllocator*;
67
    mir::graphics::GraphicBufferAllocator::GraphicBufferAllocator*;
79
68
    mir::graphics::GraphicBufferAllocator::operator*;
68
    mir::graphics::GraphicBufferAllocator::operator*;
80
69
    mir::graphics::GraphicBufferAllocator::supported_pixel_formats*;
69
    mir::graphics::GraphicBufferAllocator::supported_pixel_formats*;
81
70
    mir::graphics::LinearGammaLUTs::LinearGammaLUTs*;
82
70
    mir::graphics::module_for_device*;
71
    mir::graphics::module_for_device*;
83
71
    mir::graphics::operator*;
72
    mir::graphics::operator*;
84
72
    mir::graphics::Platform::create_buffer_allocator*;
73
    mir::graphics::Platform::create_buffer_allocator*;
85
73
74
86
=== modified file 'src/platforms/mesa/server/kms/real_kms_display_configuration.cpp'
87
--- src/platforms/mesa/server/kms/real_kms_display_configuration.cpp	2016-12-09 02:54:31 +0000
88
+++ src/platforms/mesa/server/kms/real_kms_display_configuration.cpp	2017-01-16 15:30:49 +0000
89
@@ -179,26 +179,6 @@
90
179
    return conf_mode_index;
179
    return conf_mode_index;
91
180
}
180
}
92
181
181
93
182
mg::GammaCurves mgm::RealKMSDisplayConfiguration::get_drm_gamma(
94
183
    drmModeCrtc const* crtc) const
95
184
{
96
185
    uint32_t gamma_size = crtc->gamma_size;
97
186
    uint16_t red[gamma_size];
98
187
    uint16_t green[gamma_size];
99
188
    uint16_t blue[gamma_size];
100
189
101
190
    int ret;
102
191
    if ((ret = drmModeCrtcGetGamma(drm_fd, crtc->crtc_id, gamma_size, red, green, blue)) != 0)
103
192
    {
104
193
        BOOST_THROW_EXCEPTION(
105
194
            std::system_error(errno, std::system_category(), "drmModeCrtcGetGamma Failed"));
106
195
    }
107
196
108
197
    return {GammaCurve(red, red + gamma_size),
109
198
            GammaCurve(green, green + gamma_size),
110
199
            GammaCurve(blue, blue + gamma_size)};
111
200
}
112
201
113
202
void mgm::RealKMSDisplayConfiguration::update()
182
void mgm::RealKMSDisplayConfiguration::update()
114
203
{
183
{
115
204
    kms::DRMModeResources resources{drm_fd};
184
    kms::DRMModeResources resources{drm_fd};
116
@@ -327,7 +307,8 @@
117
327
            current_mode_info = resources.crtc(encoder->crtc_id)->mode;
307
            current_mode_info = resources.crtc(encoder->crtc_id)->mode;
118
328
308
119
329
            auto crtc = resources.crtc(encoder->crtc_id);
309
            auto crtc = resources.crtc(encoder->crtc_id);
121
330
            gamma = get_drm_gamma(crtc.get());
310
            if (crtc->gamma_size > 0)
122
311
                gamma = mg::LinearGammaLUTs(crtc->gamma_size);
123
331
        }
312
        }
124
332
    }
313
    }
125
333
314
126
334
315
127
=== modified file 'src/platforms/mesa/server/kms/real_kms_display_configuration.h'
128
--- src/platforms/mesa/server/kms/real_kms_display_configuration.h	2016-10-12 06:03:15 +0000
129
+++ src/platforms/mesa/server/kms/real_kms_display_configuration.h	2017-01-16 15:30:49 +0000
130
@@ -53,7 +53,6 @@
131
53
    void add_or_update_output(kms::DRMModeResources const& resources, drmModeConnector const& connector);
53
    void add_or_update_output(kms::DRMModeResources const& resources, drmModeConnector const& connector);
132
54
    std::vector<DisplayConfigurationOutput>::iterator find_output_with_id(DisplayConfigurationOutputId id);
54
    std::vector<DisplayConfigurationOutput>::iterator find_output_with_id(DisplayConfigurationOutputId id);
133
55
    std::vector<DisplayConfigurationOutput>::const_iterator find_output_with_id(DisplayConfigurationOutputId id) const;
55
    std::vector<DisplayConfigurationOutput>::const_iterator find_output_with_id(DisplayConfigurationOutputId id) const;
134
56
    GammaCurves get_drm_gamma(drmModeCrtc const* crtc) const;
135
57
56
136
58
    int drm_fd;
57
    int drm_fd;
137
59
    DisplayConfigurationCard card;
58
    DisplayConfigurationCard card;
138
60
59
139
=== modified file 'tests/unit-tests/graphics/test_gamma_curves.cpp'
140
--- tests/unit-tests/graphics/test_gamma_curves.cpp	2016-09-27 08:16:43 +0000
141
+++ tests/unit-tests/graphics/test_gamma_curves.cpp	2017-01-16 15:30:49 +0000
142
@@ -21,47 +21,76 @@
143
21
#include <gtest/gtest.h>
21
#include <gtest/gtest.h>
144
22
#include <gmock/gmock.h>
22
#include <gmock/gmock.h>
145
23
23
146
24
#include <algorithm>
147
25
148
24
namespace mg = mir::graphics;
26
namespace mg = mir::graphics;
149
25
27
150
26
namespace
28
namespace
151
27
{
29
{
158
28
mg::GammaCurve const r{1};
30
MATCHER(IsMonotonicallyIncreasing, "")
159
29
mg::GammaCurve const g{2};
31
{
160
30
mg::GammaCurve const b{3};
32
    return std::is_sorted(std::begin(arg), std::end(arg));
161
31
}
33
}
162
32
34
}
163
33
class MockGammaCurves : public testing::Test
35
class GammaCurves : public testing::Test
164
34
{
36
{
165
35
public:
37
public:
172
36
    MockGammaCurves() :
38
    mg::GammaCurve const r{1};
173
37
        gamma(r, g, b)
39
    mg::GammaCurve const g{2};
174
38
    {
40
    mg::GammaCurve const b{3};
175
39
    }
41
    mg::GammaCurves gamma{r, g, b};
170
40
171
41
    mg::GammaCurves gamma;
176
42
};
42
};
177
43
43
179
44
TEST_F(MockGammaCurves, test_uint16_gamma_curves_size)
44
TEST_F(GammaCurves, have_correct_size)
180
45
{
45
{
181
46
    EXPECT_THAT(gamma.red.size(), r.size());
46
    EXPECT_THAT(gamma.red.size(), r.size());
182
47
    EXPECT_THAT(gamma.green.size(), g.size());
183
48
    EXPECT_THAT(gamma.blue.size(), b.size());
184
47
}
49
}
185
48
50
187
49
TEST_F(MockGammaCurves, test_uint16_gamma_curves_rgb_correct)
51
TEST_F(GammaCurves, have_expected_content)
188
50
{
52
{
193
51
    ASSERT_THAT(gamma.red.size(), r.size());
53
    using namespace testing;
194
52
    EXPECT_THAT(gamma.red[0], r[0]);
54
    EXPECT_THAT(gamma.red, ContainerEq(r));
195
53
    EXPECT_THAT(gamma.green[0], g[0]);
55
    EXPECT_THAT(gamma.green, ContainerEq(g));
196
54
    EXPECT_THAT(gamma.blue[0], b[0]);
56
    EXPECT_THAT(gamma.blue, ContainerEq(b));
197
55
}
57
}
198
56
58
200
57
TEST(GammaCurvesEmpty, test_gamma_curves_empty)
59
TEST_F(GammaCurves, are_empty_by_default)
201
58
{
60
{
202
59
    mg::GammaCurves gamma;
61
    mg::GammaCurves gamma;
203
60
62
204
61
    EXPECT_THAT(gamma.red.size(), 0);
63
    EXPECT_THAT(gamma.red.size(), 0);
205
64
    EXPECT_THAT(gamma.green.size(), 0);
206
65
    EXPECT_THAT(gamma.blue.size(), 0);
207
62
}
66
}
208
63
67
210
64
TEST(GammaCurvesEmpty, test_invalid_lut_size_gamma_curves_throw)
68
TEST_F(GammaCurves, throw_with_differing_lut_sizes)
211
65
{
69
{
212
66
    EXPECT_THROW({ mg::GammaCurves({1}, {2, 3}, {4, 5, 6}); }, std::logic_error);
70
    EXPECT_THROW({ mg::GammaCurves({1}, {2, 3}, {4, 5, 6}); }, std::logic_error);
213
67
}
71
}
214
72
215
73
TEST(LinearGammaLUTs, throw_when_size_is_too_small)
216
74
{
217
75
    EXPECT_THROW({ mg::LinearGammaLUTs(1); }, std::logic_error);
218
76
}
219
77
220
78
TEST(LinearGammaLUTs, have_expected_size)
221
79
{
222
80
    int const expected_size = 10;
223
81
    mg::LinearGammaLUTs luts(expected_size);
224
82
225
83
    EXPECT_THAT(luts.red.size(), expected_size);
226
84
    EXPECT_THAT(luts.green.size(), expected_size);
227
85
    EXPECT_THAT(luts.blue.size(), expected_size);
228
86
}
229
87
230
88
TEST(LinearGammaLUTs, is_monotonically_increasing)
231
89
{
232
90
    mg::LinearGammaLUTs luts(256);
233
91
234
92
    EXPECT_THAT(luts.red, IsMonotonicallyIncreasing());
235
93
    EXPECT_THAT(luts.green, IsMonotonicallyIncreasing());
236
94
    EXPECT_THAT(luts.blue, IsMonotonicallyIncreasing());
237
95
}
238
96
239
68
97
240
=== modified file 'tests/unit-tests/platforms/mesa/kms/test_display.cpp'
241
--- tests/unit-tests/platforms/mesa/kms/test_display.cpp	2016-11-11 07:56:09 +0000
242
+++ tests/unit-tests/platforms/mesa/kms/test_display.cpp	2017-01-16 15:30:49 +0000
243
@@ -234,12 +234,6 @@
244
234
    EXPECT_CALL(mock_gbm, gbm_surface_create(mock_gbm.fake_gbm.device,_,_,_,_))
234
    EXPECT_CALL(mock_gbm, gbm_surface_create(mock_gbm.fake_gbm.device,_,_,_,_))
245
235
        .Times(Exactly(1));
235
        .Times(Exactly(1));
246
236
236
247
237
    /* Get the DRM gamma ramp */
248
238
    EXPECT_CALL(mock_drm, drmModeCrtcGetGamma(mock_drm.fake_drm.fd(),
249
239
                                              crtc_id, fake.crtc.gamma_size,
250
240
                                              _, _, _))
251
241
        .Times(Exactly(1));
252
242
253
243
    /* Create an EGL window surface backed by the gbm surface */
237
    /* Create an EGL window surface backed by the gbm surface */
254
244
    EXPECT_CALL(mock_egl, eglCreateWindowSurface(mock_egl.fake_egl_display,
238
    EXPECT_CALL(mock_egl, eglCreateWindowSurface(mock_egl.fake_egl_display,
255
245
                                                 mock_egl.fake_configs[0],
239
                                                 mock_egl.fake_configs[0],
Reviewer	Review Type	Date Requested	Status
Mir CI Bot	continuous-integration		Approve on 2017-01-17
Daniel van Vugt			Approve on 2017-01-17
Brandon Schaefer (community)		2017-01-15	Approve on 2017-01-15
Review via email: mp+314776@code.launchpad.net
1	=== modified file 'include/platform/mir/graphics/gamma_curves.h'
2	--- include/platform/mir/graphics/gamma_curves.h 2016-10-31 02:37:31 +0000
3	+++ include/platform/mir/graphics/gamma_curves.h 2017-01-16 15:30:49 +0000
4	@@ -33,16 +33,27 @@
5	33	{	33	{
6	34	public:	34	public:
7	35	GammaCurves() = default;	35	GammaCurves() = default;
8			36	GammaCurves(GammaCurves const& other) = default;
9			37	GammaCurves(GammaCurves&& other) = default;
10	36		38
11	37	GammaCurves(GammaCurve const& red,	39	GammaCurves(GammaCurve const& red,
12	38	GammaCurve const& green,	40	GammaCurve const& green,
13	39	GammaCurve const& blue);	41	GammaCurve const& blue);
14	40		42
15			43	GammaCurves& operator=(GammaCurves const& other) = default;
16			44	GammaCurves& operator=(GammaCurves&& other) = default;
17			45
18	41	GammaCurve red;	46	GammaCurve red;
19	42	GammaCurve green;	47	GammaCurve green;
20	43	GammaCurve blue;	48	GammaCurve blue;
21	44	};	49	};
22	45		50
23			51	class LinearGammaLUTs : public GammaCurves
24			52	{
25			53	public:
26			54	explicit LinearGammaLUTs(int size);
27			55	};
28			56
29	46	}	57	}
30	47	}	58	}
31	48		59
32	49		60
33	=== modified file 'src/platform/graphics/gamma_curves.cpp'
34	--- src/platform/graphics/gamma_curves.cpp 2016-10-31 02:37:31 +0000
35	+++ src/platform/graphics/gamma_curves.cpp 2017-01-16 15:30:49 +0000
36	@@ -19,10 +19,27 @@
37	19	#include "mir/graphics/gamma_curves.h"	19	#include "mir/graphics/gamma_curves.h"
38	20		20
39	21	#include <boost/throw_exception.hpp>	21	#include <boost/throw_exception.hpp>
40			22
41			23	#include <algorithm>
42	22	#include <stdexcept>	24	#include <stdexcept>
43	23		25
44	24	namespace mg = mir::graphics;	26	namespace mg = mir::graphics;
45	25		27
46			28	namespace
47			29	{
48			30	mg::GammaCurves make_linear_ramp(int size)
49			31	{
50			32	if (size < 2)
51			33	BOOST_THROW_EXCEPTION(std::logic_error("gamma LUT size is too small"));
52			34
53			35	mg::GammaCurve ramp(size);
54			36	auto const step = std::numeric_limits<mg::GammaCurve::value_type>::max() / (size - 1);
55			37	mg::GammaCurve::value_type n = 0;
56			38	std::generate(ramp.begin(), ramp.end(), [&n, step]{ auto current = n; n += step; return current; });
57			39
58			40	return {ramp, ramp, ramp};
59			41	}
60			42	}
61	26	mg::GammaCurves::GammaCurves(GammaCurve const& red,	43	mg::GammaCurves::GammaCurves(GammaCurve const& red,
62	27	GammaCurve const& green,	44	GammaCurve const& green,
63	28	GammaCurve const& blue) :	45	GammaCurve const& blue) :
64	@@ -36,3 +53,8 @@
65	36	BOOST_THROW_EXCEPTION(std::logic_error("Different gamma LUT sizes"));	53	BOOST_THROW_EXCEPTION(std::logic_error("Different gamma LUT sizes"));
66	37	}	54	}
67	38	}	55	}
68			56
69			57	mg::LinearGammaLUTs::LinearGammaLUTs(int size)
70			58	: GammaCurves(make_linear_ramp(size))
71			59	{
72			60	}
73	39		61
74	=== modified file 'src/platform/symbols.map'
75	--- src/platform/symbols.map 2016-11-16 13:24:41 +0000
76	+++ src/platform/symbols.map 2017-01-16 15:30:49 +0000
77	@@ -67,6 +67,7 @@
78	67	mir::graphics::GraphicBufferAllocator::GraphicBufferAllocator*;	67	mir::graphics::GraphicBufferAllocator::GraphicBufferAllocator*;
79	68	mir::graphics::GraphicBufferAllocator::operator*;	68	mir::graphics::GraphicBufferAllocator::operator*;
80	69	mir::graphics::GraphicBufferAllocator::supported_pixel_formats*;	69	mir::graphics::GraphicBufferAllocator::supported_pixel_formats*;
81			70	mir::graphics::LinearGammaLUTs::LinearGammaLUTs*;
82	70	mir::graphics::module_for_device*;	71	mir::graphics::module_for_device*;
83	71	mir::graphics::operator*;	72	mir::graphics::operator*;
84	72	mir::graphics::Platform::create_buffer_allocator*;	73	mir::graphics::Platform::create_buffer_allocator*;
85	73		74
86	=== modified file 'src/platforms/mesa/server/kms/real_kms_display_configuration.cpp'
87	--- src/platforms/mesa/server/kms/real_kms_display_configuration.cpp 2016-12-09 02:54:31 +0000
88	+++ src/platforms/mesa/server/kms/real_kms_display_configuration.cpp 2017-01-16 15:30:49 +0000
89	@@ -179,26 +179,6 @@
90	179	return conf_mode_index;	179	return conf_mode_index;
91	180	}	180	}
92	181		181
93	182	mg::GammaCurves mgm::RealKMSDisplayConfiguration::get_drm_gamma(
94	183	drmModeCrtc const* crtc) const
95	184	{
96	185	uint32_t gamma_size = crtc->gamma_size;
97	186	uint16_t red[gamma_size];
98	187	uint16_t green[gamma_size];
99	188	uint16_t blue[gamma_size];
100	189
101	190	int ret;
102	191	if ((ret = drmModeCrtcGetGamma(drm_fd, crtc->crtc_id, gamma_size, red, green, blue)) != 0)
103	192	{
104	193	BOOST_THROW_EXCEPTION(
105	194	std::system_error(errno, std::system_category(), "drmModeCrtcGetGamma Failed"));
106	195	}
107	196
108	197	return {GammaCurve(red, red + gamma_size),
109	198	GammaCurve(green, green + gamma_size),
110	199	GammaCurve(blue, blue + gamma_size)};
111	200	}
112	201
113	202	void mgm::RealKMSDisplayConfiguration::update()	182	void mgm::RealKMSDisplayConfiguration::update()
114	203	{	183	{
115	204	kms::DRMModeResources resources{drm_fd};	184	kms::DRMModeResources resources{drm_fd};
116	@@ -327,7 +307,8 @@
117	327	current_mode_info = resources.crtc(encoder->crtc_id)->mode;	307	current_mode_info = resources.crtc(encoder->crtc_id)->mode;
118	328		308
119	329	auto crtc = resources.crtc(encoder->crtc_id);	309	auto crtc = resources.crtc(encoder->crtc_id);
121	330	gamma = get_drm_gamma(crtc.get());	310	if (crtc->gamma_size > 0)
122			311	gamma = mg::LinearGammaLUTs(crtc->gamma_size);
123	331	}	312	}
124	332	}	313	}
125	333		314
126	334		315
127	=== modified file 'src/platforms/mesa/server/kms/real_kms_display_configuration.h'
128	--- src/platforms/mesa/server/kms/real_kms_display_configuration.h 2016-10-12 06:03:15 +0000
129	+++ src/platforms/mesa/server/kms/real_kms_display_configuration.h 2017-01-16 15:30:49 +0000
130	@@ -53,7 +53,6 @@
131	53	void add_or_update_output(kms::DRMModeResources const& resources, drmModeConnector const& connector);	53	void add_or_update_output(kms::DRMModeResources const& resources, drmModeConnector const& connector);
132	54	std::vector<DisplayConfigurationOutput>::iterator find_output_with_id(DisplayConfigurationOutputId id);	54	std::vector<DisplayConfigurationOutput>::iterator find_output_with_id(DisplayConfigurationOutputId id);
133	55	std::vector<DisplayConfigurationOutput>::const_iterator find_output_with_id(DisplayConfigurationOutputId id) const;	55	std::vector<DisplayConfigurationOutput>::const_iterator find_output_with_id(DisplayConfigurationOutputId id) const;
134	56	GammaCurves get_drm_gamma(drmModeCrtc const* crtc) const;
135	57		56
136	58	int drm_fd;	57	int drm_fd;
137	59	DisplayConfigurationCard card;	58	DisplayConfigurationCard card;
138	60		59
139	=== modified file 'tests/unit-tests/graphics/test_gamma_curves.cpp'
140	--- tests/unit-tests/graphics/test_gamma_curves.cpp 2016-09-27 08:16:43 +0000
141	+++ tests/unit-tests/graphics/test_gamma_curves.cpp 2017-01-16 15:30:49 +0000
142	@@ -21,47 +21,76 @@
143	21	#include <gtest/gtest.h>	21	#include <gtest/gtest.h>
144	22	#include <gmock/gmock.h>	22	#include <gmock/gmock.h>
145	23		23
146			24	#include <algorithm>
147			25
148	24	namespace mg = mir::graphics;	26	namespace mg = mir::graphics;
149	25		27
150	26	namespace	28	namespace
151	27	{	29	{
158	28	mg::GammaCurve const r{1};	30	MATCHER(IsMonotonicallyIncreasing, "")
159	29	mg::GammaCurve const g{2};	31	{
160	30	mg::GammaCurve const b{3};	32	return std::is_sorted(std::begin(arg), std::end(arg));
161	31	}	33	}
162	32		34	}
163	33	class MockGammaCurves : public testing::Test	35	class GammaCurves : public testing::Test
164	34	{	36	{
165	35	public:	37	public:
172	36	MockGammaCurves() :	38	mg::GammaCurve const r{1};
173	37	gamma(r, g, b)	39	mg::GammaCurve const g{2};
174	38	{	40	mg::GammaCurve const b{3};
175	39	}	41	mg::GammaCurves gamma{r, g, b};
170	40
171	41	mg::GammaCurves gamma;
176	42	};	42	};
177	43		43
179	44	TEST_F(MockGammaCurves, test_uint16_gamma_curves_size)	44	TEST_F(GammaCurves, have_correct_size)
180	45	{	45	{
181	46	EXPECT_THAT(gamma.red.size(), r.size());	46	EXPECT_THAT(gamma.red.size(), r.size());
182			47	EXPECT_THAT(gamma.green.size(), g.size());
183			48	EXPECT_THAT(gamma.blue.size(), b.size());
184	47	}	49	}
185	48		50
187	49	TEST_F(MockGammaCurves, test_uint16_gamma_curves_rgb_correct)	51	TEST_F(GammaCurves, have_expected_content)
188	50	{	52	{
193	51	ASSERT_THAT(gamma.red.size(), r.size());	53	using namespace testing;
194	52	EXPECT_THAT(gamma.red[0], r[0]);	54	EXPECT_THAT(gamma.red, ContainerEq(r));
195	53	EXPECT_THAT(gamma.green[0], g[0]);	55	EXPECT_THAT(gamma.green, ContainerEq(g));
196	54	EXPECT_THAT(gamma.blue[0], b[0]);	56	EXPECT_THAT(gamma.blue, ContainerEq(b));
197	55	}	57	}
198	56		58
200	57	TEST(GammaCurvesEmpty, test_gamma_curves_empty)	59	TEST_F(GammaCurves, are_empty_by_default)
201	58	{	60	{
202	59	mg::GammaCurves gamma;	61	mg::GammaCurves gamma;
203	60		62
204	61	EXPECT_THAT(gamma.red.size(), 0);	63	EXPECT_THAT(gamma.red.size(), 0);
205			64	EXPECT_THAT(gamma.green.size(), 0);
206			65	EXPECT_THAT(gamma.blue.size(), 0);
207	62	}	66	}
208	63		67
210	64	TEST(GammaCurvesEmpty, test_invalid_lut_size_gamma_curves_throw)	68	TEST_F(GammaCurves, throw_with_differing_lut_sizes)
211	65	{	69	{
212	66	EXPECT_THROW({ mg::GammaCurves({1}, {2, 3}, {4, 5, 6}); }, std::logic_error);	70	EXPECT_THROW({ mg::GammaCurves({1}, {2, 3}, {4, 5, 6}); }, std::logic_error);
213	67	}	71	}
214			72
215			73	TEST(LinearGammaLUTs, throw_when_size_is_too_small)
216			74	{
217			75	EXPECT_THROW({ mg::LinearGammaLUTs(1); }, std::logic_error);
218			76	}
219			77
220			78	TEST(LinearGammaLUTs, have_expected_size)
221			79	{
222			80	int const expected_size = 10;
223			81	mg::LinearGammaLUTs luts(expected_size);
224			82
225			83	EXPECT_THAT(luts.red.size(), expected_size);
226			84	EXPECT_THAT(luts.green.size(), expected_size);
227			85	EXPECT_THAT(luts.blue.size(), expected_size);
228			86	}
229			87
230			88	TEST(LinearGammaLUTs, is_monotonically_increasing)
231			89	{
232			90	mg::LinearGammaLUTs luts(256);
233			91
234			92	EXPECT_THAT(luts.red, IsMonotonicallyIncreasing());
235			93	EXPECT_THAT(luts.green, IsMonotonicallyIncreasing());
236			94	EXPECT_THAT(luts.blue, IsMonotonicallyIncreasing());
237			95	}
238			96
239	68		97
240	=== modified file 'tests/unit-tests/platforms/mesa/kms/test_display.cpp'
241	--- tests/unit-tests/platforms/mesa/kms/test_display.cpp 2016-11-11 07:56:09 +0000
242	+++ tests/unit-tests/platforms/mesa/kms/test_display.cpp 2017-01-16 15:30:49 +0000
243	@@ -234,12 +234,6 @@
244	234	EXPECT_CALL(mock_gbm, gbm_surface_create(mock_gbm.fake_gbm.device,_,_,_,_))	234	EXPECT_CALL(mock_gbm, gbm_surface_create(mock_gbm.fake_gbm.device,_,_,_,_))
245	235	.Times(Exactly(1));	235	.Times(Exactly(1));
246	236		236
247	237	/* Get the DRM gamma ramp */
248	238	EXPECT_CALL(mock_drm, drmModeCrtcGetGamma(mock_drm.fake_drm.fd(),
249	239	crtc_id, fake.crtc.gamma_size,
250	240	_, _, _))
251	241	.Times(Exactly(1));
252	242
253	243	/* Create an EGL window surface backed by the gbm surface */	237	/* Create an EGL window surface backed by the gbm surface */
254	244	EXPECT_CALL(mock_egl, eglCreateWindowSurface(mock_egl.fake_egl_display,	238	EXPECT_CALL(mock_egl, eglCreateWindowSurface(mock_egl.fake_egl_display,
255	245	mock_egl.fake_configs[0],	239	mock_egl.fake_configs[0],