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