Commit 3ef3ba4d authored by Ian Romanick's avatar Ian Romanick

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: default avatarIan Romanick <ian.d.romanick@intel.com>
Acked-by: default avatarChad Versace <chad.versace@linux.intel.com>
parent 8a4b36de
......@@ -23,7 +23,7 @@ doxygen:
check:
cd src/glsl/tests/ && ./optimization-test
@echo "All tests passed."
make -C tests check
clean:
-@touch $(TOP)/configs/current
......
dnl Process this file with autoconf to create configure.
nl Process this file with autoconf to create configure.
AC_PREREQ([2.59])
......@@ -16,6 +16,7 @@ AC_INIT([Mesa],[mesa_version],
[https://bugs.freedesktop.org/enter_bug.cgi?product=Mesa])
AC_CONFIG_AUX_DIR([bin])
AC_CANONICAL_HOST
AM_INIT_AUTOMAKE([foreign])
dnl Save user CFLAGS and CXXFLAGS so one can override the default ones
USER_CFLAGS="$CFLAGS"
......@@ -65,6 +66,19 @@ solaris*)
;;
esac
AC_PATH_PROG([GTESTCONFIG], [gtest-config])
if test "x$GTESTCONFIG" != "x"; then
GTEST_CFLAGS=`gtest-config --cppflags --cxxflags`
GTEST_LIBS=`gtest-config --ldflags --libs`
HAVE_GTEST=1
AC_SUBST([GTEST_CFLAGS])
AC_SUBST([GTEST_LIBS])
HAVE_GTEST=yes
else
HAVE_GTEST=no
fi
AM_CONDITIONAL(HAVE_GTEST, test x$HAVE_GTEST = xyes)
dnl clang is mostly GCC-compatible, but its version is much lower,
dnl so we have to check for it.
AC_MSG_CHECKING([if compiling with clang])
......@@ -1907,7 +1921,9 @@ CFLAGS="$CFLAGS $USER_CFLAGS"
CXXFLAGS="$CXXFLAGS $USER_CXXFLAGS"
dnl Substitute the config
AC_CONFIG_FILES([configs/autoconf])
AC_CONFIG_FILES([configs/autoconf
tests/Makefile
tests/glx/Makefile])
dnl Replace the configs/current symlink
AC_CONFIG_COMMANDS([configs],[
......
......@@ -83,8 +83,11 @@ INCLUDES = -I. \
default: depend $(TOP)/$(LIB_DIR)/$(GL_LIB_NAME)
libglx.a: $(OBJECTS)
$(MKLIB) -cplusplus -o glx -static $(OBJECTS)
# Make libGL
$(TOP)/$(LIB_DIR)/$(GL_LIB_NAME): $(OBJECTS) $(GLAPI_LIB) Makefile
$(TOP)/$(LIB_DIR)/$(GL_LIB_NAME): libglx.a $(OBJECTS) $(GLAPI_LIB) Makefile
$(MKLIB) -o $(GL_LIB) -linker '$(CXX)' -ldflags '$(LDFLAGS)' \
-major 1 -minor 2 \
-cplusplus $(MKLIB_OPTIONS) \
......
AM_CFLAGS = -I$(top_builddir)/src/glx -I$(top_builddir)/src/mapi \
$(X11_CFLAGS) $(GTEST_CFLAGS)
AM_CXXFLAGS = -I$(top_builddir)/src/glx -I$(top_builddir)/src/mapi \
$(X11_CFLAGS) $(GTEST_CFLAGS)
if HAVE_GTEST
TESTS = glx_unittest
check_PROGRAMS = glx_unittest
glx_unittest_SOURCES = \
clientinfo_unittest.cpp \
create_context_unittest.cpp \
fake_glx_screen.cpp
glx_unittest_LDADD = $(top_builddir)/src/glx/libglx.a $(GTEST_LIBS) -lgtest_main
endif
\ No newline at end of file
/*
* 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]);