src/glx/tests/clientinfo_unittest.cpp

   1 /*
   2  * Copyright © 2011 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 <string.h>
  25
  26 extern "C" {
  27 #include "glxclient.h"
  28 }
  29
  30 #include <xcb/glx.h>
  31
  32 #include "mock_xdisplay.h"
  33 #include "fake_glx_screen.h"
  34
  35 /**
  36  * \name Wrappers around some X structures to make the more usable for tests
  37  */
  38 /*@{*/
  39 class fake_glx_screen;
  40
  41 class fake_glx_display : public glx_display {
  42 public:
  43    fake_glx_display(mock_XDisplay *dpy, int major, int minor)
  44    {
  45       this->next = 0;
  46       this->dpy = dpy;
  47       this->majorOpcode = 0;
  48       this->majorVersion = major;
  49       this->minorVersion = minor;
  50       this->serverGLXvendor = 0;
  51       this->serverGLXversion = 0;
  52       this->glXDrawHash = 0;
  53
  54       this->screens = new glx_screen *[dpy->nscreens];
  55       memset(this->screens, 0, sizeof(struct glx_screen *) * dpy->nscreens);
  56    }
  57
  58    ~fake_glx_display()
  59    {
  60       for (int i = 0; i < this->dpy->nscreens; i++) {
  61          if (this->screens[i] != NULL)
  62             delete this->screens[i];
  63       }
  64
  65       delete [] this->screens;
  66    }
  67
  68    void init_screen(int i, const char *ext);
  69 };
  70
  71 class glX_send_client_info_test : public ::testing::Test {
  72 public:
  73    glX_send_client_info_test();
  74    virtual ~glX_send_client_info_test();
  75    virtual void SetUp();
  76
  77    void common_protocol_expected_false_test(unsigned major, unsigned minor,
  78                                             const char *glx_ext, bool *value);
  79
  80    void common_protocol_expected_true_test(unsigned major, unsigned minor,
  81                                            const char *glx_ext, bool *value);
  82
  83    void create_single_screen_display(unsigned major, unsigned minor,
  84                                      const char *glx_ext);
  85
  86    void destroy_display();
  87
  88 protected:
  89    fake_glx_display *glx_dpy;
  90    mock_XDisplay *display;
  91 };
  92
  93 void
  94 fake_glx_display::init_screen(int i, const char *ext)
  95 {
  96    if (this->screens[i] != NULL)
  97       delete this->screens[i];
  98
  99    this->screens[i] = new fake_glx_screen(this, i, ext);
 100 }
 101 /*@}*/
 102
 103 static const char ext[] = "GL_XXX_dummy";
 104
 105 static bool ClientInfo_was_sent;
 106 static bool SetClientInfoARB_was_sent;
 107 static bool SetClientInfo2ARB_was_sent;
 108 static xcb_connection_t *connection_used;
 109 static int gl_ext_length;
 110 static char *gl_ext_string;
 111 static int glx_ext_length;
 112 static char *glx_ext_string;
 113 static int num_gl_versions;
 114 static uint32_t *gl_versions;
 115 static int glx_major;
 116 static int glx_minor;
 117
 118 extern "C" xcb_connection_t *
 119 XGetXCBConnection(Display *dpy)
 120 {
 121    return (xcb_connection_t *) 0xdeadbeef;
 122 }
 123
 124 extern "C" xcb_void_cookie_t
 125 xcb_glx_client_info(xcb_connection_t *c,
 126                     uint32_t major_version,
 127                     uint32_t minor_version,
 128                     uint32_t str_len,
 129                     const char *string)
 130 {
 131    xcb_void_cookie_t cookie;
 132
 133    ClientInfo_was_sent = true;
 134    connection_used = c;
 135
 136    gl_ext_string = (char *) malloc(str_len);
 137    memcpy(gl_ext_string, string, str_len);
 138    gl_ext_length = str_len;
 139
 140    glx_major = major_version;
 141    glx_minor = minor_version;
 142
 143    cookie.sequence = 0;
 144    return cookie;
 145 }
 146
 147 extern "C" xcb_void_cookie_t
 148 xcb_glx_set_client_info_arb(xcb_connection_t *c,
 149                             uint32_t major_version,
 150                             uint32_t minor_version,
 151                             uint32_t num_versions,
 152                             uint32_t gl_str_len,
 153                             uint32_t glx_str_len,
 154                             const uint32_t *versions,
 155                             const char *gl_string,
 156                             const char *glx_string)
 157 {
 158    xcb_void_cookie_t cookie;
 159
 160    SetClientInfoARB_was_sent = true;
 161    connection_used = c;
 162
 163    gl_ext_string = new char[gl_str_len];
 164    memcpy(gl_ext_string, gl_string, gl_str_len);
 165    gl_ext_length = gl_str_len;
 166
 167    glx_ext_string = new char[glx_str_len];
 168    memcpy(glx_ext_string, glx_string, glx_str_len);
 169    glx_ext_length = glx_str_len;
 170
 171    gl_versions = new uint32_t[num_versions * 2];
 172    memcpy(gl_versions, versions, sizeof(uint32_t) * num_versions * 2);
 173    num_gl_versions = num_versions;
 174
 175    glx_major = major_version;
 176    glx_minor = minor_version;
 177
 178    cookie.sequence = 0;
 179    return cookie;
 180 }
 181
 182 extern "C" xcb_void_cookie_t
 183 xcb_glx_set_client_info_2arb(xcb_connection_t *c,
 184                              uint32_t major_version,
 185                              uint32_t minor_version,
 186                              uint32_t num_versions,
 187                              uint32_t gl_str_len,
 188                              uint32_t glx_str_len,
 189                              const uint32_t *versions,
 190                              const char *gl_string,
 191                              const char *glx_string)
 192 {
 193    xcb_void_cookie_t cookie;
 194
 195    SetClientInfo2ARB_was_sent = true;
 196    connection_used = c;
 197
 198    gl_ext_string = new char[gl_str_len];
 199    memcpy(gl_ext_string, gl_string, gl_str_len);
 200    gl_ext_length = gl_str_len;
 201
 202    glx_ext_string = new char[glx_str_len];
 203    memcpy(glx_ext_string, glx_string, glx_str_len);
 204    glx_ext_length = glx_str_len;
 205
 206    gl_versions = new uint32_t[num_versions * 3];
 207    memcpy(gl_versions, versions, sizeof(uint32_t) * num_versions * 3);
 208    num_gl_versions = num_versions;
 209
 210    glx_major = major_version;
 211    glx_minor = minor_version;
 212
 213    cookie.sequence = 0;
 214    return cookie;
 215 }
 216
 217 extern "C" char *
 218 __glXGetClientGLExtensionString()
 219 {
 220    char *str = (char *) malloc(sizeof(ext));
 221
 222    memcpy(str, ext, sizeof(ext));
 223    return str;
 224 }
 225
 226 glX_send_client_info_test::glX_send_client_info_test()
 227    : glx_dpy(0), display(0)
 228 {
 229    /* empty */
 230 }
 231
 232 glX_send_client_info_test::~glX_send_client_info_test()
 233 {
 234    if (glx_dpy)
 235       delete glx_dpy;
 236
 237    if (display)
 238       delete display;
 239 }
 240
 241 void
 242 glX_send_client_info_test::destroy_display()
 243 {
 244    if (this->glx_dpy != NULL) {
 245       if (this->glx_dpy->screens != NULL) {
 246          for (int i = 0; i < this->display->nscreens; i++) {
 247             delete [] this->glx_dpy->screens[i]->serverGLXexts;
 248             delete this->glx_dpy->screens[i];
 249          }
 250
 251          delete [] this->glx_dpy->screens;
 252       }
 253
 254       delete this->glx_dpy;
 255       delete this->display;
 256    }
 257 }
 258
 259 void
 260 glX_send_client_info_test::SetUp()
 261 {
 262    ClientInfo_was_sent = false;
 263    SetClientInfoARB_was_sent = false;
 264    SetClientInfo2ARB_was_sent = false;
 265    connection_used = (xcb_connection_t *) ~0;
 266    gl_ext_length = 0;
 267    gl_ext_string = (char *) 0;
 268    glx_ext_length = 0;
 269    glx_ext_string = (char *) 0;
 270    num_gl_versions = 0;
 271    gl_versions = (uint32_t *) 0;
 272    glx_major = 0;
 273    glx_minor = 0;
 274 }
 275
 276 void
 277 glX_send_client_info_test::create_single_screen_display(unsigned major,
 278                                                         unsigned minor,
 279                                                         const char *glx_ext)
 280 {
 281    this->display = new mock_XDisplay(1);
 282
 283    this->glx_dpy = new fake_glx_display(this->display, major, minor);
 284    this->glx_dpy->init_screen(0, glx_ext);
 285 }
 286
 287 void
 288 glX_send_client_info_test::common_protocol_expected_false_test(unsigned major,
 289                                                                unsigned minor,
 290                                                                const char *glx_ext,
 291                                                                bool *value)
 292 {
 293    create_single_screen_display(major, minor, glx_ext);
 294    __glX_send_client_info(this->glx_dpy);
 295    EXPECT_FALSE(*value);
 296 }
 297
 298 void
 299 glX_send_client_info_test::common_protocol_expected_true_test(unsigned major,
 300                                                               unsigned minor,
 301                                                               const char *glx_ext,
 302                                                               bool *value)
 303 {
 304    create_single_screen_display(major, minor, glx_ext);
 305    __glX_send_client_info(this->glx_dpy);
 306    EXPECT_TRUE(*value);
 307 }
 308
 309 TEST_F(glX_send_client_info_test, doesnt_send_ClientInfo_for_1_0)
 310 {
 311    /* The glXClientInfo protocol was added in GLX 1.1.  Verify that no
 312     * glXClientInfo is sent to a GLX server that only has GLX 1.0.
 313     */
 314    common_protocol_expected_false_test(1, 0, "", &ClientInfo_was_sent);
 315 }
 316
 317 TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfoARB_for_1_0)
 318 {
 319    /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
 320     * GLX_ARB_create_context extension.  Verify that no glXSetClientInfoARB is
 321     * sent to a GLX server that only has GLX 1.0 regardless of the extension
 322     * setting.
 323     */
 324    common_protocol_expected_false_test(1, 0,
 325                                        "GLX_ARB_create_context",
 326                                        &SetClientInfoARB_was_sent);
 327 }
 328
 329 TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfoARB_for_1_1)
 330 {
 331    /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
 332     * GLX_ARB_create_context extension.  Verify that no glXSetClientInfoARB is
 333     * sent to a GLX server that only has GLX 1.0 regardless of the extension
 334     * setting.
 335     */
 336    common_protocol_expected_false_test(1, 1,
 337                                        "GLX_ARB_create_context",
 338                                        &SetClientInfoARB_was_sent);
 339 }
 340
 341 TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfoARB_for_1_4_with_empty_extensions)
 342 {
 343    /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
 344     * GLX_ARB_create_context extension.  Verify that no glXSetClientInfoARB is
 345     * sent to a GLX server that has GLX 1.4 but has an empty extension string
 346     * (i.e., no extensions at all).
 347     */
 348    common_protocol_expected_false_test(1, 4,
 349                                        "",
 350                                        &SetClientInfoARB_was_sent);
 351 }
 352
 353 TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfoARB_for_1_4_without_extension)
 354 {
 355    /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
 356     * GLX_ARB_create_context extension.  Verify that no glXSetClientInfoARB is
 357     * sent to a GLX server that has GLX 1.4 but doesn't have the extension.
 358     */
 359    common_protocol_expected_false_test(1, 4,
 360                                        "GLX_EXT_texture_from_pixmap",
 361                                        &SetClientInfoARB_was_sent);
 362 }
 363
 364 TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfoARB_for_1_4_with_wrong_extension)
 365 {
 366    /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
 367     * GLX_ARB_create_context extension.  Verify that no glXSetClientInfoARB is
 368     * sent to a GLX server that has GLX 1.4 but does not have the extension.
 369     *
 370     * This test differs from
 371     * doesnt_send_SetClientInfoARB_for_1_4_without_extension in that an
 372     * extension exists that looks like the correct extension but isn't.
 373     */
 374    common_protocol_expected_false_test(1, 4,
 375                                        "GLX_ARB_create_context2",
 376                                        &SetClientInfoARB_was_sent);
 377 }
 378
 379 TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfoARB_for_1_4_with_profile_extension)
 380 {
 381    /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
 382     * GLX_ARB_create_context extension.  Verify that no glXSetClientInfoARB is
 383     * sent to a GLX server that has GLX 1.4 but does not have the extension.
 384     *
 385     * This test differs from
 386     * doesnt_send_SetClientInfoARB_for_1_4_without_extension in that an
 387     * extension exists that looks like the correct extension but isn't.
 388     */
 389    common_protocol_expected_false_test(1, 4,
 390                                        "GLX_ARB_create_context_profile",
 391                                        &SetClientInfoARB_was_sent);
 392 }
 393
 394 TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfo2ARB_for_1_0)
 395 {
 396    /* The glXSetClientInfo2ARB protocol was added in GLX 1.4 with the
 397     * GLX_ARB_create_context_profile extension.  Verify that no
 398     * glXSetClientInfo2ARB is sent to a GLX server that only has GLX 1.0
 399     * regardless of the extension setting.
 400     */
 401    common_protocol_expected_false_test(1, 0,
 402                                        "GLX_ARB_create_context_profile",
 403                                        &SetClientInfo2ARB_was_sent);
 404 }
 405
 406 TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfo2ARB_for_1_1)
 407 {
 408    /* The glXSetClientInfo2ARB protocol was added in GLX 1.4 with the
 409     * GLX_ARB_create_context_profile extension.  Verify that no
 410     * glXSetClientInfo2ARB is sent to a GLX server that only has GLX 1.1
 411     * regardless of the extension setting.
 412     */
 413    common_protocol_expected_false_test(1, 1,
 414                                        "GLX_ARB_create_context_profile",
 415                                        &SetClientInfo2ARB_was_sent);
 416 }
 417
 418 TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfo2ARB_for_1_4_with_empty_extensions)
 419 {
 420    /* The glXSetClientInfo2ARB protocol was added in GLX 1.4 with the
 421     * GLX_ARB_create_context_profile extension.  Verify that no
 422     * glXSetClientInfo2ARB is sent to a GLX server that has GLX 1.4 but has an
 423     * empty extension string (i.e., no extensions at all).
 424     */
 425    common_protocol_expected_false_test(1, 4,
 426                                        "",
 427                                        &SetClientInfo2ARB_was_sent);
 428 }
 429
 430 TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfo2ARB_for_1_4_without_extension)
 431 {
 432    /* The glXSetClientInfo2ARB protocol was added in GLX 1.4 with the
 433     * GLX_ARB_create_context_profile extension.  Verify that no
 434     * glXSetClientInfo2ARB is sent to a GLX server that has GLX 1.4 but
 435     * doesn't have the extension.
 436     */
 437    common_protocol_expected_false_test(1, 4,
 438                                        "GLX_EXT_texture_from_pixmap",
 439                                        &SetClientInfo2ARB_was_sent);
 440 }
 441
 442 TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfo2ARB_for_1_4_with_wrong_extension)
 443 {
 444    /* The glXSetClientInfo2ARB protocol was added in GLX 1.4 with the
 445     * GLX_ARB_create_context_profile extension.  Verify that no
 446     * glXSetClientInfo2ARB is sent to a GLX server that has GLX 1.4 but does
 447     * not have the extension.
 448     *
 449     * This test differs from
 450     * doesnt_send_SetClientInfo2ARB_for_1_4_without_extension in that an
 451     * extension exists that looks like the correct extension but isn't.
 452     */
 453    common_protocol_expected_false_test(1, 4,
 454                                        "GLX_ARB_create_context_profile2",
 455                                        &SetClientInfo2ARB_was_sent);
 456 }
 457
 458 TEST_F(glX_send_client_info_test, does_send_ClientInfo_for_1_1)
 459 {
 460    /* The glXClientInfo protocol was added in GLX 1.1.  Verify that
 461     * glXClientInfo is sent to a GLX server that has GLX 1.1.
 462     */
 463    common_protocol_expected_true_test(1, 1,
 464                                       "",
 465                                       &ClientInfo_was_sent);
 466 }
 467
 468 TEST_F(glX_send_client_info_test, does_send_SetClientInfoARB_for_1_4_with_extension)
 469 {
 470    /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
 471     * GLX_ARB_create_context extension.  Verify that glXSetClientInfoARB is
 472     * sent to a GLX server that has GLX 1.4 and the extension.
 473     */
 474    common_protocol_expected_true_test(1, 4,
 475                                       "GLX_ARB_create_context",
 476                                       &SetClientInfoARB_was_sent);
 477 }
 478
 479 TEST_F(glX_send_client_info_test, does_send_SetClientInfo2ARB_for_1_4_with_just_profile_extension)
 480 {
 481    /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
 482     * GLX_ARB_create_context extension.  Verify that glXSetClientInfoARB is
 483     * sent to a GLX server that has GLX 1.4 and the extension.
 484     */
 485    common_protocol_expected_true_test(1, 4,
 486                                       "GLX_ARB_create_context_profile",
 487                                       &SetClientInfo2ARB_was_sent);
 488 }
 489
 490 TEST_F(glX_send_client_info_test, does_send_SetClientInfo2ARB_for_1_4_with_both_extensions)
 491 {
 492    /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
 493     * GLX_ARB_create_context extension.  Verify that glXSetClientInfoARB is
 494     * sent to a GLX server that has GLX 1.4 and the extension.
 495     */
 496    common_protocol_expected_true_test(1, 4,
 497                                       "GLX_ARB_create_context "
 498                                       "GLX_ARB_create_context_profile",
 499                                       &SetClientInfo2ARB_was_sent);
 500 }
 501
 502 TEST_F(glX_send_client_info_test, does_send_SetClientInfo2ARB_for_1_4_with_both_extensions_reversed)
 503 {
 504    /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
 505     * GLX_ARB_create_context extension.  Verify that glXSetClientInfoARB is
 506     * sent to a GLX server that has GLX 1.4 and the extension.
 507     */
 508    common_protocol_expected_true_test(1, 4,
 509                                       "GLX_ARB_create_context_profile "
 510                                       "GLX_ARB_create_context",
 511                                       &SetClientInfo2ARB_was_sent);
 512 }
 513
 514 TEST_F(glX_send_client_info_test, uses_correct_connection)
 515 {
 516    create_single_screen_display(1, 1, "");
 517    __glX_send_client_info(this->glx_dpy);
 518    EXPECT_EQ((xcb_connection_t *) 0xdeadbeef, connection_used);
 519 }
 520
 521 TEST_F(glX_send_client_info_test, sends_correct_gl_extension_string)
 522 {
 523    create_single_screen_display(1, 1, "");
 524    __glX_send_client_info(this->glx_dpy);
 525
 526    ASSERT_EQ(sizeof(ext), gl_ext_length);
 527    ASSERT_NE((char *) 0, gl_ext_string);
 528    EXPECT_EQ(0, memcmp(gl_ext_string, ext, sizeof(ext)));
 529 }
 530
 531 TEST_F(glX_send_client_info_test, gl_versions_are_sane)
 532 {
 533    create_single_screen_display(1, 4, "GLX_ARB_create_context");
 534    __glX_send_client_info(this->glx_dpy);
 535
 536    ASSERT_NE(0, num_gl_versions);
 537
 538    unsigned versions_below_3_0 = 0;
 539    for (int i = 0; i < num_gl_versions; i++) {
 540       EXPECT_LT(0, gl_versions[i * 2]);
 541       EXPECT_GE(4, gl_versions[i * 2]);
 542
 543       /* Verify that the minor version advertised with the major version makes
 544        * sense.
 545        */
 546       switch (gl_versions[i * 2]) {
 547       case 1:
 548          EXPECT_GE(5, gl_versions[i * 2 + 1]);
 549          versions_below_3_0++;
 550          break;
 551       case 2:
 552          EXPECT_GE(1, gl_versions[i * 2 + 1]);
 553          versions_below_3_0++;
 554          break;
 555       case 3:
 556          EXPECT_GE(3, gl_versions[i * 2 + 1]);
 557          break;
 558       case 4:
 559          EXPECT_GE(2, gl_versions[i * 2 + 1]);
 560          break;
 561       }
 562    }
 563
 564    /* From the GLX_ARB_create_context spec:
 565     *
 566     *     "Only the highest supported version below 3.0 should be sent, since
 567     *     OpenGL 2.1 is backwards compatible with all earlier versions."
 568     */
 569    EXPECT_LE(versions_below_3_0, 1);
 570 }
 571
 572 TEST_F(glX_send_client_info_test, gl_versions_and_profiles_are_sane)
 573 {
 574    create_single_screen_display(1, 4, "GLX_ARB_create_context_profile");
 575    __glX_send_client_info(this->glx_dpy);
 576
 577    ASSERT_NE(0, num_gl_versions);
 578
 579    const uint32_t all_valid_bits = GLX_CONTEXT_CORE_PROFILE_BIT_ARB
 580       | GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
 581
 582    unsigned versions_below_3_0 = 0;
 583
 584    for (int i = 0; i < num_gl_versions; i++) {
 585       EXPECT_LT(0, gl_versions[i * 3]);
 586       EXPECT_GE(4, gl_versions[i * 3]);
 587
 588       /* Verify that the minor version advertised with the major version makes
 589        * sense.
 590        */
 591       switch (gl_versions[i * 3]) {
 592       case 1:
 593          EXPECT_GE(5, gl_versions[i * 3 + 1]);
 594          EXPECT_EQ(0, gl_versions[i * 3 + 2]);
 595          versions_below_3_0++;
 596          break;
 597       case 2:
 598          EXPECT_GE(1, gl_versions[i * 3 + 1]);
 599          EXPECT_EQ(0, gl_versions[i * 3 + 2]);
 600          versions_below_3_0++;
 601          break;
 602       case 3:
 603          EXPECT_GE(3, gl_versions[i * 3 + 1]);
 604
 605          /* Profiles were not introduced until OpenGL 3.2.
 606           */
 607          if (gl_versions[i * 3 + 1] < 2) {
 608             EXPECT_EQ(0, gl_versions[i * 3 + 2]);
 609          } else {
 610             EXPECT_EQ(0, gl_versions[i * 3 + 2] & ~all_valid_bits);
 611          }
 612          break;
 613       case 4:
 614          EXPECT_GE(2, gl_versions[i * 3 + 1]);
 615          EXPECT_EQ(0, gl_versions[i * 3 + 2] & ~all_valid_bits);
 616          break;
 617       }
 618    }
 619
 620    /* From the GLX_ARB_create_context_profile spec:
 621     *
 622     *     "Only the highest supported version below 3.0 should be sent, since
 623     *     OpenGL 2.1 is backwards compatible with all earlier versions."
 624     */
 625    EXPECT_LE(versions_below_3_0, 1);
 626 }
 627
 628 TEST_F(glX_send_client_info_test, glx_version_is_1_4_for_1_1)
 629 {
 630    create_single_screen_display(1, 1, "");
 631    __glX_send_client_info(this->glx_dpy);
 632
 633    EXPECT_EQ(1, glx_major);
 634    EXPECT_EQ(4, glx_minor);
 635 }
 636
 637 TEST_F(glX_send_client_info_test, glx_version_is_1_4_for_1_4)
 638 {
 639    create_single_screen_display(1, 4, "");
 640    __glX_send_client_info(this->glx_dpy);
 641
 642    EXPECT_EQ(1, glx_major);
 643    EXPECT_EQ(4, glx_minor);
 644 }
 645
 646 TEST_F(glX_send_client_info_test, glx_version_is_1_4_for_1_4_with_ARB_create_context)
 647 {
 648    create_single_screen_display(1, 4, "GLX_ARB_create_context");
 649    __glX_send_client_info(this->glx_dpy);
 650
 651    EXPECT_EQ(1, glx_major);
 652    EXPECT_EQ(4, glx_minor);
 653 }
 654
 655 TEST_F(glX_send_client_info_test, glx_version_is_1_4_for_1_4_with_ARB_create_context_profile)
 656 {
 657    create_single_screen_display(1, 4, "GLX_ARB_create_context_profile");
 658    __glX_send_client_info(this->glx_dpy);
 659
 660    EXPECT_EQ(1, glx_major);
 661    EXPECT_EQ(4, glx_minor);
 662 }
 663
 664 TEST_F(glX_send_client_info_test, glx_version_is_1_4_for_1_5)
 665 {
 666    create_single_screen_display(1, 5, "");
 667    __glX_send_client_info(this->glx_dpy);
 668
 669    EXPECT_EQ(1, glx_major);
 670    EXPECT_EQ(4, glx_minor);
 671 }
 672
 673 TEST_F(glX_send_client_info_test, glx_extensions_has_GLX_ARB_create_context)
 674 {
 675    create_single_screen_display(1, 4, "GLX_ARB_create_context");
 676    __glX_send_client_info(this->glx_dpy);
 677
 678    ASSERT_NE(0, glx_ext_length);
 679    ASSERT_NE((char *) 0, glx_ext_string);
 680
 681    bool found_GLX_ARB_create_context = false;
 682    const char *const needle = "GLX_ARB_create_context";
 683    const unsigned len = strlen(needle);
 684    char *haystack = glx_ext_string;
 685    while (haystack != NULL) {
 686       char *match = strstr(haystack, needle);
 687
 688       if (match[len] == '\0' || match[len] == ' ') {
 689          found_GLX_ARB_create_context = true;
 690          break;
 691       }
 692
 693       haystack = match + len;
 694    }
 695
 696    EXPECT_TRUE(found_GLX_ARB_create_context);
 697 }
 698
 699 TEST_F(glX_send_client_info_test, glx_extensions_has_GLX_ARB_create_context_profile)
 700 {
 701    create_single_screen_display(1, 4, "GLX_ARB_create_context_profile");
 702    __glX_send_client_info(this->glx_dpy);
 703
 704    ASSERT_NE(0, glx_ext_length);
 705    ASSERT_NE((char *) 0, glx_ext_string);
 706
 707    bool found_GLX_ARB_create_context_profile = false;
 708    const char *const needle = "GLX_ARB_create_context_profile";
 709    const unsigned len = strlen(needle);
 710    char *haystack = glx_ext_string;
 711    while (haystack != NULL) {
 712       char *match = strstr(haystack, needle);
 713
 714       if (match[len] == '\0' || match[len] == ' ') {
 715          found_GLX_ARB_create_context_profile = true;
 716          break;
 717       }
 718
 719       haystack = match + len;
 720    }
 721
 722    EXPECT_TRUE(found_GLX_ARB_create_context_profile);
 723 }