1 // Copyright 2012 Intel Corporation
2 //
3 // All rights reserved.
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are met:
7 //
8 // - Redistributions of source code must retain the above copyright notice, this
9 // list of conditions and the following disclaimer.
10 //
11 // - Redistributions in binary form must reproduce the above copyright notice,
12 // this list of conditions and the following disclaimer in the documentation
13 // and/or other materials provided with the distribution.
14 //
15 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
19 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
21 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
22 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
23 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25
26 #include <setjmp.h>
27 #include <stdarg.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <string.h>
31
32 #include <cmocka.h>
33
34 #include "wcore_config_attrs.h"
35 #include "wcore_error.h"
36
37 struct test_state_wcore_config_attrs {
38
39 struct wcore_config_attrs actual_attrs;
40 struct wcore_config_attrs expect_attrs;
41 };
42
43 static int
setup(void ** state)44 setup(void **state) {
45 static const struct wcore_config_attrs default_attrs = {
46 // There is no default context api, so arbitrarily choose OpenGL. The
47 // remaining context attrs are the defaults for OpenGL.
48 .context_api = WAFFLE_CONTEXT_OPENGL,
49 .context_major_version = 1,
50 .context_minor_version = 0,
51 .context_profile = WAFFLE_NONE,
52 .context_debug = false,
53 .context_forward_compatible = false,
54
55 .rgb_size = 0,
56 .rgba_size = 0,
57
58 .red_size = 0,
59 .green_size = 0,
60 .blue_size = 0,
61 .alpha_size = 0,
62
63 .depth_size = 0,
64 .stencil_size = 0,
65
66 .sample_buffers = 0,
67 .samples = 0,
68
69 .double_buffered = true,
70 };
71
72 struct test_state_wcore_config_attrs *ts;
73
74 ts = calloc(1, sizeof(*ts));
75 if (!ts)
76 return -1;
77
78 *state = ts;
79
80 wcore_error_reset();
81
82 // Fill actual_attrs with canaries.
83 memset(&ts->actual_attrs, 0x99, sizeof(ts->actual_attrs));
84
85 // Set expect_attrs to defaults.
86 memcpy(&ts->expect_attrs, &default_attrs, sizeof(ts->expect_attrs));
87 return 0;
88 }
89
90 static int
teardown(void ** state)91 teardown(void **state) {
92 free(*state);
93 return 0;
94 }
95
96 static void
test_wcore_config_attrs_null_attrib_list(void ** state)97 test_wcore_config_attrs_null_attrib_list(void **state) {
98 struct test_state_wcore_config_attrs *ts = *state;
99
100 assert_false(wcore_config_attrs_parse(NULL, &ts->actual_attrs));
101 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
102 }
103
104 static void
test_wcore_config_attrs_empty_attrib_list(void ** state)105 test_wcore_config_attrs_empty_attrib_list(void **state) {
106 struct test_state_wcore_config_attrs *ts = *state;
107 const int32_t attrib_list[] = {0};
108
109 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
110 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
111 }
112
113 static void
test_wcore_config_attrs_gl_defaults(void ** state)114 test_wcore_config_attrs_gl_defaults(void **state) {
115 struct test_state_wcore_config_attrs *ts = *state;
116 const int32_t attrib_list[] = {
117 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
118 0,
119 };
120
121 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
122
123 assert_int_equal(ts->actual_attrs.context_major_version, 1);
124 assert_int_equal(ts->actual_attrs.context_minor_version, 0);
125 assert_int_equal(ts->actual_attrs.context_profile, WAFFLE_NONE);
126 assert_int_equal(ts->actual_attrs.red_size, 0);
127 assert_int_equal(ts->actual_attrs.green_size, 0);
128 assert_int_equal(ts->actual_attrs.blue_size, 0);
129 assert_int_equal(ts->actual_attrs.alpha_size, 0);
130 assert_int_equal(ts->actual_attrs.depth_size, 0);
131 assert_int_equal(ts->actual_attrs.stencil_size, 0);
132 assert_int_equal(ts->actual_attrs.sample_buffers, false);
133 assert_int_equal(ts->actual_attrs.samples, 0);
134 assert_int_equal(ts->actual_attrs.double_buffered, true);
135 assert_int_equal(ts->actual_attrs.accum_buffer, false);
136 assert_int_equal(ts->actual_attrs.context_forward_compatible, false);
137 }
138
139 static void
test_wcore_config_attrs_gles1_defaults(void ** state)140 test_wcore_config_attrs_gles1_defaults(void **state) {
141 struct test_state_wcore_config_attrs *ts = *state;
142
143 const int32_t attrib_list[] = {
144 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES1,
145 0,
146 };
147
148 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
149
150 assert_int_equal(ts->actual_attrs.context_major_version, 1);
151 assert_int_equal(ts->actual_attrs.context_minor_version, 0);
152 assert_int_equal(ts->actual_attrs.context_profile, WAFFLE_NONE);
153
154 assert_int_equal(ts->actual_attrs.red_size, 0);
155 assert_int_equal(ts->actual_attrs.green_size, 0);
156 assert_int_equal(ts->actual_attrs.blue_size, 0);
157 assert_int_equal(ts->actual_attrs.alpha_size, 0);
158 assert_int_equal(ts->actual_attrs.depth_size, 0);
159 assert_int_equal(ts->actual_attrs.stencil_size, 0);
160 assert_int_equal(ts->actual_attrs.sample_buffers, false);
161 assert_int_equal(ts->actual_attrs.samples, 0);
162 assert_int_equal(ts->actual_attrs.double_buffered, true);
163 assert_int_equal(ts->actual_attrs.accum_buffer, false);
164 }
165
166 static void
test_wcore_config_attrs_gles2_defaults(void ** state)167 test_wcore_config_attrs_gles2_defaults(void **state) {
168 struct test_state_wcore_config_attrs *ts = *state;
169
170 const int32_t attrib_list[] = {
171 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES2,
172 0,
173 };
174
175 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
176
177 assert_int_equal(ts->actual_attrs.context_major_version, 2);
178 assert_int_equal(ts->actual_attrs.context_minor_version, 0);
179 assert_int_equal(ts->actual_attrs.context_profile, WAFFLE_NONE);
180
181 assert_int_equal(ts->actual_attrs.red_size, 0);
182 assert_int_equal(ts->actual_attrs.green_size, 0);
183 assert_int_equal(ts->actual_attrs.blue_size, 0);
184 assert_int_equal(ts->actual_attrs.alpha_size, 0);
185 assert_int_equal(ts->actual_attrs.depth_size, 0);
186 assert_int_equal(ts->actual_attrs.stencil_size, 0);
187 assert_int_equal(ts->actual_attrs.sample_buffers, false);
188 assert_int_equal(ts->actual_attrs.samples, 0);
189 assert_int_equal(ts->actual_attrs.double_buffered, true);
190 assert_int_equal(ts->actual_attrs.accum_buffer, false);
191 }
192
193 static void
test_wcore_config_attrs_gles3_defaults(void ** state)194 test_wcore_config_attrs_gles3_defaults(void **state) {
195 struct test_state_wcore_config_attrs *ts = *state;
196
197 const int32_t attrib_list[] = {
198 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES3,
199 0,
200 };
201
202 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
203
204 assert_int_equal(ts->actual_attrs.context_major_version, 3);
205 assert_int_equal(ts->actual_attrs.context_minor_version, 0);
206 assert_int_equal(ts->actual_attrs.context_profile, WAFFLE_NONE);
207
208 assert_int_equal(ts->actual_attrs.red_size, 0);
209 assert_int_equal(ts->actual_attrs.green_size, 0);
210 assert_int_equal(ts->actual_attrs.blue_size, 0);
211 assert_int_equal(ts->actual_attrs.alpha_size, 0);
212 assert_int_equal(ts->actual_attrs.depth_size, 0);
213 assert_int_equal(ts->actual_attrs.stencil_size, 0);
214 assert_int_equal(ts->actual_attrs.sample_buffers, false);
215 assert_int_equal(ts->actual_attrs.samples, 0);
216 assert_int_equal(ts->actual_attrs.double_buffered, true);
217 assert_int_equal(ts->actual_attrs.accum_buffer, false);
218 }
219
220 static void
test_wcore_config_attrs_bad_attr(void ** state)221 test_wcore_config_attrs_bad_attr(void **state) {
222 struct test_state_wcore_config_attrs *ts = *state;
223
224 const int32_t attrib_list[] = {
225 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
226 WAFFLE_CONTEXT_CORE_PROFILE, WAFFLE_CONTEXT_OPENGL_ES2,
227 0,
228 };
229
230 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
231 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
232 }
233
234 static void
test_wcore_config_attrs_gl31_none_profile(void ** state)235 test_wcore_config_attrs_gl31_none_profile(void **state) {
236 struct test_state_wcore_config_attrs *ts = *state;
237
238 const int32_t attrib_list[] = {
239 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
240 WAFFLE_CONTEXT_MAJOR_VERSION, 3,
241 WAFFLE_CONTEXT_MINOR_VERSION, 1,
242 WAFFLE_CONTEXT_PROFILE, WAFFLE_NONE,
243 0,
244 };
245
246 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
247 assert_int_equal(ts->actual_attrs.context_profile, WAFFLE_NONE);
248 }
249
250 static void
test_wcore_config_attrs_gl31_trash_profile(void ** state)251 test_wcore_config_attrs_gl31_trash_profile(void **state) {
252 struct test_state_wcore_config_attrs *ts = *state;
253
254 const int32_t attrib_list[] = {
255 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
256 WAFFLE_CONTEXT_MAJOR_VERSION, 3,
257 WAFFLE_CONTEXT_MINOR_VERSION, 1,
258 WAFFLE_CONTEXT_PROFILE, 0x314159,
259 0,
260 };
261
262 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
263 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
264 }
265
266 static void
test_wcore_config_attrs_gl31_core(void ** state)267 test_wcore_config_attrs_gl31_core(void **state) {
268 struct test_state_wcore_config_attrs *ts = *state;
269
270 const int32_t attrib_list[] = {
271 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
272 WAFFLE_CONTEXT_MAJOR_VERSION, 3,
273 WAFFLE_CONTEXT_MINOR_VERSION, 1,
274 WAFFLE_CONTEXT_PROFILE, WAFFLE_CONTEXT_CORE_PROFILE,
275 0,
276 };
277
278 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
279 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
280 }
281
282 static void
test_wcore_config_attrs_gl31_compat(void ** state)283 test_wcore_config_attrs_gl31_compat(void **state) {
284 struct test_state_wcore_config_attrs *ts = *state;
285
286 const int32_t attrib_list[] = {
287 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
288 WAFFLE_CONTEXT_MAJOR_VERSION, 3,
289 WAFFLE_CONTEXT_MINOR_VERSION, 1,
290 WAFFLE_CONTEXT_PROFILE, WAFFLE_CONTEXT_COMPATIBILITY_PROFILE,
291 0,
292 };
293
294 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
295 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
296 }
297
298 static void
test_wcore_config_attrs_gl32_none_profile(void ** state)299 test_wcore_config_attrs_gl32_none_profile(void **state) {
300 struct test_state_wcore_config_attrs *ts = *state;
301
302 const int32_t attrib_list[] = {
303 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
304 WAFFLE_CONTEXT_MAJOR_VERSION, 3,
305 WAFFLE_CONTEXT_MINOR_VERSION, 2,
306 WAFFLE_CONTEXT_PROFILE, WAFFLE_NONE,
307 0,
308 };
309
310 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
311 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
312 }
313
314 static void
test_wcore_config_attrs_gl32_trash_profile(void ** state)315 test_wcore_config_attrs_gl32_trash_profile(void **state) {
316 struct test_state_wcore_config_attrs *ts = *state;
317
318 const int32_t attrib_list[] = {
319 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
320 WAFFLE_CONTEXT_MAJOR_VERSION, 3,
321 WAFFLE_CONTEXT_MINOR_VERSION, 2,
322 WAFFLE_CONTEXT_PROFILE, 0x314159,
323 0,
324 };
325
326 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
327 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
328 }
329
330 static void
test_wcore_config_attrs_gl32_core(void ** state)331 test_wcore_config_attrs_gl32_core(void **state) {
332 struct test_state_wcore_config_attrs *ts = *state;
333
334 const int32_t attrib_list[] = {
335 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
336 WAFFLE_CONTEXT_MAJOR_VERSION, 3,
337 WAFFLE_CONTEXT_MINOR_VERSION, 2,
338 WAFFLE_CONTEXT_PROFILE, WAFFLE_CONTEXT_CORE_PROFILE,
339 0,
340 };
341
342 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
343 assert_int_equal(ts->actual_attrs.context_profile, WAFFLE_CONTEXT_CORE_PROFILE);
344 }
345
346 static void
test_wcore_config_attrs_gl32_compat(void ** state)347 test_wcore_config_attrs_gl32_compat(void **state) {
348 struct test_state_wcore_config_attrs *ts = *state;
349
350 const int32_t attrib_list[] = {
351 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
352 WAFFLE_CONTEXT_MAJOR_VERSION, 3,
353 WAFFLE_CONTEXT_MINOR_VERSION, 2,
354 WAFFLE_CONTEXT_PROFILE, WAFFLE_CONTEXT_COMPATIBILITY_PROFILE,
355 0,
356 };
357
358 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
359 assert_int_equal(ts->actual_attrs.context_profile, WAFFLE_CONTEXT_COMPATIBILITY_PROFILE);
360 }
361
362 static void
test_wcore_config_attrs_gles1_profile_is_checked(void ** state)363 test_wcore_config_attrs_gles1_profile_is_checked(void **state) {
364 struct test_state_wcore_config_attrs *ts = *state;
365
366 const int32_t attrib_list[] = {
367 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES1,
368 WAFFLE_CONTEXT_PROFILE, WAFFLE_CONTEXT_CORE_PROFILE,
369 0,
370 };
371
372 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
373 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
374 assert_true(strstr(wcore_error_get_info()->message, "WAFFLE_CONTEXT_PROFILE"));
375 }
376
377 static void
test_wcore_config_attrs_gles2_profile_is_checked(void ** state)378 test_wcore_config_attrs_gles2_profile_is_checked(void **state) {
379 struct test_state_wcore_config_attrs *ts = *state;
380
381 const int32_t attrib_list[] = {
382 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES2,
383 WAFFLE_CONTEXT_PROFILE, WAFFLE_CONTEXT_CORE_PROFILE,
384 0,
385 };
386
387 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
388 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
389 assert_true(strstr(wcore_error_get_info()->message, "WAFFLE_CONTEXT_PROFILE"));
390 }
391
392 static void
test_wcore_config_attrs_gles3_profile_is_checked(void ** state)393 test_wcore_config_attrs_gles3_profile_is_checked(void **state) {
394 struct test_state_wcore_config_attrs *ts = *state;
395
396 const int32_t attrib_list[] = {
397 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES3,
398 WAFFLE_CONTEXT_PROFILE, WAFFLE_CONTEXT_CORE_PROFILE,
399 0,
400 };
401
402 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
403 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
404 assert_true(strstr(wcore_error_get_info()->message, "WAFFLE_CONTEXT_PROFILE"));
405 }
406
407 static void
test_wcore_config_attrs_negative_minor_version(void ** state)408 test_wcore_config_attrs_negative_minor_version(void **state) {
409 struct test_state_wcore_config_attrs *ts = *state;
410
411 const int32_t attrib_list[] = {
412 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
413 WAFFLE_CONTEXT_MINOR_VERSION, -1,
414 0,
415 };
416
417 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
418 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
419 }
420
421 static void
test_wcore_config_attrs_gles10(void ** state)422 test_wcore_config_attrs_gles10(void **state) {
423 struct test_state_wcore_config_attrs *ts = *state;
424
425 const int32_t attrib_list[] = {
426 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES1,
427 WAFFLE_CONTEXT_MAJOR_VERSION, 1,
428 WAFFLE_CONTEXT_MINOR_VERSION, 0,
429 0,
430 };
431
432 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
433 assert_int_equal(ts->actual_attrs.context_major_version, 1);
434 assert_int_equal(ts->actual_attrs.context_minor_version, 0);
435 }
436
437 static void
test_wcore_config_attrs_gles11(void ** state)438 test_wcore_config_attrs_gles11(void **state) {
439 struct test_state_wcore_config_attrs *ts = *state;
440
441 const int32_t attrib_list[] = {
442 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES1,
443 WAFFLE_CONTEXT_MAJOR_VERSION, 1,
444 WAFFLE_CONTEXT_MINOR_VERSION, 1,
445 0,
446 };
447
448 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
449 assert_int_equal(ts->actual_attrs.context_major_version, 1);
450 assert_int_equal(ts->actual_attrs.context_minor_version, 1);
451 }
452
453 static void
test_wcore_config_attrs_gles20(void ** state)454 test_wcore_config_attrs_gles20(void **state) {
455 struct test_state_wcore_config_attrs *ts = *state;
456
457 const int32_t attrib_list[] = {
458 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES2,
459 WAFFLE_CONTEXT_MAJOR_VERSION, 2,
460 WAFFLE_CONTEXT_MINOR_VERSION, 0,
461 0,
462 };
463
464 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
465 assert_int_equal(ts->actual_attrs.context_major_version, 2);
466 assert_int_equal(ts->actual_attrs.context_minor_version, 0);
467 }
468
469 static void
test_wcore_config_attrs_gles21(void ** state)470 test_wcore_config_attrs_gles21(void **state) {
471 struct test_state_wcore_config_attrs *ts = *state;
472
473 const int32_t attrib_list[] = {
474 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES2,
475 WAFFLE_CONTEXT_MAJOR_VERSION, 2,
476 WAFFLE_CONTEXT_MINOR_VERSION, 1,
477 0,
478 };
479
480 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
481 assert_int_equal(ts->actual_attrs.context_major_version, 2);
482 assert_int_equal(ts->actual_attrs.context_minor_version, 1);
483 }
484
485 static void
test_wcore_config_attrs_gles30(void ** state)486 test_wcore_config_attrs_gles30(void **state) {
487 struct test_state_wcore_config_attrs *ts = *state;
488
489 const int32_t attrib_list[] = {
490 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES3,
491 WAFFLE_CONTEXT_MAJOR_VERSION, 3,
492 WAFFLE_CONTEXT_MINOR_VERSION, 0,
493 0,
494 };
495
496 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
497 assert_int_equal(ts->actual_attrs.context_major_version, 3);
498 assert_int_equal(ts->actual_attrs.context_minor_version, 0);
499 }
500
501 static void
test_wcore_config_attrs_gles31(void ** state)502 test_wcore_config_attrs_gles31(void **state) {
503 struct test_state_wcore_config_attrs *ts = *state;
504
505 const int32_t attrib_list[] = {
506 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES3,
507 WAFFLE_CONTEXT_MAJOR_VERSION, 3,
508 WAFFLE_CONTEXT_MINOR_VERSION, 1,
509 0,
510 };
511
512 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
513 assert_int_equal(ts->actual_attrs.context_major_version, 3);
514 assert_int_equal(ts->actual_attrs.context_minor_version, 1);
515 }
516
517 static void
test_wcore_config_attrs_color_buffer_size(void ** state)518 test_wcore_config_attrs_color_buffer_size(void **state) {
519 struct test_state_wcore_config_attrs *ts = *state;
520
521 const int32_t attrib_list[] = {
522 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
523
524 WAFFLE_SAMPLES, 4, // noise
525
526 WAFFLE_ALPHA_SIZE, 8,
527 WAFFLE_RED_SIZE, 5,
528 WAFFLE_GREEN_SIZE, 6,
529 0,
530 };
531
532 ts->expect_attrs.samples = 4;
533 ts->expect_attrs.alpha_size = 8;
534 ts->expect_attrs.red_size = 5;
535 ts->expect_attrs.green_size = 6;
536
537 ts->expect_attrs.rgb_size = 5 + 6;
538 ts->expect_attrs.rgba_size = 8 + 5 + 6;
539
540 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
541 assert_memory_equal(&ts->actual_attrs, &ts->expect_attrs, sizeof(ts->expect_attrs));
542 }
543
544 static void
test_wcore_config_attrs_double_buffered_is_true(void ** state)545 test_wcore_config_attrs_double_buffered_is_true(void **state) {
546 struct test_state_wcore_config_attrs *ts = *state;
547
548 const int32_t attrib_list[] = {
549 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
550 WAFFLE_DOUBLE_BUFFERED, 1,
551 0,
552 };
553
554 ts->expect_attrs.double_buffered = true;
555
556 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
557 assert_memory_equal(&ts->actual_attrs, &ts->expect_attrs, sizeof(ts->expect_attrs));
558 }
559
560 static void
test_wcore_config_attrs_double_buffered_is_false(void ** state)561 test_wcore_config_attrs_double_buffered_is_false(void **state) {
562 struct test_state_wcore_config_attrs *ts = *state;
563
564 const int32_t attrib_list[] = {
565 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
566 WAFFLE_DOUBLE_BUFFERED, 0,
567 0,
568 };
569
570 ts->expect_attrs.double_buffered = false;
571
572 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
573 assert_memory_equal(&ts->actual_attrs, &ts->expect_attrs, sizeof(ts->expect_attrs));
574 }
575
576 static void
test_wcore_config_attrs_double_buffered_is_bad(void ** state)577 test_wcore_config_attrs_double_buffered_is_bad(void **state) {
578 struct test_state_wcore_config_attrs *ts = *state;
579
580 const int32_t attrib_list[] = {
581 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
582 WAFFLE_DOUBLE_BUFFERED, 0x31415926,
583 0,
584 };
585
586 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
587 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
588 assert_true(strstr(wcore_error_get_info()->message, "WAFFLE_DOUBLE_BUFFERED"));
589 assert_true(strstr(wcore_error_get_info()->message, "0x31415926"));
590 }
591
592 static void
test_wcore_config_attrs_sample_buffers_is_bad(void ** state)593 test_wcore_config_attrs_sample_buffers_is_bad(void **state) {
594 struct test_state_wcore_config_attrs *ts = *state;
595
596 const int32_t attrib_list[] = {
597 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
598 WAFFLE_SAMPLE_BUFFERS, 0x31415926,
599 0,
600 };
601
602 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
603 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
604 assert_true(strstr(wcore_error_get_info()->message, "WAFFLE_SAMPLE_BUFFERS"));
605 assert_true(strstr(wcore_error_get_info()->message, "0x31415926"));
606 }
607
608 static void
test_wcore_config_attrs_accum_buffer_is_bad(void ** state)609 test_wcore_config_attrs_accum_buffer_is_bad(void **state) {
610 struct test_state_wcore_config_attrs *ts = *state;
611
612 const int32_t attrib_list[] = {
613 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
614 WAFFLE_ACCUM_BUFFER, 0x31415926,
615 0,
616 };
617
618 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
619 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
620 assert_true(strstr(wcore_error_get_info()->message, "WAFFLE_ACCUM_BUFFER"));
621 assert_true(strstr(wcore_error_get_info()->message, "0x31415926"));
622 }
623
624 static void
test_wcore_config_attrs_core_profile_and_accum_buffer(void ** state)625 test_wcore_config_attrs_core_profile_and_accum_buffer(void **state) {
626 struct test_state_wcore_config_attrs *ts = *state;
627
628 const int32_t attrib_list[] = {
629 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
630 WAFFLE_CONTEXT_MAJOR_VERSION, 3,
631 WAFFLE_CONTEXT_MINOR_VERSION, 2,
632 WAFFLE_CONTEXT_PROFILE, WAFFLE_CONTEXT_CORE_PROFILE,
633
634 WAFFLE_ACCUM_BUFFER, true,
635
636 0,
637 };
638
639 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
640 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
641 }
642
643 static void
test_wcore_config_attrs_negative_red(void ** state)644 test_wcore_config_attrs_negative_red(void **state) {
645 struct test_state_wcore_config_attrs *ts = *state;
646
647 const int32_t attrib_list[] = {
648 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
649 WAFFLE_RED_SIZE, -2,
650 0,
651 };
652
653 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
654 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
655 assert_true(strstr(wcore_error_get_info()->message, "WAFFLE_RED_SIZE"));
656 assert_true(strstr(wcore_error_get_info()->message, "-2"));
657 }
658
659 static void
test_wcore_config_attrs_negative_green(void ** state)660 test_wcore_config_attrs_negative_green(void **state) {
661 struct test_state_wcore_config_attrs *ts = *state;
662
663 const int32_t attrib_list[] = {
664 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
665 WAFFLE_GREEN_SIZE, -2,
666 0,
667 };
668
669 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
670 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
671 assert_true(strstr(wcore_error_get_info()->message, "WAFFLE_GREEN_SIZE"));
672 assert_true(strstr(wcore_error_get_info()->message, "-2"));
673 }
674
675 static void
test_wcore_config_attrs_negative_blue(void ** state)676 test_wcore_config_attrs_negative_blue(void **state) {
677 struct test_state_wcore_config_attrs *ts = *state;
678
679 const int32_t attrib_list[] = {
680 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
681 WAFFLE_BLUE_SIZE, -2,
682 0,
683 };
684
685 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
686 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
687 assert_true(strstr(wcore_error_get_info()->message, "WAFFLE_BLUE_SIZE"));
688 assert_true(strstr(wcore_error_get_info()->message, "-2"));
689 }
690
691 static void
test_wcore_config_attrs_negative_alpha(void ** state)692 test_wcore_config_attrs_negative_alpha(void **state) {
693 struct test_state_wcore_config_attrs *ts = *state;
694
695 const int32_t attrib_list[] = {
696 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
697 WAFFLE_ALPHA_SIZE, -2,
698 0,
699 };
700
701 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
702 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
703 assert_true(strstr(wcore_error_get_info()->message, "WAFFLE_ALPHA_SIZE"));
704 assert_true(strstr(wcore_error_get_info()->message, "-2"));
705 }
706
707 static void
test_wcore_config_attrs_negative_depth(void ** state)708 test_wcore_config_attrs_negative_depth(void **state) {
709 struct test_state_wcore_config_attrs *ts = *state;
710
711 const int32_t attrib_list[] = {
712 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
713 WAFFLE_DEPTH_SIZE, -2,
714 0,
715 };
716
717 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
718 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
719 assert_true(strstr(wcore_error_get_info()->message, "WAFFLE_DEPTH_SIZE"));
720 assert_true(strstr(wcore_error_get_info()->message, "-2"));
721 }
722
723 static void
test_wcore_config_attrs_negative_stencil(void ** state)724 test_wcore_config_attrs_negative_stencil(void **state) {
725 struct test_state_wcore_config_attrs *ts = *state;
726
727 const int32_t attrib_list[] = {
728 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
729 WAFFLE_STENCIL_SIZE, -2,
730 0,
731 };
732
733 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
734 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
735 assert_true(strstr(wcore_error_get_info()->message, "WAFFLE_STENCIL_SIZE"));
736 assert_true(strstr(wcore_error_get_info()->message, "-2"));
737 }
738
739 static void
test_wcore_config_attrs_negative_samples(void ** state)740 test_wcore_config_attrs_negative_samples(void **state) {
741 struct test_state_wcore_config_attrs *ts = *state;
742
743 const int32_t attrib_list[] = {
744 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
745 WAFFLE_SAMPLES, -2,
746 0,
747 };
748
749 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
750 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
751 assert_true(strstr(wcore_error_get_info()->message, "WAFFLE_SAMPLES"));
752 assert_true(strstr(wcore_error_get_info()->message, "-2"));
753 }
754
755
756 static void
test_wcore_config_attrs_forward_compat_gles1_emits_bad_attribute(void ** state)757 test_wcore_config_attrs_forward_compat_gles1_emits_bad_attribute(void **state) {
758 struct test_state_wcore_config_attrs *ts = *state;
759
760 const int32_t attrib_list[] = {
761 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES1,
762 WAFFLE_CONTEXT_FORWARD_COMPATIBLE, true,
763 0,
764 };
765
766 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
767 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
768 }
769
770 static void
test_wcore_config_attrs_forward_compat_gles2_emits_bad_attribute(void ** state)771 test_wcore_config_attrs_forward_compat_gles2_emits_bad_attribute(void **state) {
772 struct test_state_wcore_config_attrs *ts = *state;
773
774 const int32_t attrib_list[] = {
775 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES2,
776 WAFFLE_CONTEXT_FORWARD_COMPATIBLE, true,
777 0,
778 };
779
780 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
781 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
782 }
783
784 static void
test_wcore_config_attrs_forward_compat_gles3_emits_bad_attribute(void ** state)785 test_wcore_config_attrs_forward_compat_gles3_emits_bad_attribute(void **state) {
786 struct test_state_wcore_config_attrs *ts = *state;
787
788 const int32_t attrib_list[] = {
789 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES3,
790 WAFFLE_CONTEXT_FORWARD_COMPATIBLE, true,
791 0,
792 };
793
794 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
795 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
796 }
797
798 static void
test_wcore_config_attrs_forward_compat_gl_emits_bad_attribute(void ** state)799 test_wcore_config_attrs_forward_compat_gl_emits_bad_attribute(void **state) {
800 struct test_state_wcore_config_attrs *ts = *state;
801
802 const int32_t attrib_list[] = {
803 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
804 WAFFLE_CONTEXT_FORWARD_COMPATIBLE, true,
805 0,
806 };
807
808 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
809 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
810 }
811
812 static void
test_wcore_config_attrs_forward_compat_gl10_emits_bad_attribute(void ** state)813 test_wcore_config_attrs_forward_compat_gl10_emits_bad_attribute(void **state) {
814 struct test_state_wcore_config_attrs *ts = *state;
815
816 const int32_t attrib_list[] = {
817 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
818 WAFFLE_CONTEXT_MAJOR_VERSION, 1,
819 WAFFLE_CONTEXT_MAJOR_VERSION, 0,
820 WAFFLE_CONTEXT_FORWARD_COMPATIBLE, true,
821 0,
822 };
823
824 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
825 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
826 }
827
828 static void
test_wcore_config_attrs_forward_compat_gl21_emits_bad_attribute(void ** state)829 test_wcore_config_attrs_forward_compat_gl21_emits_bad_attribute(void **state) {
830 struct test_state_wcore_config_attrs *ts = *state;
831
832 const int32_t attrib_list[] = {
833 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
834 WAFFLE_CONTEXT_MAJOR_VERSION, 2,
835 WAFFLE_CONTEXT_MAJOR_VERSION, 1,
836 WAFFLE_CONTEXT_FORWARD_COMPATIBLE, true,
837 0,
838 };
839
840 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
841 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
842 }
843
844 static void
test_wcore_config_attrs_forward_compat_gl30(void ** state)845 test_wcore_config_attrs_forward_compat_gl30(void **state) {
846 struct test_state_wcore_config_attrs *ts = *state;
847
848 const int32_t attrib_list[] = {
849 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
850 WAFFLE_CONTEXT_MAJOR_VERSION, 3,
851 WAFFLE_CONTEXT_MAJOR_VERSION, 0,
852 WAFFLE_CONTEXT_FORWARD_COMPATIBLE, true,
853 0,
854 };
855
856 ts->expect_attrs.context_major_version = 3;
857 ts->expect_attrs.context_minor_version = 0;
858 ts->expect_attrs.context_forward_compatible = true;
859
860 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
861 assert_int_equal(wcore_error_get_code(), WAFFLE_NO_ERROR);
862 assert_memory_equal(&ts->actual_attrs, &ts->expect_attrs, sizeof(ts->expect_attrs));
863 }
864
865 static void
test_wcore_config_attrs_forward_compat_gl32(void ** state)866 test_wcore_config_attrs_forward_compat_gl32(void **state) {
867 struct test_state_wcore_config_attrs *ts = *state;
868
869 const int32_t attrib_list[] = {
870 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
871 WAFFLE_CONTEXT_MAJOR_VERSION, 3,
872 WAFFLE_CONTEXT_MINOR_VERSION, 2,
873 WAFFLE_CONTEXT_FORWARD_COMPATIBLE, true,
874 0,
875 };
876
877 ts->expect_attrs.context_major_version = 3;
878 ts->expect_attrs.context_minor_version = 2;
879 ts->expect_attrs.context_profile = WAFFLE_CONTEXT_CORE_PROFILE;
880 ts->expect_attrs.context_forward_compatible = true;
881
882 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
883 assert_int_equal(wcore_error_get_code(), WAFFLE_NO_ERROR);
884 assert_memory_equal(&ts->actual_attrs, &ts->expect_attrs, sizeof(ts->expect_attrs));
885 }
886
887 static void
test_wcore_config_attrs_forward_compat_gl41(void ** state)888 test_wcore_config_attrs_forward_compat_gl41(void **state) {
889 struct test_state_wcore_config_attrs *ts = *state;
890
891 const int32_t attrib_list[] = {
892 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
893 WAFFLE_CONTEXT_MAJOR_VERSION, 4,
894 WAFFLE_CONTEXT_MINOR_VERSION, 1,
895 WAFFLE_CONTEXT_FORWARD_COMPATIBLE, true,
896 0,
897 };
898
899 ts->expect_attrs.context_major_version = 4;
900 ts->expect_attrs.context_minor_version = 1;
901 ts->expect_attrs.context_profile = WAFFLE_CONTEXT_CORE_PROFILE;
902 ts->expect_attrs.context_forward_compatible = true;
903
904 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
905 assert_int_equal(wcore_error_get_code(), WAFFLE_NO_ERROR);
906 assert_memory_equal(&ts->actual_attrs, &ts->expect_attrs, sizeof(ts->expect_attrs));
907 }
908
909 static void
test_wcore_config_attrs_forward_compat_gl30_dont_care(void ** state)910 test_wcore_config_attrs_forward_compat_gl30_dont_care(void **state) {
911 struct test_state_wcore_config_attrs *ts = *state;
912
913 const int32_t attrib_list[] = {
914 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
915 WAFFLE_CONTEXT_MAJOR_VERSION, 3,
916 WAFFLE_CONTEXT_MAJOR_VERSION, 0,
917 WAFFLE_CONTEXT_FORWARD_COMPATIBLE, WAFFLE_DONT_CARE,
918 0,
919 };
920
921 ts->expect_attrs.context_major_version = 3;
922 ts->expect_attrs.context_minor_version = 0;
923 ts->expect_attrs.context_forward_compatible = false;
924
925 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
926 assert_int_equal(wcore_error_get_code(), WAFFLE_NO_ERROR);
927 assert_memory_equal(&ts->actual_attrs, &ts->expect_attrs, sizeof(ts->expect_attrs));
928 }
929
930 static void
test_wcore_config_attrs_forward_compat_gl30_bad_value(void ** state)931 test_wcore_config_attrs_forward_compat_gl30_bad_value(void **state) {
932 struct test_state_wcore_config_attrs *ts = *state;
933
934 const int32_t attrib_list[] = {
935 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
936 WAFFLE_CONTEXT_MAJOR_VERSION, 3,
937 WAFFLE_CONTEXT_MAJOR_VERSION, 0,
938 WAFFLE_CONTEXT_FORWARD_COMPATIBLE, 2,
939 0,
940 };
941
942 assert_false(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
943 assert_int_equal(wcore_error_get_code(), WAFFLE_ERROR_BAD_ATTRIBUTE);
944 assert_true(strstr(wcore_error_get_info()->message, "2"));
945 }
946
947 static void
test_wcore_config_attrs_debug_gl(void ** state)948 test_wcore_config_attrs_debug_gl(void **state) {
949 struct test_state_wcore_config_attrs *ts = *state;
950
951 const int32_t attrib_list[] = {
952 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
953 WAFFLE_CONTEXT_DEBUG, true,
954 0,
955 };
956
957 ts->expect_attrs.context_api = WAFFLE_CONTEXT_OPENGL;
958 ts->expect_attrs.context_debug = true;
959
960 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
961 assert_int_equal(wcore_error_get_code(), WAFFLE_NO_ERROR);
962 assert_memory_equal(&ts->actual_attrs, &ts->expect_attrs, sizeof(ts->expect_attrs));
963 }
964
965 static void
test_wcore_config_attrs_debug_gl21(void ** state)966 test_wcore_config_attrs_debug_gl21(void **state) {
967 struct test_state_wcore_config_attrs *ts = *state;
968
969 const int32_t attrib_list[] = {
970 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
971 WAFFLE_CONTEXT_MAJOR_VERSION, 2,
972 WAFFLE_CONTEXT_MINOR_VERSION, 1,
973 WAFFLE_CONTEXT_DEBUG, true,
974 0,
975 };
976
977 ts->expect_attrs.context_api = WAFFLE_CONTEXT_OPENGL;
978 ts->expect_attrs.context_major_version = 2;
979 ts->expect_attrs.context_minor_version = 1;
980 ts->expect_attrs.context_debug = true;
981
982 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
983 assert_int_equal(wcore_error_get_code(), WAFFLE_NO_ERROR);
984 assert_memory_equal(&ts->actual_attrs, &ts->expect_attrs, sizeof(ts->expect_attrs));
985 }
986
987 static void
test_wcore_config_attrs_debug_gl32_core(void ** state)988 test_wcore_config_attrs_debug_gl32_core(void **state) {
989 struct test_state_wcore_config_attrs *ts = *state;
990
991 const int32_t attrib_list[] = {
992 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
993 WAFFLE_CONTEXT_PROFILE, WAFFLE_CONTEXT_CORE_PROFILE,
994 WAFFLE_CONTEXT_MAJOR_VERSION, 3,
995 WAFFLE_CONTEXT_MINOR_VERSION, 2,
996 WAFFLE_CONTEXT_DEBUG, true,
997 0,
998 };
999
1000 ts->expect_attrs.context_api = WAFFLE_CONTEXT_OPENGL;
1001 ts->expect_attrs.context_profile = WAFFLE_CONTEXT_CORE_PROFILE;
1002 ts->expect_attrs.context_major_version = 3;
1003 ts->expect_attrs.context_minor_version = 2;
1004 ts->expect_attrs.context_debug = true;
1005
1006 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
1007 assert_int_equal(wcore_error_get_code(), WAFFLE_NO_ERROR);
1008 assert_memory_equal(&ts->actual_attrs, &ts->expect_attrs, sizeof(ts->expect_attrs));
1009 }
1010
1011 static void
test_wcore_config_attrs_debug_gl32_compat(void ** state)1012 test_wcore_config_attrs_debug_gl32_compat(void **state) {
1013 struct test_state_wcore_config_attrs *ts = *state;
1014
1015 const int32_t attrib_list[] = {
1016 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL,
1017 WAFFLE_CONTEXT_PROFILE, WAFFLE_CONTEXT_COMPATIBILITY_PROFILE,
1018 WAFFLE_CONTEXT_MAJOR_VERSION, 3,
1019 WAFFLE_CONTEXT_MINOR_VERSION, 2,
1020 WAFFLE_CONTEXT_DEBUG, true,
1021 0,
1022 };
1023
1024 ts->expect_attrs.context_api = WAFFLE_CONTEXT_OPENGL;
1025 ts->expect_attrs.context_profile = WAFFLE_CONTEXT_COMPATIBILITY_PROFILE;
1026 ts->expect_attrs.context_major_version = 3;
1027 ts->expect_attrs.context_minor_version = 2;
1028 ts->expect_attrs.context_debug = true;
1029
1030 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
1031 assert_int_equal(wcore_error_get_code(), WAFFLE_NO_ERROR);
1032 assert_memory_equal(&ts->actual_attrs, &ts->expect_attrs, sizeof(ts->expect_attrs));
1033 }
1034
1035 static void
test_wcore_config_attrs_debug_gles1(void ** state)1036 test_wcore_config_attrs_debug_gles1(void **state) {
1037 struct test_state_wcore_config_attrs *ts = *state;
1038
1039 const int32_t attrib_list[] = {
1040 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES1,
1041 WAFFLE_CONTEXT_DEBUG, true,
1042 0,
1043 };
1044
1045 ts->expect_attrs.context_api = WAFFLE_CONTEXT_OPENGL_ES1;
1046 ts->expect_attrs.context_major_version = 1;
1047 ts->expect_attrs.context_debug = true;
1048
1049 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
1050 assert_int_equal(wcore_error_get_code(), WAFFLE_NO_ERROR);
1051 assert_memory_equal(&ts->actual_attrs, &ts->expect_attrs, sizeof(ts->expect_attrs));
1052 }
1053
1054 static void
test_wcore_config_attrs_debug_gles2(void ** state)1055 test_wcore_config_attrs_debug_gles2(void **state) {
1056 struct test_state_wcore_config_attrs *ts = *state;
1057
1058 const int32_t attrib_list[] = {
1059 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES2,
1060 WAFFLE_CONTEXT_DEBUG, true,
1061 0,
1062 };
1063
1064 ts->expect_attrs.context_api = WAFFLE_CONTEXT_OPENGL_ES2;
1065 ts->expect_attrs.context_major_version = 2;
1066 ts->expect_attrs.context_debug = true;
1067
1068 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
1069 assert_int_equal(wcore_error_get_code(), WAFFLE_NO_ERROR);
1070 assert_memory_equal(&ts->actual_attrs, &ts->expect_attrs, sizeof(ts->expect_attrs));
1071 }
1072
1073 static void
test_wcore_config_attrs_debug_gles3(void ** state)1074 test_wcore_config_attrs_debug_gles3(void **state) {
1075 struct test_state_wcore_config_attrs *ts = *state;
1076
1077 const int32_t attrib_list[] = {
1078 WAFFLE_CONTEXT_API, WAFFLE_CONTEXT_OPENGL_ES3,
1079 WAFFLE_CONTEXT_DEBUG, true,
1080 0,
1081 };
1082
1083 ts->expect_attrs.context_api = WAFFLE_CONTEXT_OPENGL_ES3;
1084 ts->expect_attrs.context_major_version = 3;
1085 ts->expect_attrs.context_debug = true;
1086
1087 assert_true(wcore_config_attrs_parse(attrib_list, &ts->actual_attrs));
1088 assert_int_equal(wcore_error_get_code(), WAFFLE_NO_ERROR);
1089 assert_memory_equal(&ts->actual_attrs, &ts->expect_attrs, sizeof(ts->expect_attrs));
1090 }
1091
1092 int
main(void)1093 main(void) {
1094 const struct CMUnitTest tests[] = {
1095 #define unit_test_make(name) cmocka_unit_test_setup_teardown(name, setup, teardown)
1096
1097 unit_test_make(test_wcore_config_attrs_null_attrib_list),
1098 unit_test_make(test_wcore_config_attrs_empty_attrib_list),
1099 unit_test_make(test_wcore_config_attrs_gl_defaults),
1100 unit_test_make(test_wcore_config_attrs_gles1_defaults),
1101 unit_test_make(test_wcore_config_attrs_gles2_defaults),
1102 unit_test_make(test_wcore_config_attrs_gles3_defaults),
1103 unit_test_make(test_wcore_config_attrs_bad_attr),
1104 unit_test_make(test_wcore_config_attrs_gl31_none_profile),
1105 unit_test_make(test_wcore_config_attrs_gl31_trash_profile),
1106 unit_test_make(test_wcore_config_attrs_gl31_core),
1107 unit_test_make(test_wcore_config_attrs_gl31_compat),
1108 unit_test_make(test_wcore_config_attrs_gl32_none_profile),
1109 unit_test_make(test_wcore_config_attrs_gl32_trash_profile),
1110 unit_test_make(test_wcore_config_attrs_gl32_core),
1111 unit_test_make(test_wcore_config_attrs_gl32_compat),
1112 unit_test_make(test_wcore_config_attrs_gles1_profile_is_checked),
1113 unit_test_make(test_wcore_config_attrs_gles2_profile_is_checked),
1114 unit_test_make(test_wcore_config_attrs_gles3_profile_is_checked),
1115 unit_test_make(test_wcore_config_attrs_negative_minor_version),
1116 unit_test_make(test_wcore_config_attrs_gles10),
1117 unit_test_make(test_wcore_config_attrs_gles11),
1118 unit_test_make(test_wcore_config_attrs_gles20),
1119 unit_test_make(test_wcore_config_attrs_gles21),
1120 unit_test_make(test_wcore_config_attrs_gles30),
1121 unit_test_make(test_wcore_config_attrs_gles31),
1122 unit_test_make(test_wcore_config_attrs_color_buffer_size),
1123 unit_test_make(test_wcore_config_attrs_double_buffered_is_true),
1124 unit_test_make(test_wcore_config_attrs_double_buffered_is_false),
1125 unit_test_make(test_wcore_config_attrs_double_buffered_is_bad),
1126 unit_test_make(test_wcore_config_attrs_sample_buffers_is_bad),
1127 unit_test_make(test_wcore_config_attrs_accum_buffer_is_bad),
1128 unit_test_make(test_wcore_config_attrs_core_profile_and_accum_buffer),
1129 unit_test_make(test_wcore_config_attrs_negative_red),
1130 unit_test_make(test_wcore_config_attrs_negative_green),
1131 unit_test_make(test_wcore_config_attrs_negative_blue),
1132 unit_test_make(test_wcore_config_attrs_negative_alpha),
1133 unit_test_make(test_wcore_config_attrs_negative_depth),
1134 unit_test_make(test_wcore_config_attrs_negative_stencil),
1135 unit_test_make(test_wcore_config_attrs_negative_samples),
1136 unit_test_make(test_wcore_config_attrs_forward_compat_gles1_emits_bad_attribute),
1137 unit_test_make(test_wcore_config_attrs_forward_compat_gles2_emits_bad_attribute),
1138 unit_test_make(test_wcore_config_attrs_forward_compat_gles3_emits_bad_attribute),
1139 unit_test_make(test_wcore_config_attrs_forward_compat_gl_emits_bad_attribute),
1140 unit_test_make(test_wcore_config_attrs_forward_compat_gl10_emits_bad_attribute),
1141 unit_test_make(test_wcore_config_attrs_forward_compat_gl21_emits_bad_attribute),
1142 unit_test_make(test_wcore_config_attrs_forward_compat_gl30),
1143 unit_test_make(test_wcore_config_attrs_forward_compat_gl32),
1144 unit_test_make(test_wcore_config_attrs_forward_compat_gl41),
1145 unit_test_make(test_wcore_config_attrs_forward_compat_gl30_dont_care),
1146 unit_test_make(test_wcore_config_attrs_forward_compat_gl30_bad_value),
1147 unit_test_make(test_wcore_config_attrs_debug_gl),
1148 unit_test_make(test_wcore_config_attrs_debug_gl21),
1149 unit_test_make(test_wcore_config_attrs_debug_gl32_core),
1150 unit_test_make(test_wcore_config_attrs_debug_gl32_compat),
1151 unit_test_make(test_wcore_config_attrs_debug_gles1),
1152 unit_test_make(test_wcore_config_attrs_debug_gles2),
1153 unit_test_make(test_wcore_config_attrs_debug_gles3),
1154
1155 #undef unit_test_make
1156 };
1157
1158 return cmocka_run_group_tests(tests, NULL, NULL);
1159 }
1160