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