2 * Copyright © 2013 Intel Corporation
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
23 #include <gtest/gtest.h>
28 #include "glxclient.h"
29 #include "glx_error.h"
32 extern bool GetGLXScreenConfigs_called
;
33 extern struct glx_screen
*psc
;
35 struct attribute_test_vector
{
40 #define E(x) { # x, x }
44 static bool got_sigsegv
;
48 sigsegv_handler(int sig
)
55 static bool query_renderer_string_called
= false;
56 static bool query_renderer_integer_called
= false;
59 fake_query_renderer_integer(struct glx_screen
*psc
, int attribute
,
66 query_renderer_integer_called
= true;
72 fake_query_renderer_string(struct glx_screen
*psc
, int attribute
,
79 query_renderer_string_called
= true;
84 struct glx_screen_vtable fake_vtable
= {
87 fake_query_renderer_integer
,
88 fake_query_renderer_string
91 class query_renderer_string_test
: public ::testing::Test
{
94 virtual void TearDown();
96 struct glx_screen scr
;
98 struct sigaction old_sa
;
102 class query_renderer_integer_test
: public query_renderer_string_test
{
105 void query_renderer_string_test::SetUp()
107 memset(&scr
, 0, sizeof(scr
));
108 scr
.vtable
= &fake_vtable
;
113 sa
.sa_handler
= sigsegv_handler
;
114 sigemptyset(&sa
.sa_mask
);
116 sigaction(SIGSEGV
, &sa
, &old_sa
);
119 void query_renderer_string_test::TearDown()
121 sigaction(SIGSEGV
, &old_sa
, NULL
);
125 * glXQueryRendererStringMESA will return \c NULL if the query_render_string
126 * vtable entry is \c NULL. It will also not segfault.
128 TEST_F(query_renderer_string_test
, null_query_render_string
)
130 struct glx_screen_vtable vtable
= {
137 scr
.vtable
= &vtable
;
139 if (setjmp(jmp
) == 0) {
141 glXQueryRendererStringMESA(&dpy
, 0, 0, GLX_RENDERER_VENDOR_ID_MESA
);
142 EXPECT_EQ((char *)0, str
);
144 EXPECT_FALSE(got_sigsegv
);
149 * glXQueryRendererStringMESA will not call the screen query_render_string
150 * function with an invalid GLX enum value, and it will return NULL.
152 TEST_F(query_renderer_string_test
, invalid_attribute
)
154 static const attribute_test_vector invalid_attributes
[] = {
155 /* These values are just plain invalid for use with this extension.
161 E(GLX_RENDERER_VENDOR_ID_MESA
+ 0x10000),
162 E(GLX_RENDERER_DEVICE_ID_MESA
+ 0x10000),
164 /* These enums are part of the extension, but they are not allowed for
167 E(GLX_RENDERER_VERSION_MESA
),
168 E(GLX_RENDERER_ACCELERATED_MESA
),
169 E(GLX_RENDERER_VIDEO_MEMORY_MESA
),
170 E(GLX_RENDERER_UNIFIED_MEMORY_ARCHITECTURE_MESA
),
171 E(GLX_RENDERER_PREFERRED_PROFILE_MESA
),
172 E(GLX_RENDERER_OPENGL_CORE_PROFILE_VERSION_MESA
),
173 E(GLX_RENDERER_OPENGL_COMPATIBILITY_PROFILE_VERSION_MESA
),
174 E(GLX_RENDERER_OPENGL_ES_PROFILE_VERSION_MESA
),
175 E(GLX_RENDERER_OPENGL_ES2_PROFILE_VERSION_MESA
),
176 E(GLX_RENDERER_ID_MESA
),
179 for (unsigned i
= 0; i
< ARRAY_SIZE(invalid_attributes
); i
++) {
180 query_renderer_integer_called
= false;
181 query_renderer_string_called
= false;
184 glXQueryRendererStringMESA(&dpy
, 0, 0, invalid_attributes
[i
].value
);
185 EXPECT_EQ((char *)0, str
) << invalid_attributes
[i
].string
;
186 EXPECT_FALSE(query_renderer_integer_called
)
187 << invalid_attributes
[i
].string
;
188 EXPECT_FALSE(query_renderer_string_called
)
189 << invalid_attributes
[i
].string
;
194 * glXQueryRendererStringMESA will not call GetGLXScreenConfigs if the display
195 * pointer is \c NULL. It will also not segfault.
197 TEST_F(query_renderer_string_test
, null_display_pointer
)
199 if (setjmp(jmp
) == 0) {
200 GetGLXScreenConfigs_called
= false;
203 glXQueryRendererStringMESA(NULL
, 0, 0, GLX_RENDERER_VENDOR_ID_MESA
);
204 EXPECT_EQ((char *)0, str
);
205 EXPECT_FALSE(GetGLXScreenConfigs_called
);
207 EXPECT_FALSE(got_sigsegv
);
212 * glXQueryRendererStringMESA will return error if GetGLXScreenConfigs returns
213 * NULL. It will also not segfault.
215 TEST_F(query_renderer_string_test
, null_screen_pointer
)
219 if (setjmp(jmp
) == 0) {
220 GetGLXScreenConfigs_called
= false;
223 glXQueryRendererStringMESA(&dpy
, 0, 0, GLX_RENDERER_VENDOR_ID_MESA
);
224 EXPECT_EQ((char *)0, str
);
225 EXPECT_TRUE(GetGLXScreenConfigs_called
);
227 EXPECT_FALSE(got_sigsegv
);
232 * glXQueryRendererStringMESA will not call the screen query_render_string
233 * function if the renderer is invalid, and it will return NULL.
235 TEST_F(query_renderer_string_test
, invalid_renderer_index
)
237 static const int invalid_renderer_indices
[] = {
243 if (setjmp(jmp
) == 0) {
244 for (unsigned i
= 0; i
< ARRAY_SIZE(invalid_renderer_indices
); i
++) {
246 glXQueryRendererStringMESA(&dpy
, 0,
247 invalid_renderer_indices
[i
],
248 GLX_RENDERER_VENDOR_ID_MESA
);
249 EXPECT_EQ((char *)0, str
) << invalid_renderer_indices
[i
];
250 EXPECT_FALSE(query_renderer_integer_called
)
251 << invalid_renderer_indices
[i
];
252 EXPECT_FALSE(query_renderer_string_called
)
253 << invalid_renderer_indices
[i
];
256 EXPECT_FALSE(got_sigsegv
);
261 * glXQueryCurrentRendererStringMESA will return error if there is no context
262 * current. It will also not segfault.
264 TEST_F(query_renderer_string_test
, no_current_context
)
266 if (setjmp(jmp
) == 0) {
268 glXQueryCurrentRendererStringMESA(GLX_RENDERER_VENDOR_ID_MESA
);
269 EXPECT_EQ((char *)0, str
);
271 EXPECT_FALSE(got_sigsegv
);
276 * glXQueryCurrentRendererIntegerMESA will return \c NULL if the
277 * query_render_string vtable entry is \c NULL. It will also not segfault.
279 TEST_F(query_renderer_integer_test
, null_query_render_string
)
281 struct glx_screen_vtable vtable
= {
288 scr
.vtable
= &vtable
;
290 if (setjmp(jmp
) == 0) {
291 unsigned value
= 0xDEADBEEF;
292 Bool success
= glXQueryRendererIntegerMESA(&dpy
, 0, 0,
293 GLX_RENDERER_VENDOR_ID_MESA
,
295 EXPECT_FALSE(success
);
296 EXPECT_EQ(0xDEADBEEF, value
);
298 EXPECT_FALSE(got_sigsegv
);
303 * glXQueryCurrentRendererIntegerMESA will not call the screen
304 * query_render_string function with an invalid GLX enum value, and it will
307 TEST_F(query_renderer_integer_test
, invalid_attribute
)
309 static const attribute_test_vector invalid_attributes
[] = {
310 /* These values are just plain invalid for use with this extension.
316 E(GLX_RENDERER_VENDOR_ID_MESA
+ 0x10000),
317 E(GLX_RENDERER_DEVICE_ID_MESA
+ 0x10000),
318 E(GLX_RENDERER_VERSION_MESA
+ 0x10000),
319 E(GLX_RENDERER_ACCELERATED_MESA
+ 0x10000),
320 E(GLX_RENDERER_VIDEO_MEMORY_MESA
+ 0x10000),
321 E(GLX_RENDERER_UNIFIED_MEMORY_ARCHITECTURE_MESA
+ 0x10000),
322 E(GLX_RENDERER_PREFERRED_PROFILE_MESA
+ 0x10000),
323 E(GLX_RENDERER_OPENGL_CORE_PROFILE_VERSION_MESA
+ 0x10000),
324 E(GLX_RENDERER_OPENGL_COMPATIBILITY_PROFILE_VERSION_MESA
+ 0x10000),
325 E(GLX_RENDERER_OPENGL_ES_PROFILE_VERSION_MESA
+ 0x10000),
326 E(GLX_RENDERER_OPENGL_ES2_PROFILE_VERSION_MESA
+ 0x10000),
327 E(GLX_RENDERER_ID_MESA
+ 0x10000),
330 for (unsigned i
= 0; i
< ARRAY_SIZE(invalid_attributes
); i
++) {
331 query_renderer_integer_called
= false;
332 query_renderer_string_called
= false;
334 unsigned value
= 0xDEADBEEF;
336 glXQueryRendererIntegerMESA(&dpy
, 0, 0,
337 invalid_attributes
[i
].value
,
339 EXPECT_FALSE(success
) << invalid_attributes
[i
].string
;
340 EXPECT_EQ(0xDEADBEEF, value
) << invalid_attributes
[i
].string
;
341 EXPECT_FALSE(query_renderer_integer_called
)
342 << invalid_attributes
[i
].string
;
343 EXPECT_FALSE(query_renderer_string_called
)
344 << invalid_attributes
[i
].string
;
349 * glXQueryCurrentRendererIntegerMESA will not call GetGLXScreenConfigs if the
350 * display pointer is \c NULL. It will also not segfault.
352 TEST_F(query_renderer_integer_test
, null_display_pointer
)
354 if (setjmp(jmp
) == 0) {
355 GetGLXScreenConfigs_called
= false;
357 unsigned value
= 0xDEADBEEF;
359 glXQueryRendererIntegerMESA(NULL
, 0, 0, GLX_RENDERER_VENDOR_ID_MESA
,
361 EXPECT_FALSE(success
);
362 EXPECT_EQ(0xDEADBEEF, value
);
363 EXPECT_FALSE(GetGLXScreenConfigs_called
);
365 EXPECT_FALSE(got_sigsegv
);
370 * glXQueryCurrentRendererIntegerMESA will return error if GetGLXScreenConfigs
371 * returns NULL. It will also not segfault.
373 TEST_F(query_renderer_integer_test
, null_screen_pointer
)
377 if (setjmp(jmp
) == 0) {
378 GetGLXScreenConfigs_called
= false;
380 unsigned value
= 0xDEADBEEF;
382 glXQueryRendererIntegerMESA(&dpy
, 0, 0, GLX_RENDERER_VENDOR_ID_MESA
,
384 EXPECT_FALSE(success
);
385 EXPECT_EQ(0xDEADBEEF, value
);
386 EXPECT_TRUE(GetGLXScreenConfigs_called
);
388 EXPECT_FALSE(got_sigsegv
);
393 * glXQueryRendererIntegerMESA will not call the screen query_render_integer
394 * function if the renderer is invalid, and it will return NULL.
396 TEST_F(query_renderer_integer_test
, invalid_renderer_index
)
398 static const int invalid_renderer_indices
[] = {
404 if (setjmp(jmp
) == 0) {
405 for (unsigned i
= 0; i
< ARRAY_SIZE(invalid_renderer_indices
); i
++) {
406 unsigned value
= 0xDEADBEEF;
408 glXQueryRendererIntegerMESA(&dpy
, 0,
409 invalid_renderer_indices
[i
],
410 GLX_RENDERER_VENDOR_ID_MESA
,
412 EXPECT_FALSE(success
) << invalid_renderer_indices
[i
];
413 EXPECT_EQ(0xDEADBEEF, value
) << invalid_renderer_indices
[i
];
414 EXPECT_FALSE(query_renderer_integer_called
)
415 << invalid_renderer_indices
[i
];
416 EXPECT_FALSE(query_renderer_string_called
)
417 << invalid_renderer_indices
[i
];
420 EXPECT_FALSE(got_sigsegv
);
425 * glXQueryCurrentRendererIntegerMESA will return error if there is no context
426 * current. It will also not segfault.
428 TEST_F(query_renderer_integer_test
, no_current_context
)
430 if (setjmp(jmp
) == 0) {
431 unsigned value
= 0xDEADBEEF;
433 glXQueryCurrentRendererIntegerMESA(GLX_RENDERER_VENDOR_ID_MESA
,
435 EXPECT_FALSE(success
);
436 EXPECT_EQ(0xDEADBEEF, value
);
438 EXPECT_FALSE(got_sigsegv
);