tests/glx: Add unit tests for GLX_ARB_create_context GLX protocol

This adds a new tests directory at the top-level and some extra build
infrastructure.  The tests use the Google C++ Testing Framework, and
they will only be built if configure can detect its availability.  The
tests are automatically wired-in to run with 'make check'.

Signed-off-by: Ian Romanick <[email protected]>
Acked-by: Chad Versace <[email protected]>

1 files changed, 723 insertions, 0 deletions

diff --git a/tests/glx/clientinfo_unittest.cpp b/tests/glx/clientinfo_unittest.cpp
new file mode 100644
index 00000000000..f599c833a66
--- /dev/null
+++ b/tests/glx/clientinfo_unittest.cpp
@@ -0,0 +1,723 @@
+/*
+ * Copyright © 2011 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include <gtest/gtest.h>
+#include <string.h>
+
+extern "C" {
+#include "glxclient.h"
+}
+
+#include <xcb/glx.h>
+
+#include "mock_xdisplay.h"
+#include "fake_glx_screen.h"
+
+/**
+ * \name Wrappers around some X structures to make the more usable for tests
+ */
+/*@{*/
+class fake_glx_screen;
+
+class fake_glx_display : public glx_display {
+public:
+   fake_glx_display(mock_XDisplay *dpy, int major, int minor)
+   {
+      this->next = 0;
+      this->dpy = dpy;
+      this->majorOpcode = 0;
+      this->majorVersion = major;
+      this->minorVersion = minor;
+      this->serverGLXvendor = 0;
+      this->serverGLXversion = 0;
+      this->glXDrawHash = 0;
+
+      this->screens = new glx_screen *[dpy->nscreens];
+      memset(this->screens, 0, sizeof(struct glx_screen *) * dpy->nscreens);
+   }
+
+   ~fake_glx_display()
+   {
+      for (int i = 0; i < this->dpy->nscreens; i++) {
+	 if (this->screens[i] != NULL)
+	    delete this->screens[i];
+      }
+
+      delete [] this->screens;
+   }
+
+   void init_screen(int i, const char *ext);
+};
+
+class glX_send_client_info_test : public ::testing::Test {
+public:
+   glX_send_client_info_test();
+   virtual ~glX_send_client_info_test();
+   virtual void SetUp();
+
+   void common_protocol_expected_false_test(unsigned major, unsigned minor,
+					    const char *glx_ext, bool *value);
+
+   void common_protocol_expected_true_test(unsigned major, unsigned minor,
+					   const char *glx_ext, bool *value);
+
+   void create_single_screen_display(unsigned major, unsigned minor,
+				     const char *glx_ext);
+
+   void destroy_display();
+
+protected:
+   fake_glx_display *glx_dpy;
+   mock_XDisplay *display;
+};
+
+void
+fake_glx_display::init_screen(int i, const char *ext)
+{
+   if (this->screens[i] != NULL)
+      delete this->screens[i];
+
+   this->screens[i] = new fake_glx_screen(this, i, ext);
+}
+/*@}*/
+
+static const char ext[] = "GL_XXX_dummy";
+
+static bool ClientInfo_was_sent;
+static bool SetClientInfoARB_was_sent;
+static bool SetClientInfo2ARB_was_sent;
+static xcb_connection_t *connection_used;
+static int gl_ext_length;
+static char *gl_ext_string;
+static int glx_ext_length;
+static char *glx_ext_string;
+static int num_gl_versions;
+static uint32_t *gl_versions;
+static int glx_major;
+static int glx_minor;
+
+extern "C" xcb_connection_t *
+XGetXCBConnection(Display *dpy)
+{
+   return (xcb_connection_t *) 0xdeadbeef;
+}
+
+extern "C" xcb_void_cookie_t
+xcb_glx_client_info(xcb_connection_t *c,
+		    uint32_t major_version,
+		    uint32_t minor_version,
+		    uint32_t str_len,
+		    const char *string)
+{
+   xcb_void_cookie_t cookie;
+
+   ClientInfo_was_sent = true;
+   connection_used = c;
+
+   gl_ext_string = (char *) malloc(str_len);
+   memcpy(gl_ext_string, string, str_len);
+   gl_ext_length = str_len;
+
+   glx_major = major_version;
+   glx_minor = minor_version;
+
+   cookie.sequence = 0;
+   return cookie;
+}
+
+extern "C" xcb_void_cookie_t
+xcb_glx_set_client_info_arb(xcb_connection_t *c,
+			    uint32_t major_version,
+			    uint32_t minor_version,
+			    uint32_t num_versions,
+			    uint32_t gl_str_len,
+			    uint32_t glx_str_len,
+			    const uint32_t *versions,
+			    const char *gl_string,
+			    const char *glx_string)
+{
+   xcb_void_cookie_t cookie;
+
+   SetClientInfoARB_was_sent = true;
+   connection_used = c;
+
+   gl_ext_string = new char[gl_str_len];
+   memcpy(gl_ext_string, gl_string, gl_str_len);
+   gl_ext_length = gl_str_len;
+
+   glx_ext_string = new char[glx_str_len];
+   memcpy(glx_ext_string, glx_string, glx_str_len);
+   glx_ext_length = glx_str_len;
+
+   gl_versions = new uint32_t[num_versions * 2];
+   memcpy(gl_versions, versions, sizeof(uint32_t) * num_versions * 2);
+   num_gl_versions = num_versions;
+
+   glx_major = major_version;
+   glx_minor = minor_version;
+
+   cookie.sequence = 0;
+   return cookie;
+}
+
+extern "C" xcb_void_cookie_t
+xcb_glx_set_client_info_2arb(xcb_connection_t *c,
+			     uint32_t major_version,
+			     uint32_t minor_version,
+			     uint32_t num_versions,
+			     uint32_t gl_str_len,
+			     uint32_t glx_str_len,
+			     const uint32_t *versions,
+			     const char *gl_string,
+			     const char *glx_string)
+{
+   xcb_void_cookie_t cookie;
+
+   SetClientInfo2ARB_was_sent = true;
+   connection_used = c;
+
+   gl_ext_string = new char[gl_str_len];
+   memcpy(gl_ext_string, gl_string, gl_str_len);
+   gl_ext_length = gl_str_len;
+
+   glx_ext_string = new char[glx_str_len];
+   memcpy(glx_ext_string, glx_string, glx_str_len);
+   glx_ext_length = glx_str_len;
+
+   gl_versions = new uint32_t[num_versions * 3];
+   memcpy(gl_versions, versions, sizeof(uint32_t) * num_versions * 3);
+   num_gl_versions = num_versions;
+
+   glx_major = major_version;
+   glx_minor = minor_version;
+
+   cookie.sequence = 0;
+   return cookie;
+}
+
+extern "C" char *
+__glXGetClientGLExtensionString()
+{
+   char *str = (char *) malloc(sizeof(ext));
+
+   memcpy(str, ext, sizeof(ext));
+   return str;
+}
+
+glX_send_client_info_test::glX_send_client_info_test()
+   : glx_dpy(0), display(0)
+{
+   /* empty */
+}
+
+glX_send_client_info_test::~glX_send_client_info_test()
+{
+   if (glx_dpy)
+      delete glx_dpy;
+
+   if (display)
+      delete display;
+}
+
+void
+glX_send_client_info_test::destroy_display()
+{
+   if (this->glx_dpy != NULL) {
+      if (this->glx_dpy->screens != NULL) {
+	 for (int i = 0; i < this->display->nscreens; i++) {
+	    delete [] this->glx_dpy->screens[i]->serverGLXexts;
+	    delete this->glx_dpy->screens[i];
+	 }
+
+	 delete [] this->glx_dpy->screens;
+      }
+
+      delete this->glx_dpy;
+      delete this->display;
+   }
+}
+
+void
+glX_send_client_info_test::SetUp()
+{
+   ClientInfo_was_sent = false;
+   SetClientInfoARB_was_sent = false;
+   SetClientInfo2ARB_was_sent = false;
+   connection_used = (xcb_connection_t *) ~0;
+   gl_ext_length = 0;
+   gl_ext_string = (char *) 0;
+   glx_ext_length = 0;
+   glx_ext_string = (char *) 0;
+   num_gl_versions = 0;
+   gl_versions = (uint32_t *) 0;
+   glx_major = 0;
+   glx_minor = 0;
+}
+
+void
+glX_send_client_info_test::create_single_screen_display(unsigned major,
+							unsigned minor,
+							const char *glx_ext)
+{
+   this->display = new mock_XDisplay(1);
+
+   this->glx_dpy = new fake_glx_display(this->display, major, minor);
+   this->glx_dpy->init_screen(0, glx_ext);
+}
+
+void
+glX_send_client_info_test::common_protocol_expected_false_test(unsigned major,
+							       unsigned minor,
+							       const char *glx_ext,
+							       bool *value)
+{
+   create_single_screen_display(major, minor, glx_ext);
+   __glX_send_client_info(this->glx_dpy);
+   EXPECT_FALSE(*value);
+}
+
+void
+glX_send_client_info_test::common_protocol_expected_true_test(unsigned major,
+							      unsigned minor,
+							      const char *glx_ext,
+							      bool *value)
+{
+   create_single_screen_display(major, minor, glx_ext);
+   __glX_send_client_info(this->glx_dpy);
+   EXPECT_TRUE(*value);
+}
+
+TEST_F(glX_send_client_info_test, doesnt_send_ClientInfo_for_1_0)
+{
+   /* The glXClientInfo protocol was added in GLX 1.1.  Verify that no
+    * glXClientInfo is sent to a GLX server that only has GLX 1.0.
+    */
+   common_protocol_expected_false_test(1, 0, "", &ClientInfo_was_sent);
+}
+
+TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfoARB_for_1_0)
+{
+   /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
+    * GLX_ARB_create_context extension.  Verify that no glXSetClientInfoARB is
+    * sent to a GLX server that only has GLX 1.0 regardless of the extension
+    * setting.
+    */
+   common_protocol_expected_false_test(1, 0,
+				       "GLX_ARB_create_context",
+				       &SetClientInfoARB_was_sent);
+}
+
+TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfoARB_for_1_1)
+{
+   /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
+    * GLX_ARB_create_context extension.  Verify that no glXSetClientInfoARB is
+    * sent to a GLX server that only has GLX 1.0 regardless of the extension
+    * setting.
+    */
+   common_protocol_expected_false_test(1, 1,
+				       "GLX_ARB_create_context",
+				       &SetClientInfoARB_was_sent);
+}
+
+TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfoARB_for_1_4_with_empty_extensions)
+{
+   /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
+    * GLX_ARB_create_context extension.  Verify that no glXSetClientInfoARB is
+    * sent to a GLX server that has GLX 1.4 but has an empty extension string
+    * (i.e., no extensions at all).
+    */
+   common_protocol_expected_false_test(1, 4,
+				       "",
+				       &SetClientInfoARB_was_sent);
+}
+
+TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfoARB_for_1_4_without_extension)
+{
+   /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
+    * GLX_ARB_create_context extension.  Verify that no glXSetClientInfoARB is
+    * sent to a GLX server that has GLX 1.4 but doesn't have the extension.
+    */
+   common_protocol_expected_false_test(1, 4,
+				       "GLX_EXT_texture_from_pixmap",
+				       &SetClientInfoARB_was_sent);
+}
+
+TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfoARB_for_1_4_with_wrong_extension)
+{
+   /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
+    * GLX_ARB_create_context extension.  Verify that no glXSetClientInfoARB is
+    * sent to a GLX server that has GLX 1.4 but does not have the extension.
+    *
+    * This test differs from
+    * doesnt_send_SetClientInfoARB_for_1_4_without_extension in that an
+    * extension exists that looks like the correct extension but isn't.
+    */
+   common_protocol_expected_false_test(1, 4,
+				       "GLX_ARB_create_context2",
+				       &SetClientInfoARB_was_sent);
+}
+
+TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfoARB_for_1_4_with_profile_extension)
+{
+   /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
+    * GLX_ARB_create_context extension.  Verify that no glXSetClientInfoARB is
+    * sent to a GLX server that has GLX 1.4 but does not have the extension.
+    *
+    * This test differs from
+    * doesnt_send_SetClientInfoARB_for_1_4_without_extension in that an
+    * extension exists that looks like the correct extension but isn't.
+    */
+   common_protocol_expected_false_test(1, 4,
+				       "GLX_ARB_create_context_profile",
+				       &SetClientInfoARB_was_sent);
+}
+
+TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfo2ARB_for_1_0)
+{
+   /* The glXSetClientInfo2ARB protocol was added in GLX 1.4 with the
+    * GLX_ARB_create_context_profile extension.  Verify that no
+    * glXSetClientInfo2ARB is sent to a GLX server that only has GLX 1.0
+    * regardless of the extension setting.
+    */
+   common_protocol_expected_false_test(1, 0,
+				       "GLX_ARB_create_context_profile",
+				       &SetClientInfo2ARB_was_sent);
+}
+
+TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfo2ARB_for_1_1)
+{
+   /* The glXSetClientInfo2ARB protocol was added in GLX 1.4 with the
+    * GLX_ARB_create_context_profile extension.  Verify that no
+    * glXSetClientInfo2ARB is sent to a GLX server that only has GLX 1.1
+    * regardless of the extension setting.
+    */
+   common_protocol_expected_false_test(1, 1,
+				       "GLX_ARB_create_context_profile",
+				       &SetClientInfo2ARB_was_sent);
+}
+
+TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfo2ARB_for_1_4_with_empty_extensions)
+{
+   /* The glXSetClientInfo2ARB protocol was added in GLX 1.4 with the
+    * GLX_ARB_create_context_profile extension.  Verify that no
+    * glXSetClientInfo2ARB is sent to a GLX server that has GLX 1.4 but has an
+    * empty extension string (i.e., no extensions at all).
+    */
+   common_protocol_expected_false_test(1, 4,
+				       "",
+				       &SetClientInfo2ARB_was_sent);
+}
+
+TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfo2ARB_for_1_4_without_extension)
+{
+   /* The glXSetClientInfo2ARB protocol was added in GLX 1.4 with the
+    * GLX_ARB_create_context_profile extension.  Verify that no
+    * glXSetClientInfo2ARB is sent to a GLX server that has GLX 1.4 but
+    * doesn't have the extension.
+    */
+   common_protocol_expected_false_test(1, 4,
+				       "GLX_EXT_texture_from_pixmap",
+				       &SetClientInfo2ARB_was_sent);
+}
+
+TEST_F(glX_send_client_info_test, doesnt_send_SetClientInfo2ARB_for_1_4_with_wrong_extension)
+{
+   /* The glXSetClientInfo2ARB protocol was added in GLX 1.4 with the
+    * GLX_ARB_create_context_profile extension.  Verify that no
+    * glXSetClientInfo2ARB is sent to a GLX server that has GLX 1.4 but does
+    * not have the extension.
+    *
+    * This test differs from
+    * doesnt_send_SetClientInfo2ARB_for_1_4_without_extension in that an
+    * extension exists that looks like the correct extension but isn't.
+    */
+   common_protocol_expected_false_test(1, 4,
+				       "GLX_ARB_create_context_profile2",
+				       &SetClientInfo2ARB_was_sent);
+}
+
+TEST_F(glX_send_client_info_test, does_send_ClientInfo_for_1_1)
+{
+   /* The glXClientInfo protocol was added in GLX 1.1.  Verify that
+    * glXClientInfo is sent to a GLX server that has GLX 1.1.
+    */
+   common_protocol_expected_true_test(1, 1,
+				      "",
+				      &ClientInfo_was_sent);
+}
+
+TEST_F(glX_send_client_info_test, does_send_SetClientInfoARB_for_1_4_with_extension)
+{
+   /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
+    * GLX_ARB_create_context extension.  Verify that glXSetClientInfoARB is
+    * sent to a GLX server that has GLX 1.4 and the extension.
+    */
+   common_protocol_expected_true_test(1, 4,
+				      "GLX_ARB_create_context",
+				      &SetClientInfoARB_was_sent);
+}
+
+TEST_F(glX_send_client_info_test, does_send_SetClientInfo2ARB_for_1_4_with_just_profile_extension)
+{
+   /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
+    * GLX_ARB_create_context extension.  Verify that glXSetClientInfoARB is
+    * sent to a GLX server that has GLX 1.4 and the extension.
+    */
+   common_protocol_expected_true_test(1, 4,
+				      "GLX_ARB_create_context_profile",
+				      &SetClientInfo2ARB_was_sent);
+}
+
+TEST_F(glX_send_client_info_test, does_send_SetClientInfo2ARB_for_1_4_with_both_extensions)
+{
+   /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
+    * GLX_ARB_create_context extension.  Verify that glXSetClientInfoARB is
+    * sent to a GLX server that has GLX 1.4 and the extension.
+    */
+   common_protocol_expected_true_test(1, 4,
+				      "GLX_ARB_create_context "
+				      "GLX_ARB_create_context_profile",
+				      &SetClientInfo2ARB_was_sent);
+}
+
+TEST_F(glX_send_client_info_test, does_send_SetClientInfo2ARB_for_1_4_with_both_extensions_reversed)
+{
+   /* The glXSetClientInfoARB protocol was added in GLX 1.4 with the
+    * GLX_ARB_create_context extension.  Verify that glXSetClientInfoARB is
+    * sent to a GLX server that has GLX 1.4 and the extension.
+    */
+   common_protocol_expected_true_test(1, 4,
+				      "GLX_ARB_create_context_profile "
+				      "GLX_ARB_create_context",
+				      &SetClientInfo2ARB_was_sent);
+}
+
+TEST_F(glX_send_client_info_test, uses_correct_connection)
+{
+   create_single_screen_display(1, 1, "");
+   __glX_send_client_info(this->glx_dpy);
+   EXPECT_EQ((xcb_connection_t *) 0xdeadbeef, connection_used);
+}
+
+TEST_F(glX_send_client_info_test, sends_correct_gl_extension_string)
+{
+   create_single_screen_display(1, 1, "");
+   __glX_send_client_info(this->glx_dpy);
+
+   ASSERT_EQ(sizeof(ext), gl_ext_length);
+   ASSERT_NE((char *) 0, gl_ext_string);
+   EXPECT_EQ(0, memcmp(gl_ext_string, ext, sizeof(ext)));
+}
+
+TEST_F(glX_send_client_info_test, gl_versions_are_sane)
+{
+   create_single_screen_display(1, 4, "GLX_ARB_create_context");
+   __glX_send_client_info(this->glx_dpy);
+
+   ASSERT_NE(0, num_gl_versions);
+
+   unsigned versions_below_3_0 = 0;
+   for (int i = 0; i < num_gl_versions; i++) {
+      EXPECT_LT(0, gl_versions[i * 2]);
+      EXPECT_GE(4, gl_versions[i * 2]);
+
+      /* Verify that the minor version advertised with the major version makes
+       * sense.
+       */
+      switch (gl_versions[i * 2]) {
+      case 1:
+	 EXPECT_GE(5, gl_versions[i * 2 + 1]);
+	 versions_below_3_0++;
+	 break;
+      case 2:
+	 EXPECT_GE(1, gl_versions[i * 2 + 1]);
+	 versions_below_3_0++;
+	 break;
+      case 3:
+	 EXPECT_GE(3, gl_versions[i * 2 + 1]);
+	 break;
+      case 4:
+	 EXPECT_GE(2, gl_versions[i * 2 + 1]);
+	 break;
+      }
+   }
+
+   /* From the GLX_ARB_create_context spec:
+    *
+    *     "Only the highest supported version below 3.0 should be sent, since
+    *     OpenGL 2.1 is backwards compatible with all earlier versions."
+    */
+   EXPECT_LE(versions_below_3_0, 1);
+}
+
+TEST_F(glX_send_client_info_test, gl_versions_and_profiles_are_sane)
+{
+   create_single_screen_display(1, 4, "GLX_ARB_create_context_profile");
+   __glX_send_client_info(this->glx_dpy);
+
+   ASSERT_NE(0, num_gl_versions);
+
+   const uint32_t all_valid_bits = GLX_CONTEXT_CORE_PROFILE_BIT_ARB
+      | GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
+
+   unsigned versions_below_3_0 = 0;
+
+   for (int i = 0; i < num_gl_versions; i++) {
+      EXPECT_LT(0, gl_versions[i * 3]);
+      EXPECT_GE(4, gl_versions[i * 3]);
+
+      /* Verify that the minor version advertised with the major version makes
+       * sense.
+       */
+      switch (gl_versions[i * 3]) {
+      case 1:
+	 EXPECT_GE(5, gl_versions[i * 3 + 1]);
+	 EXPECT_EQ(0, gl_versions[i * 3 + 2]);
+	 versions_below_3_0++;
+	 break;
+      case 2:
+	 EXPECT_GE(1, gl_versions[i * 3 + 1]);
+	 EXPECT_EQ(0, gl_versions[i * 3 + 2]);
+	 versions_below_3_0++;
+	 break;
+      case 3:
+	 EXPECT_GE(3, gl_versions[i * 3 + 1]);
+
+	 /* Profiles were not introduced until OpenGL 3.2.
+	  */
+	 if (gl_versions[i * 3 + 1] < 2) {
+	    EXPECT_EQ(0, gl_versions[i * 3 + 2]);
+	 } else {
+	    EXPECT_EQ(0, gl_versions[i * 3 + 2] & ~all_valid_bits);
+	 }
+	 break;
+      case 4:
+	 EXPECT_GE(2, gl_versions[i * 3 + 1]);
+	 EXPECT_EQ(0, gl_versions[i * 3 + 2] & ~all_valid_bits);
+	 break;
+      }
+   }
+
+   /* From the GLX_ARB_create_context_profile spec:
+    *
+    *     "Only the highest supported version below 3.0 should be sent, since
+    *     OpenGL 2.1 is backwards compatible with all earlier versions."
+    */
+   EXPECT_LE(versions_below_3_0, 1);
+}
+
+TEST_F(glX_send_client_info_test, glx_version_is_1_4_for_1_1)
+{
+   create_single_screen_display(1, 1, "");
+   __glX_send_client_info(this->glx_dpy);
+
+   EXPECT_EQ(1, glx_major);
+   EXPECT_EQ(4, glx_minor);
+}
+
+TEST_F(glX_send_client_info_test, glx_version_is_1_4_for_1_4)
+{
+   create_single_screen_display(1, 4, "");
+   __glX_send_client_info(this->glx_dpy);
+
+   EXPECT_EQ(1, glx_major);
+   EXPECT_EQ(4, glx_minor);
+}
+
+TEST_F(glX_send_client_info_test, glx_version_is_1_4_for_1_4_with_ARB_create_context)
+{
+   create_single_screen_display(1, 4, "GLX_ARB_create_context");
+   __glX_send_client_info(this->glx_dpy);
+
+   EXPECT_EQ(1, glx_major);
+   EXPECT_EQ(4, glx_minor);
+}
+
+TEST_F(glX_send_client_info_test, glx_version_is_1_4_for_1_4_with_ARB_create_context_profile)
+{
+   create_single_screen_display(1, 4, "GLX_ARB_create_context_profile");
+   __glX_send_client_info(this->glx_dpy);
+
+   EXPECT_EQ(1, glx_major);
+   EXPECT_EQ(4, glx_minor);
+}
+
+TEST_F(glX_send_client_info_test, glx_version_is_1_4_for_1_5)
+{
+   create_single_screen_display(1, 5, "");
+   __glX_send_client_info(this->glx_dpy);
+
+   EXPECT_EQ(1, glx_major);
+   EXPECT_EQ(4, glx_minor);
+}
+
+TEST_F(glX_send_client_info_test, glx_extensions_has_GLX_ARB_create_context)
+{
+   create_single_screen_display(1, 4, "GLX_ARB_create_context");
+   __glX_send_client_info(this->glx_dpy);
+
+   ASSERT_NE(0, glx_ext_length);
+   ASSERT_NE((char *) 0, glx_ext_string);
+
+   bool found_GLX_ARB_create_context = false;
+   const char *const needle = "GLX_ARB_create_context";
+   const unsigned len = strlen(needle);
+   char *haystack = glx_ext_string;
+   while (haystack != NULL) {
+      char *match = strstr(haystack, needle);
+
+      if (match[len] == '\0' || match[len] == ' ') {
+	 found_GLX_ARB_create_context = true;
+	 break;
+      }
+
+      haystack = match + len;
+   }
+
+   EXPECT_TRUE(found_GLX_ARB_create_context);
+}
+
+TEST_F(glX_send_client_info_test, glx_extensions_has_GLX_ARB_create_context_profile)
+{
+   create_single_screen_display(1, 4, "GLX_ARB_create_context_profile");
+   __glX_send_client_info(this->glx_dpy);
+
+   ASSERT_NE(0, glx_ext_length);
+   ASSERT_NE((char *) 0, glx_ext_string);
+
+   bool found_GLX_ARB_create_context_profile = false;
+   const char *const needle = "GLX_ARB_create_context_profile";
+   const unsigned len = strlen(needle);
+   char *haystack = glx_ext_string;
+   while (haystack != NULL) {
+      char *match = strstr(haystack, needle);
+
+      if (match[len] == '\0' || match[len] == ' ') {
+	 found_GLX_ARB_create_context_profile = true;
+	 break;
+      }
+
+      haystack = match + len;
+   }
+
+   EXPECT_TRUE(found_GLX_ARB_create_context_profile);
+}