1 //
2 // Copyright 2015 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6
7 // EGLX11VisualTest.cpp: tests for EGL_ANGLE_x11_visual extension
8
9 #include <gtest/gtest.h>
10
11 #include <EGL/egl.h>
12 #include <EGL/eglext.h>
13 #include <X11/Xlib.h>
14 #include <X11/Xresource.h>
15 #include <X11/Xutil.h>
16
17 #include "test_utils/ANGLETest.h"
18 #include "util/OSWindow.h"
19 #include "util/linux/x11/X11Window.h"
20
21 using namespace angle;
22
23 namespace
24 {
25
26 const EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
27 }
28
29 class EGLX11VisualHintTest : public ANGLETest<>
30 {
31 public:
testSetUp()32 void testSetUp() override { mDisplay = XOpenDisplay(nullptr); }
33
getDisplayAttributes(int visualId) const34 std::vector<EGLint> getDisplayAttributes(int visualId) const
35 {
36 std::vector<EGLint> attribs;
37
38 attribs.push_back(EGL_PLATFORM_ANGLE_TYPE_ANGLE);
39 attribs.push_back(GetParam().getRenderer());
40 attribs.push_back(EGL_X11_VISUAL_ID_ANGLE);
41 attribs.push_back(visualId);
42 attribs.push_back(EGL_NONE);
43
44 return attribs;
45 }
46
chooseDifferentVisual(unsigned int visualId)47 unsigned int chooseDifferentVisual(unsigned int visualId)
48 {
49 int numVisuals;
50 XVisualInfo visualTemplate;
51 visualTemplate.screen = DefaultScreen(mDisplay);
52
53 XVisualInfo *visuals =
54 XGetVisualInfo(mDisplay, VisualScreenMask, &visualTemplate, &numVisuals);
55 EXPECT_TRUE(numVisuals >= 2);
56
57 for (int i = 0; i < numVisuals; ++i)
58 {
59 if (visuals[i].visualid != visualId)
60 {
61 int result = visuals[i].visualid;
62 XFree(visuals);
63 return result;
64 }
65 }
66
67 EXPECT_TRUE(false);
68 return -1;
69 }
70
71 protected:
72 Display *mDisplay;
73 };
74
75 // Test that display creation fails if the visual ID passed in invalid.
TEST_P(EGLX11VisualHintTest,InvalidVisualID)76 TEST_P(EGLX11VisualHintTest, InvalidVisualID)
77 {
78 static const int gInvalidVisualId = -1;
79 auto attributes = getDisplayAttributes(gInvalidVisualId);
80
81 EGLDisplay display = eglGetPlatformDisplayEXT(
82 EGL_PLATFORM_ANGLE_ANGLE, reinterpret_cast<_XDisplay *>(EGL_DEFAULT_DISPLAY),
83 attributes.data());
84 ASSERT_TRUE(display != EGL_NO_DISPLAY);
85
86 ASSERT_TRUE(EGL_FALSE == eglInitialize(display, nullptr, nullptr));
87 ASSERT_EGL_ERROR(EGL_NOT_INITIALIZED);
88 }
89
90 // Test that context creation with a visual ID succeeds, that the context exposes
91 // only one config, and that a clear on a surface with this config works.
TEST_P(EGLX11VisualHintTest,ValidVisualIDAndClear)92 TEST_P(EGLX11VisualHintTest, ValidVisualIDAndClear)
93 {
94 // We'll test the extension with one visual ID but we don't care which one. This means we
95 // can use OSWindow to create a window and just grab its visual.
96 OSWindow *osWindow = OSWindow::New();
97 osWindow->initialize("EGLX11VisualHintTest", 500, 500);
98 setWindowVisible(osWindow, true);
99
100 Window xWindow = osWindow->getNativeWindow();
101
102 XWindowAttributes windowAttributes;
103 ASSERT_NE(0, XGetWindowAttributes(mDisplay, xWindow, &windowAttributes));
104 int visualId = windowAttributes.visual->visualid;
105
106 auto attributes = getDisplayAttributes(visualId);
107 EGLDisplay display = eglGetPlatformDisplayEXT(
108 EGL_PLATFORM_ANGLE_ANGLE, reinterpret_cast<_XDisplay *>(EGL_DEFAULT_DISPLAY),
109 attributes.data());
110 ASSERT_NE(EGL_NO_DISPLAY, display);
111
112 ASSERT_TRUE(EGL_TRUE == eglInitialize(display, nullptr, nullptr));
113
114 int nConfigs = 0;
115 ASSERT_TRUE(EGL_TRUE == eglGetConfigs(display, nullptr, 0, &nConfigs));
116 ASSERT_GE(nConfigs, 1);
117
118 int nReturnedConfigs = 0;
119 std::vector<EGLConfig> configs(nConfigs);
120 ASSERT_TRUE(EGL_TRUE == eglGetConfigs(display, configs.data(), nConfigs, &nReturnedConfigs));
121 ASSERT_EQ(nConfigs, nReturnedConfigs);
122
123 for (EGLConfig config : configs)
124 {
125 EGLint eglNativeId;
126 ASSERT_TRUE(EGL_TRUE ==
127 eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &eglNativeId));
128 ASSERT_EQ(visualId, eglNativeId);
129
130 // Finally, try to do a clear on the window.
131 EGLContext context = eglCreateContext(display, config, EGL_NO_CONTEXT, contextAttribs);
132 ASSERT_NE(EGL_NO_CONTEXT, context);
133
134 EGLSurface window = eglCreateWindowSurface(display, config, xWindow, nullptr);
135 ASSERT_EGL_SUCCESS();
136
137 eglMakeCurrent(display, window, window, context);
138 ASSERT_EGL_SUCCESS();
139
140 glViewport(0, 0, 500, 500);
141 glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
142 glClear(GL_COLOR_BUFFER_BIT);
143 ASSERT_GL_NO_ERROR();
144 EXPECT_PIXEL_EQ(250, 250, 0, 0, 255, 255);
145
146 // Teardown
147 eglDestroySurface(display, window);
148 ASSERT_EGL_SUCCESS();
149
150 eglDestroyContext(display, context);
151 ASSERT_EGL_SUCCESS();
152
153 eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
154 ASSERT_EGL_SUCCESS();
155 }
156
157 OSWindow::Delete(&osWindow);
158
159 eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
160 eglTerminate(display);
161 }
162
163 // Test that a child window is created when trying to create an EGL window from
164 // an X11 window whose visual ID doesn't match the visual ID passed at display creation.
TEST_P(EGLX11VisualHintTest,InvalidWindowVisualID)165 TEST_P(EGLX11VisualHintTest, InvalidWindowVisualID)
166 {
167 // Get the default visual ID, as a good guess of a visual id for which display
168 // creation will succeed.
169 int visualId;
170 {
171 OSWindow *osWindow = OSWindow::New();
172 osWindow->initialize("EGLX11VisualHintTest", 500, 500);
173 setWindowVisible(osWindow, true);
174
175 Window xWindow = osWindow->getNativeWindow();
176
177 XWindowAttributes windowAttributes;
178 ASSERT_NE(0, XGetWindowAttributes(mDisplay, xWindow, &windowAttributes));
179 visualId = windowAttributes.visual->visualid;
180
181 OSWindow::Delete(&osWindow);
182 }
183
184 auto attributes = getDisplayAttributes(visualId);
185 EGLDisplay display = eglGetPlatformDisplayEXT(
186 EGL_PLATFORM_ANGLE_ANGLE, reinterpret_cast<_XDisplay *>(EGL_DEFAULT_DISPLAY),
187 attributes.data());
188 ASSERT_NE(EGL_NO_DISPLAY, display);
189
190 ASSERT_TRUE(EGL_TRUE == eglInitialize(display, nullptr, nullptr));
191
192 // Initialize the window with a visual id different from the display's visual id
193 int otherVisualId = chooseDifferentVisual(visualId);
194 ASSERT_NE(visualId, otherVisualId);
195
196 OSWindow *osWindow = CreateX11WindowWithVisualId(otherVisualId);
197 osWindow->initialize("EGLX11VisualHintTest", 500, 500);
198 setWindowVisible(osWindow, true);
199
200 Window xWindow = osWindow->getNativeWindow();
201
202 // Creating the EGL window should succeed
203 int nReturnedConfigs = 0;
204 EGLConfig config;
205 ASSERT_TRUE(EGL_TRUE == eglGetConfigs(display, &config, 1, &nReturnedConfigs));
206 ASSERT_EQ(1, nReturnedConfigs);
207
208 EGLSurface window = eglCreateWindowSurface(display, config, xWindow, nullptr);
209 ASSERT_TRUE(window);
210 ASSERT_EGL_SUCCESS();
211
212 // When trying to create a window with a visual other than the one specified
213 // with EGL_X11_VISUAL_ID_ANGLE, ANGLE should fallback to using a child window.
214 Window root;
215 Window parent;
216 Window *children;
217 unsigned int nchildren;
218 XQueryTree(mDisplay, xWindow, &root, &parent, &children, &nchildren);
219 EXPECT_EQ(nchildren, 1U);
220 XFree(children);
221
222 OSWindow::Delete(&osWindow);
223 }
224
225 ANGLE_INSTANTIATE_TEST(EGLX11VisualHintTest, WithNoFixture(ES2_OPENGL()));
226