src/glx/tests/query_renderer_unittest.cpp

   1 /*
   2  * Copyright © 2013 Intel Corporation
   3  *
   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:
  10  *
  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
  13  * Software.
  14  *
  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.
  22  */
  23 #include <gtest/gtest.h>
  24 #include <signal.h>
  25 #include <setjmp.h>
  26
  27 #include "glxclient.h"
  28 #include "glx_error.h"
  29
  30 extern bool GetGLXScreenConfigs_called;
  31 extern struct glx_screen *psc;
  32
  33 struct attribute_test_vector {
  34    const char *string;
  35    int value;
  36 };
  37
  38 #define E(x) { # x, x }
  39
  40
  41
  42 static bool got_sigsegv;
  43 static jmp_buf jmp;
  44
  45 static void
  46 sigsegv_handler(int sig)
  47 {
  48    (void) sig;
  49    got_sigsegv = true;
  50    longjmp(jmp, 1);
  51 }
  52
  53 static bool query_renderer_string_called = false;
  54 static bool query_renderer_integer_called = false;
  55
  56 static int
  57 fake_query_renderer_integer(struct glx_screen *psc, int attribute,
  58                             unsigned int *value)
  59 {
  60    (void) psc;
  61    (void) attribute;
  62    (void) value;
  63
  64    query_renderer_integer_called = true;
  65
  66    return -1;
  67 }
  68
  69 static int
  70 fake_query_renderer_string(struct glx_screen *psc, int attribute,
  71                            const char **value)
  72 {
  73    (void) psc;
  74    (void) attribute;
  75    (void) value;
  76
  77    query_renderer_string_called = true;
  78
  79    return -1;
  80 }
  81
  82 struct glx_screen_vtable fake_vtable = {
  83    NULL,
  84    NULL,
  85    fake_query_renderer_integer,
  86    fake_query_renderer_string
  87 };
  88
  89 class query_renderer_string_test : public ::testing::Test {
  90 public:
  91    virtual void SetUp();
  92    virtual void TearDown();
  93
  94    struct glx_screen scr;
  95    struct sigaction sa;
  96    struct sigaction old_sa;
  97    Display dpy;
  98 };
  99
 100 class query_renderer_integer_test : public query_renderer_string_test {
 101 };
 102
 103 void query_renderer_string_test::SetUp()
 104 {
 105    memset(&scr, 0, sizeof(scr));
 106    scr.vtable = &fake_vtable;
 107    psc = &scr;
 108
 109    got_sigsegv = false;
 110
 111    sa.sa_handler = sigsegv_handler;
 112    sigemptyset(&sa.sa_mask);
 113    sa.sa_flags = 0;
 114    sigaction(SIGSEGV, &sa, &old_sa);
 115 }
 116
 117 void query_renderer_string_test::TearDown()
 118 {
 119    sigaction(SIGSEGV, &old_sa, NULL);
 120 }
 121
 122 /**
 123  * glXQueryRendererStringMESA will return \c NULL if the query_render_string
 124  * vtable entry is \c NULL.  It will also not segfault.
 125  */
 126 TEST_F(query_renderer_string_test, null_query_render_string)
 127 {
 128    struct glx_screen_vtable vtable = {
 129       NULL,
 130       NULL,
 131       NULL,
 132       NULL
 133    };
 134
 135    scr.vtable = &vtable;
 136
 137    if (setjmp(jmp) == 0) {
 138       const char *str =
 139          glXQueryRendererStringMESA(&dpy, 0, 0, GLX_RENDERER_VENDOR_ID_MESA);
 140       EXPECT_EQ((char *)0, str);
 141    } else {
 142       EXPECT_FALSE(got_sigsegv);
 143    }
 144 }
 145
 146 /**
 147  * glXQueryRendererStringMESA will not call the screen query_render_string
 148  * function with an invalid GLX enum value, and it will return NULL.
 149  */
 150 TEST_F(query_renderer_string_test, invalid_attribute)
 151 {
 152    static const attribute_test_vector invalid_attributes[] = {
 153       /* These values are just plain invalid for use with this extension.
 154        */
 155       E(0),
 156       E(GLX_VENDOR),
 157       E(GLX_VERSION),
 158       E(GLX_EXTENSIONS),
 159       E(GLX_RENDERER_VENDOR_ID_MESA + 0x10000),
 160       E(GLX_RENDERER_DEVICE_ID_MESA + 0x10000),
 161
 162       /* These enums are part of the extension, but they are not allowed for
 163        * the string query.
 164        */
 165       E(GLX_RENDERER_VERSION_MESA),
 166       E(GLX_RENDERER_ACCELERATED_MESA),
 167       E(GLX_RENDERER_VIDEO_MEMORY_MESA),
 168       E(GLX_RENDERER_UNIFIED_MEMORY_ARCHITECTURE_MESA),
 169       E(GLX_RENDERER_PREFERRED_PROFILE_MESA),
 170       E(GLX_RENDERER_OPENGL_CORE_PROFILE_VERSION_MESA),
 171       E(GLX_RENDERER_OPENGL_COMPATIBILITY_PROFILE_VERSION_MESA),
 172       E(GLX_RENDERER_OPENGL_ES_PROFILE_VERSION_MESA),
 173       E(GLX_RENDERER_OPENGL_ES2_PROFILE_VERSION_MESA),
 174       E(GLX_RENDERER_ID_MESA),
 175    };
 176
 177    for (unsigned i = 0; i < ARRAY_SIZE(invalid_attributes); i++) {
 178       query_renderer_integer_called = false;
 179       query_renderer_string_called = false;
 180
 181       const char *str =
 182          glXQueryRendererStringMESA(&dpy, 0, 0, invalid_attributes[i].value);
 183       EXPECT_EQ((char *)0, str) << invalid_attributes[i].string;
 184       EXPECT_FALSE(query_renderer_integer_called)
 185          << invalid_attributes[i].string;
 186       EXPECT_FALSE(query_renderer_string_called)
 187          << invalid_attributes[i].string;
 188    }
 189 }
 190
 191 /**
 192  * glXQueryRendererStringMESA will not call GetGLXScreenConfigs if the display
 193  * pointer is \c NULL.  It will also not segfault.
 194  */
 195 TEST_F(query_renderer_string_test, null_display_pointer)
 196 {
 197    if (setjmp(jmp) == 0) {
 198       GetGLXScreenConfigs_called = false;
 199
 200       const char *str =
 201          glXQueryRendererStringMESA(NULL, 0, 0, GLX_RENDERER_VENDOR_ID_MESA);
 202       EXPECT_EQ((char *)0, str);
 203       EXPECT_FALSE(GetGLXScreenConfigs_called);
 204    } else {
 205       EXPECT_FALSE(got_sigsegv);
 206    }
 207 }
 208
 209 /**
 210  * glXQueryRendererStringMESA will return error if GetGLXScreenConfigs returns
 211  * NULL.  It will also not segfault.
 212  */
 213 TEST_F(query_renderer_string_test, null_screen_pointer)
 214 {
 215    psc = NULL;
 216
 217    if (setjmp(jmp) == 0) {
 218       GetGLXScreenConfigs_called = false;
 219
 220       const char *str =
 221          glXQueryRendererStringMESA(&dpy, 0, 0, GLX_RENDERER_VENDOR_ID_MESA);
 222       EXPECT_EQ((char *)0, str);
 223       EXPECT_TRUE(GetGLXScreenConfigs_called);
 224    } else {
 225       EXPECT_FALSE(got_sigsegv);
 226    }
 227 }
 228
 229 /**
 230  * glXQueryRendererStringMESA will not call the screen query_render_string
 231  * function if the renderer is invalid, and it will return NULL.
 232  */
 233 TEST_F(query_renderer_string_test, invalid_renderer_index)
 234 {
 235    static const int invalid_renderer_indices[] = {
 236       -1,
 237       1,
 238       999,
 239    };
 240
 241    if (setjmp(jmp) == 0) {
 242       for (unsigned i = 0; i < ARRAY_SIZE(invalid_renderer_indices); i++) {
 243          const char *str =
 244             glXQueryRendererStringMESA(&dpy, 0,
 245                                        invalid_renderer_indices[i],
 246                                        GLX_RENDERER_VENDOR_ID_MESA);
 247          EXPECT_EQ((char *)0, str) << invalid_renderer_indices[i];
 248          EXPECT_FALSE(query_renderer_integer_called)
 249             << invalid_renderer_indices[i];
 250          EXPECT_FALSE(query_renderer_string_called)
 251             << invalid_renderer_indices[i];
 252       }
 253    } else {
 254       EXPECT_FALSE(got_sigsegv);
 255    }
 256 }
 257
 258 /**
 259  * glXQueryCurrentRendererStringMESA will return error if there is no context
 260  * current.  It will also not segfault.
 261  */
 262 TEST_F(query_renderer_string_test, no_current_context)
 263 {
 264    if (setjmp(jmp) == 0) {
 265       const char *str =
 266          glXQueryCurrentRendererStringMESA(GLX_RENDERER_VENDOR_ID_MESA);
 267       EXPECT_EQ((char *)0, str);
 268    } else {
 269       EXPECT_FALSE(got_sigsegv);
 270    }
 271 }
 272
 273 /**
 274  * glXQueryCurrentRendererIntegerMESA will return \c NULL if the
 275  * query_render_string vtable entry is \c NULL.  It will also not segfault.
 276  */
 277 TEST_F(query_renderer_integer_test, null_query_render_string)
 278 {
 279    struct glx_screen_vtable vtable = {
 280       NULL,
 281       NULL,
 282       NULL,
 283       NULL
 284    };
 285
 286    scr.vtable = &vtable;
 287
 288    if (setjmp(jmp) == 0) {
 289       unsigned value = 0xDEADBEEF;
 290       Bool success = glXQueryRendererIntegerMESA(&dpy, 0, 0,
 291                                                  GLX_RENDERER_VENDOR_ID_MESA,
 292                                                  &value);
 293       EXPECT_FALSE(success);
 294       EXPECT_EQ(0xDEADBEEF, value);
 295    } else {
 296       EXPECT_FALSE(got_sigsegv);
 297    }
 298 }
 299
 300 /**
 301  * glXQueryCurrentRendererIntegerMESA will not call the screen
 302  * query_render_string function with an invalid GLX enum value, and it will
 303  * return NULL.
 304  */
 305 TEST_F(query_renderer_integer_test, invalid_attribute)
 306 {
 307    static const attribute_test_vector invalid_attributes[] = {
 308       /* These values are just plain invalid for use with this extension.
 309        */
 310       E(0),
 311       E(GLX_VENDOR),
 312       E(GLX_VERSION),
 313       E(GLX_EXTENSIONS),
 314       E(GLX_RENDERER_VENDOR_ID_MESA + 0x10000),
 315       E(GLX_RENDERER_DEVICE_ID_MESA + 0x10000),
 316       E(GLX_RENDERER_VERSION_MESA + 0x10000),
 317       E(GLX_RENDERER_ACCELERATED_MESA + 0x10000),
 318       E(GLX_RENDERER_VIDEO_MEMORY_MESA + 0x10000),
 319       E(GLX_RENDERER_UNIFIED_MEMORY_ARCHITECTURE_MESA + 0x10000),
 320       E(GLX_RENDERER_PREFERRED_PROFILE_MESA + 0x10000),
 321       E(GLX_RENDERER_OPENGL_CORE_PROFILE_VERSION_MESA + 0x10000),
 322       E(GLX_RENDERER_OPENGL_COMPATIBILITY_PROFILE_VERSION_MESA + 0x10000),
 323       E(GLX_RENDERER_OPENGL_ES_PROFILE_VERSION_MESA + 0x10000),
 324       E(GLX_RENDERER_OPENGL_ES2_PROFILE_VERSION_MESA + 0x10000),
 325       E(GLX_RENDERER_ID_MESA + 0x10000),
 326    };
 327
 328    for (unsigned i = 0; i < ARRAY_SIZE(invalid_attributes); i++) {
 329       query_renderer_integer_called = false;
 330       query_renderer_string_called = false;
 331
 332       unsigned value = 0xDEADBEEF;
 333       Bool success =
 334          glXQueryRendererIntegerMESA(&dpy, 0, 0,
 335                                      invalid_attributes[i].value,
 336                                      &value);
 337       EXPECT_FALSE(success) << invalid_attributes[i].string;
 338       EXPECT_EQ(0xDEADBEEF, value) << invalid_attributes[i].string;
 339       EXPECT_FALSE(query_renderer_integer_called)
 340          << invalid_attributes[i].string;
 341       EXPECT_FALSE(query_renderer_string_called)
 342          << invalid_attributes[i].string;
 343    }
 344 }
 345
 346 /**
 347  * glXQueryCurrentRendererIntegerMESA will not call GetGLXScreenConfigs if the
 348  * display pointer is \c NULL.  It will also not segfault.
 349  */
 350 TEST_F(query_renderer_integer_test, null_display_pointer)
 351 {
 352    if (setjmp(jmp) == 0) {
 353       GetGLXScreenConfigs_called = false;
 354
 355       unsigned value = 0xDEADBEEF;
 356       Bool success =
 357          glXQueryRendererIntegerMESA(NULL, 0, 0, GLX_RENDERER_VENDOR_ID_MESA,
 358                                      &value);
 359       EXPECT_FALSE(success);
 360       EXPECT_EQ(0xDEADBEEF, value);
 361       EXPECT_FALSE(GetGLXScreenConfigs_called);
 362    } else {
 363       EXPECT_FALSE(got_sigsegv);
 364    }
 365 }
 366
 367 /**
 368  * glXQueryCurrentRendererIntegerMESA will return error if GetGLXScreenConfigs
 369  * returns NULL.  It will also not segfault.
 370  */
 371 TEST_F(query_renderer_integer_test, null_screen_pointer)
 372 {
 373    psc = NULL;
 374
 375    if (setjmp(jmp) == 0) {
 376       GetGLXScreenConfigs_called = false;
 377
 378       unsigned value = 0xDEADBEEF;
 379       Bool success =
 380          glXQueryRendererIntegerMESA(&dpy, 0, 0, GLX_RENDERER_VENDOR_ID_MESA,
 381             &value);
 382       EXPECT_FALSE(success);
 383       EXPECT_EQ(0xDEADBEEF, value);
 384       EXPECT_TRUE(GetGLXScreenConfigs_called);
 385    } else {
 386       EXPECT_FALSE(got_sigsegv);
 387    }
 388 }
 389
 390 /**
 391  * glXQueryRendererIntegerMESA will not call the screen query_render_integer
 392  * function if the renderer is invalid, and it will return NULL.
 393  */
 394 TEST_F(query_renderer_integer_test, invalid_renderer_index)
 395 {
 396    static const int invalid_renderer_indices[] = {
 397       -1,
 398       1,
 399       999,
 400    };
 401
 402    if (setjmp(jmp) == 0) {
 403       for (unsigned i = 0; i < ARRAY_SIZE(invalid_renderer_indices); i++) {
 404          unsigned value = 0xDEADBEEF;
 405          Bool success =
 406             glXQueryRendererIntegerMESA(&dpy, 0,
 407                                         invalid_renderer_indices[i],
 408                                         GLX_RENDERER_VENDOR_ID_MESA,
 409                                         &value);
 410          EXPECT_FALSE(success) << invalid_renderer_indices[i];
 411          EXPECT_EQ(0xDEADBEEF, value) << invalid_renderer_indices[i];
 412          EXPECT_FALSE(query_renderer_integer_called)
 413             << invalid_renderer_indices[i];
 414          EXPECT_FALSE(query_renderer_string_called)
 415             << invalid_renderer_indices[i];
 416       }
 417    } else {
 418       EXPECT_FALSE(got_sigsegv);
 419    }
 420 }
 421
 422 /**
 423  * glXQueryCurrentRendererIntegerMESA will return error if there is no context
 424  * current.  It will also not segfault.
 425  */
 426 TEST_F(query_renderer_integer_test, no_current_context)
 427 {
 428    if (setjmp(jmp) == 0) {
 429       unsigned value = 0xDEADBEEF;
 430       Bool success =
 431          glXQueryCurrentRendererIntegerMESA(GLX_RENDERER_VENDOR_ID_MESA,
 432                                             &value);
 433       EXPECT_FALSE(success);
 434       EXPECT_EQ(0xDEADBEEF, value);
 435    } else {
 436       EXPECT_FALSE(got_sigsegv);
 437    }
 438 }