Mercurial > malikania

comparison tests/libclient/color/main.cpp @ 44:f30c84b4b9ed

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Tests: switch from GoogleTest to Boost.Unit, closes #588
author David Demelier <markand@malikania.fr>
date Wed, 30 Nov 2016 21:15:53 +0100
parents fabbe1759cec
children fe7e3524e571
comparison
equal deleted inserted replaced
43:fabbe1759cec 44:f30c84b4b9ed
1 /* 1 /*
2 * main.cpp -- test color 2 * main.cpp -- test mlk::color
3 * 3 *
4 * Copyright (c) 2013-2016 Malikania Authors 4 * Copyright (c) 2013-2016 Malikania Authors
5 * 5 *
6 * Permission to use, copy, modify, and/or distribute this software for any 6 * Permission to use, copy, modify, and/or distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above 7 * purpose with or without fee is hereby granted, provided that the above
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */ 17 */
18 18
19 #include <gtest/gtest.h> 19 #define BOOST_TEST_MODULE "Color"
20 #include <boost/test/unit_test.hpp>
20 21
21 #include <malikania/color.hpp> 22 #include <malikania/color.hpp>
22 23
23 using namespace mlk;
24
25 /* 24 /*
26 * Separate arguments 25 * Separate arguments
27 * ------------------------------------------------------------------ 26 * ------------------------------------------------------------------
28 */ 27 */
29 28
30 TEST(Basic, black) 29 BOOST_AUTO_TEST_SUITE(basic)
31 { 30
32 color c; 31 BOOST_AUTO_TEST_CASE(black)
33 32 {
34 ASSERT_EQ(0, c.red()); 33 mlk::color c;
35 ASSERT_EQ(0, c.green()); 34
36 ASSERT_EQ(0, c.blue()); 35 BOOST_REQUIRE_EQUAL(0, c.red());
37 ASSERT_EQ(255, c.alpha()); 36 BOOST_REQUIRE_EQUAL(0, c.green());
38 } 37 BOOST_REQUIRE_EQUAL(0, c.blue());
39 38 BOOST_REQUIRE_EQUAL(255, c.alpha());
40 TEST(Basic, white) 39 }
41 { 40
42 color c{255, 255, 255, 255}; 41 BOOST_AUTO_TEST_CASE(white)
43 42 {
44 ASSERT_EQ(255, c.red()); 43 mlk::color c{255, 255, 255, 255};
45 ASSERT_EQ(255, c.green()); 44
46 ASSERT_EQ(255, c.blue()); 45 BOOST_REQUIRE_EQUAL(255, c.red());
47 ASSERT_EQ(255, c.alpha()); 46 BOOST_REQUIRE_EQUAL(255, c.green());
48 } 47 BOOST_REQUIRE_EQUAL(255, c.blue());
49 48 BOOST_REQUIRE_EQUAL(255, c.alpha());
50 TEST(Basic, red) 49 }
51 { 50
52 color c{255, 0, 0, 255}; 51 BOOST_AUTO_TEST_CASE(red)
53 52 {
54 ASSERT_EQ(255, c.red()); 53 mlk::color c{255, 0, 0, 255};
55 ASSERT_EQ(0, c.green()); 54
56 ASSERT_EQ(0, c.blue()); 55 BOOST_REQUIRE_EQUAL(255, c.red());
57 ASSERT_EQ(255, c.alpha()); 56 BOOST_REQUIRE_EQUAL(0, c.green());
58 } 57 BOOST_REQUIRE_EQUAL(0, c.blue());
59 58 BOOST_REQUIRE_EQUAL(255, c.alpha());
60 TEST(Basic, green) 59 }
61 { 60
62 color c{0, 255, 0, 255}; 61 BOOST_AUTO_TEST_CASE(green)
63 62 {
64 ASSERT_EQ(0, c.red()); 63 mlk::color c{0, 255, 0, 255};
65 ASSERT_EQ(255, c.green()); 64
66 ASSERT_EQ(0, c.blue()); 65 BOOST_REQUIRE_EQUAL(0, c.red());
67 ASSERT_EQ(255, c.alpha()); 66 BOOST_REQUIRE_EQUAL(255, c.green());
68 } 67 BOOST_REQUIRE_EQUAL(0, c.blue());
69 68 BOOST_REQUIRE_EQUAL(255, c.alpha());
70 TEST(Basic, blue) 69 }
71 { 70
72 color c{0, 0, 255, 255}; 71 BOOST_AUTO_TEST_CASE(blue)
73 72 {
74 ASSERT_EQ(0, c.red()); 73 mlk::color c{0, 0, 255, 255};
75 ASSERT_EQ(0, c.green()); 74
76 ASSERT_EQ(255, c.blue()); 75 BOOST_REQUIRE_EQUAL(0, c.red());
77 ASSERT_EQ(255, c.alpha()); 76 BOOST_REQUIRE_EQUAL(0, c.green());
78 } 77 BOOST_REQUIRE_EQUAL(255, c.blue());
78 BOOST_REQUIRE_EQUAL(255, c.alpha());
79 }
80
81 BOOST_AUTO_TEST_SUITE_END()
79 82
80 /* 83 /*
81 * Hexadecimal 84 * Hexadecimal
82 * ------------------------------------------------------------------ 85 * ------------------------------------------------------------------
83 */ 86 */
84 87
85 TEST(Hex, black) 88 BOOST_AUTO_TEST_SUITE(hex)
86 { 89
87 color c{0xff000000}; 90 BOOST_AUTO_TEST_CASE(black)
88 91 {
89 ASSERT_EQ(0, c.red()); 92 mlk::color c{0xff000000};
90 ASSERT_EQ(0, c.green()); 93
91 ASSERT_EQ(0, c.blue()); 94 BOOST_REQUIRE_EQUAL(0, c.red());
92 ASSERT_EQ(255, c.alpha()); 95 BOOST_REQUIRE_EQUAL(0, c.green());
93 } 96 BOOST_REQUIRE_EQUAL(0, c.blue());
94 97 BOOST_REQUIRE_EQUAL(255, c.alpha());
95 TEST(Hex, white) 98 }
96 { 99
97 color c{0xffffffff}; 100 BOOST_AUTO_TEST_CASE(white)
98 101 {
99 ASSERT_EQ(255, c.red()); 102 mlk::color c{0xffffffff};
100 ASSERT_EQ(255, c.green()); 103
101 ASSERT_EQ(255, c.blue()); 104 BOOST_REQUIRE_EQUAL(255, c.red());
102 ASSERT_EQ(255, c.alpha()); 105 BOOST_REQUIRE_EQUAL(255, c.green());
103 } 106 BOOST_REQUIRE_EQUAL(255, c.blue());
104 107 BOOST_REQUIRE_EQUAL(255, c.alpha());
105 TEST(Hex, red) 108 }
106 { 109
107 color c{0xffff0000}; 110 BOOST_AUTO_TEST_CASE(red)
108 111 {
109 ASSERT_EQ(255, c.red()); 112 mlk::color c{0xffff0000};
110 ASSERT_EQ(0, c.green()); 113
111 ASSERT_EQ(0, c.blue()); 114 BOOST_REQUIRE_EQUAL(255, c.red());
112 ASSERT_EQ(255, c.alpha()); 115 BOOST_REQUIRE_EQUAL(0, c.green());
113 } 116 BOOST_REQUIRE_EQUAL(0, c.blue());
114 117 BOOST_REQUIRE_EQUAL(255, c.alpha());
115 TEST(Hex, green) 118 }
116 { 119
117 color c{0xff00ff00}; 120 BOOST_AUTO_TEST_CASE(green)
118 121 {
119 ASSERT_EQ(0, c.red()); 122 mlk::color c{0xff00ff00};
120 ASSERT_EQ(255, c.green()); 123
121 ASSERT_EQ(0, c.blue()); 124 BOOST_REQUIRE_EQUAL(0, c.red());
122 ASSERT_EQ(255, c.alpha()); 125 BOOST_REQUIRE_EQUAL(255, c.green());
123 } 126 BOOST_REQUIRE_EQUAL(0, c.blue());
124 127 BOOST_REQUIRE_EQUAL(255, c.alpha());
125 TEST(Hex, blue) 128 }
126 { 129
127 color c{0xff0000ff}; 130 BOOST_AUTO_TEST_CASE(blue)
128 131 {
129 ASSERT_EQ(0, c.red()); 132 mlk::color c{0xff0000ff};
130 ASSERT_EQ(0, c.green()); 133
131 ASSERT_EQ(255, c.blue()); 134 BOOST_REQUIRE_EQUAL(0, c.red());
132 ASSERT_EQ(255, c.alpha()); 135 BOOST_REQUIRE_EQUAL(0, c.green());
133 } 136 BOOST_REQUIRE_EQUAL(255, c.blue());
137 BOOST_REQUIRE_EQUAL(255, c.alpha());
138 }
139
140 BOOST_AUTO_TEST_SUITE_END()
134 141
135 /* 142 /*
136 * Names 143 * Names
137 * ------------------------------------------------------------------ 144 * ------------------------------------------------------------------
138 * 145 *
139 * Test most famous. 146 * Test most famous.
140 */ 147 */
141 148
142 TEST(Named, black) 149 BOOST_AUTO_TEST_SUITE(named)
143 { 150
144 color c{"black"}; 151 BOOST_AUTO_TEST_CASE(black)
145 152 {
146 ASSERT_EQ(0, c.red()); 153 mlk::color c{"black"};
147 ASSERT_EQ(0, c.green()); 154
148 ASSERT_EQ(0, c.blue()); 155 BOOST_REQUIRE_EQUAL(0, c.red());
149 ASSERT_EQ(255, c.alpha()); 156 BOOST_REQUIRE_EQUAL(0, c.green());
150 } 157 BOOST_REQUIRE_EQUAL(0, c.blue());
151 158 BOOST_REQUIRE_EQUAL(255, c.alpha());
152 TEST(Named, white) 159 }
153 { 160
154 color c{"white"}; 161 BOOST_AUTO_TEST_CASE(white)
155 162 {
156 ASSERT_EQ(255, c.red()); 163 mlk::color c{"white"};
157 ASSERT_EQ(255, c.green()); 164
158 ASSERT_EQ(255, c.blue()); 165 BOOST_REQUIRE_EQUAL(255, c.red());
159 ASSERT_EQ(255, c.alpha()); 166 BOOST_REQUIRE_EQUAL(255, c.green());
160 } 167 BOOST_REQUIRE_EQUAL(255, c.blue());
161 168 BOOST_REQUIRE_EQUAL(255, c.alpha());
162 TEST(Named, red) 169 }
163 { 170
164 color c{"red"}; 171 BOOST_AUTO_TEST_CASE(red)
165 172 {
166 ASSERT_EQ(255, c.red()); 173 mlk::color c{"red"};
167 ASSERT_EQ(0, c.green()); 174
168 ASSERT_EQ(0, c.blue()); 175 BOOST_REQUIRE_EQUAL(255, c.red());
169 ASSERT_EQ(255, c.alpha()); 176 BOOST_REQUIRE_EQUAL(0, c.green());
170 } 177 BOOST_REQUIRE_EQUAL(0, c.blue());
171 178 BOOST_REQUIRE_EQUAL(255, c.alpha());
172 TEST(Named, green) 179 }
173 { 180
174 color c{"green"}; 181 BOOST_AUTO_TEST_CASE(green)
175 182 {
176 ASSERT_EQ(0, c.red()); 183 mlk::color c{"green"};
177 ASSERT_EQ(128, c.green()); 184
178 ASSERT_EQ(0, c.blue()); 185 BOOST_REQUIRE_EQUAL(0, c.red());
179 ASSERT_EQ(255, c.alpha()); 186 BOOST_REQUIRE_EQUAL(128, c.green());
180 } 187 BOOST_REQUIRE_EQUAL(0, c.blue());
181 188 BOOST_REQUIRE_EQUAL(255, c.alpha());
182 TEST(Named, blue) 189 }
183 { 190
184 color c{"blue"}; 191 BOOST_AUTO_TEST_CASE(blue)
185 192 {
186 ASSERT_EQ(0, c.red()); 193 mlk::color c{"blue"};
187 ASSERT_EQ(0, c.green()); 194
188 ASSERT_EQ(255, c.blue()); 195 BOOST_REQUIRE_EQUAL(0, c.red());
189 ASSERT_EQ(255, c.alpha()); 196 BOOST_REQUIRE_EQUAL(0, c.green());
190 } 197 BOOST_REQUIRE_EQUAL(255, c.blue());
191 198 BOOST_REQUIRE_EQUAL(255, c.alpha());
192 TEST(Named, wrong) 199 }
193 { 200
194 try { 201 BOOST_AUTO_TEST_CASE(wrong)
195 color c{"does not exist"}; 202 {
196 203 BOOST_REQUIRE_THROW(mlk::color c{"does not exist"}, std::exception);
197 FAIL() << "exception expected"; 204 }
198 } catch (const std::exception &) { 205
199 } 206 BOOST_AUTO_TEST_SUITE_END()
200 }
201 207
202 /* 208 /*
203 * #rrggbb 209 * #rrggbb
204 * ------------------------------------------------------------------ 210 * ------------------------------------------------------------------
205 * 211 *
206 * Test most famous. 212 * Test most famous.
207 */ 213 */
208 214
209 TEST(FullRgb, black) 215 BOOST_AUTO_TEST_SUITE(long_rgb)
210 { 216
211 color c{"#000000"}; 217 BOOST_AUTO_TEST_CASE(black)
212 218 {
213 ASSERT_EQ(0, c.red()); 219 mlk::color c{"#000000"};
214 ASSERT_EQ(0, c.green()); 220
215 ASSERT_EQ(0, c.blue()); 221 BOOST_REQUIRE_EQUAL(0, c.red());
216 ASSERT_EQ(255, c.alpha()); 222 BOOST_REQUIRE_EQUAL(0, c.green());
217 } 223 BOOST_REQUIRE_EQUAL(0, c.blue());
218 224 BOOST_REQUIRE_EQUAL(255, c.alpha());
219 TEST(FullRgb, white) 225 }
220 { 226
221 color c{"#ffffff"}; 227 BOOST_AUTO_TEST_CASE(white)
222 228 {
223 ASSERT_EQ(255, c.red()); 229 mlk::color c{"#ffffff"};
224 ASSERT_EQ(255, c.green()); 230
225 ASSERT_EQ(255, c.blue()); 231 BOOST_REQUIRE_EQUAL(255, c.red());
226 ASSERT_EQ(255, c.alpha()); 232 BOOST_REQUIRE_EQUAL(255, c.green());
227 } 233 BOOST_REQUIRE_EQUAL(255, c.blue());
228 234 BOOST_REQUIRE_EQUAL(255, c.alpha());
229 TEST(FullRgb, red) 235 }
230 { 236
231 color c{"#ff0000"}; 237 BOOST_AUTO_TEST_CASE(red)
232 238 {
233 ASSERT_EQ(255, c.red()); 239 mlk::color c{"#ff0000"};
234 ASSERT_EQ(0, c.green()); 240
235 ASSERT_EQ(0, c.blue()); 241 BOOST_REQUIRE_EQUAL(255, c.red());
236 ASSERT_EQ(255, c.alpha()); 242 BOOST_REQUIRE_EQUAL(0, c.green());
237 } 243 BOOST_REQUIRE_EQUAL(0, c.blue());
238 244 BOOST_REQUIRE_EQUAL(255, c.alpha());
239 TEST(FullRgb, green) 245 }
240 { 246
241 color c{"#00ff00"}; 247 BOOST_AUTO_TEST_CASE(green)
242 248 {
243 ASSERT_EQ(0, c.red()); 249 mlk::color c{"#00ff00"};
244 ASSERT_EQ(255, c.green()); 250
245 ASSERT_EQ(0, c.blue()); 251 BOOST_REQUIRE_EQUAL(0, c.red());
246 ASSERT_EQ(255, c.alpha()); 252 BOOST_REQUIRE_EQUAL(255, c.green());
247 } 253 BOOST_REQUIRE_EQUAL(0, c.blue());
248 254 BOOST_REQUIRE_EQUAL(255, c.alpha());
249 TEST(FullRgb, blue) 255 }
250 { 256
251 color c{"#0000ff"}; 257 BOOST_AUTO_TEST_CASE(blue)
252 258 {
253 ASSERT_EQ(0, c.red()); 259 mlk::color c{"#0000ff"};
254 ASSERT_EQ(0, c.green()); 260
255 ASSERT_EQ(255, c.blue()); 261 BOOST_REQUIRE_EQUAL(0, c.red());
256 ASSERT_EQ(255, c.alpha()); 262 BOOST_REQUIRE_EQUAL(0, c.green());
257 } 263 BOOST_REQUIRE_EQUAL(255, c.blue());
258 264 BOOST_REQUIRE_EQUAL(255, c.alpha());
259 TEST(FullRgb, wrong) 265 }
260 { 266
261 try { 267 BOOST_AUTO_TEST_CASE(wrong)
262 color c{"#ghijkl"}; 268 {
263 269 BOOST_REQUIRE_THROW(mlk::color c{"#ghijkl"}, std::exception);
264 FAIL() << "exception expected"; 270 }
265 } catch (const std::exception &) { 271
266 } 272 BOOST_AUTO_TEST_SUITE_END()
267 }
268 273
269 /* 274 /*
270 * #rgb 275 * #rgb
271 * ------------------------------------------------------------------ 276 * ------------------------------------------------------------------
272 * 277 *
273 * Test most famous. 278 * Test most famous.
274 */ 279 */
275 280
276 TEST(ShortRgb, black) 281 BOOST_AUTO_TEST_SUITE(short_rgb)
277 { 282
278 color c{"#000"}; 283 BOOST_AUTO_TEST_CASE(black)
279 284 {
280 ASSERT_EQ(0, c.red()); 285 mlk::color c{"#000"};
281 ASSERT_EQ(0, c.green()); 286
282 ASSERT_EQ(0, c.blue()); 287 BOOST_REQUIRE_EQUAL(0, c.red());
283 ASSERT_EQ(255, c.alpha()); 288 BOOST_REQUIRE_EQUAL(0, c.green());
284 } 289 BOOST_REQUIRE_EQUAL(0, c.blue());
285 290 BOOST_REQUIRE_EQUAL(255, c.alpha());
286 TEST(ShortRgb, white) 291 }
287 { 292
288 color c{"#fff"}; 293 BOOST_AUTO_TEST_CASE(white)
289 294 {
290 ASSERT_EQ(255, c.red()); 295 mlk::color c{"#fff"};
291 ASSERT_EQ(255, c.green()); 296
292 ASSERT_EQ(255, c.blue()); 297 BOOST_REQUIRE_EQUAL(255, c.red());
293 ASSERT_EQ(255, c.alpha()); 298 BOOST_REQUIRE_EQUAL(255, c.green());
294 } 299 BOOST_REQUIRE_EQUAL(255, c.blue());
295 300 BOOST_REQUIRE_EQUAL(255, c.alpha());
296 TEST(ShortRgb, red) 301 }
297 { 302
298 color c{"#f00"}; 303 BOOST_AUTO_TEST_CASE(red)
299 304 {
300 ASSERT_EQ(255, c.red()); 305 mlk::color c{"#f00"};
301 ASSERT_EQ(0, c.green()); 306
302 ASSERT_EQ(0, c.blue()); 307 BOOST_REQUIRE_EQUAL(255, c.red());
303 ASSERT_EQ(255, c.alpha()); 308 BOOST_REQUIRE_EQUAL(0, c.green());
304 } 309 BOOST_REQUIRE_EQUAL(0, c.blue());
305 310 BOOST_REQUIRE_EQUAL(255, c.alpha());
306 TEST(ShortRgb, green) 311 }
307 { 312
308 color c{"#0f0"}; 313 BOOST_AUTO_TEST_CASE(green)
309 314 {
310 ASSERT_EQ(0, c.red()); 315 mlk::color c{"#0f0"};
311 ASSERT_EQ(255, c.green()); 316
312 ASSERT_EQ(0, c.blue()); 317 BOOST_REQUIRE_EQUAL(0, c.red());
313 ASSERT_EQ(255, c.alpha()); 318 BOOST_REQUIRE_EQUAL(255, c.green());
314 } 319 BOOST_REQUIRE_EQUAL(0, c.blue());
315 320 BOOST_REQUIRE_EQUAL(255, c.alpha());
316 TEST(ShortRgb, blue) 321 }
317 { 322
318 color c{"#00f"}; 323 BOOST_AUTO_TEST_CASE(blue)
319 324 {
320 ASSERT_EQ(0, c.red()); 325 mlk::color c{"#00f"};
321 ASSERT_EQ(0, c.green()); 326
322 ASSERT_EQ(255, c.blue()); 327 BOOST_REQUIRE_EQUAL(0, c.red());
323 ASSERT_EQ(255, c.alpha()); 328 BOOST_REQUIRE_EQUAL(0, c.green());
324 } 329 BOOST_REQUIRE_EQUAL(255, c.blue());
325 330 BOOST_REQUIRE_EQUAL(255, c.alpha());
326 TEST(ShortRgb, combination) 331 }
327 { 332
328 color c{"#123"}; 333 BOOST_AUTO_TEST_CASE(combination)
329 334 {
330 ASSERT_EQ(17, c.red()); 335 mlk::color c{"#123"};
331 ASSERT_EQ(34, c.green()); 336
332 ASSERT_EQ(51, c.blue()); 337 BOOST_REQUIRE_EQUAL(17, c.red());
333 ASSERT_EQ(255, c.alpha()); 338 BOOST_REQUIRE_EQUAL(34, c.green());
334 } 339 BOOST_REQUIRE_EQUAL(51, c.blue());
335 340 BOOST_REQUIRE_EQUAL(255, c.alpha());
336 TEST(ShortRgb, wrong) 341 }
337 { 342
338 try { 343 BOOST_AUTO_TEST_CASE(wrong)
339 color c{"#ghi"}; 344 {
340 345 BOOST_REQUIRE_THROW(mlk::color c{"#ghi"}, std::exception);
341 FAIL() << "exception expected"; 346 }
342 } catch (const std::exception &) { 347
343 } 348 BOOST_AUTO_TEST_SUITE_END()
344 }
345
346 int main(int argc, char **argv)
347 {
348 testing::InitGoogleTest(&argc, argv);
349
350 return RUN_ALL_TESTS();
351 }