1 //
2 // Copyright 2017 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 // TextureRectangleTest: Tests of GL_ANGLE_texture_rectangle
8
9 #include "test_utils/ANGLETest.h"
10 #include "test_utils/gl_raii.h"
11
12 using namespace angle;
13
14 namespace
15 {
16
17 class TextureRectangleTest : public ANGLETest
18 {
19 protected:
TextureRectangleTest()20 TextureRectangleTest()
21 {
22 setWindowWidth(64);
23 setWindowHeight(64);
24 setConfigRedBits(8);
25 setConfigGreenBits(8);
26 setConfigBlueBits(8);
27 setConfigAlphaBits(8);
28 }
29
checkExtensionSupported() const30 bool checkExtensionSupported() const
31 {
32 if (!IsGLExtensionEnabled("GL_ANGLE_texture_rectangle"))
33 {
34 std::cout << "Test skipped because GL_ANGLE_texture_rectangle is not available."
35 << std::endl;
36 return false;
37 }
38 return true;
39 }
40 };
41
42 class TextureRectangleTestES3 : public TextureRectangleTest
43 {};
44
45 class TextureRectangleTestES31 : public TextureRectangleTest
46 {};
47
48 // Test using TexImage2D to define a rectangle texture
TEST_P(TextureRectangleTest,TexImage2D)49 TEST_P(TextureRectangleTest, TexImage2D)
50 {
51 ANGLE_SKIP_TEST_IF(!checkExtensionSupported());
52
53 GLTexture tex;
54 glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
55
56 // Defining level 0 is allowed
57 glTexImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE,
58 nullptr);
59 ASSERT_GL_NO_ERROR();
60
61 // Defining level other than 0 is not allowed
62 glTexImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 1, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE,
63 nullptr);
64 ASSERT_GL_ERROR(GL_INVALID_VALUE);
65
66 GLint maxSize = 0;
67 glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_ANGLE, &maxSize);
68
69 // Defining a texture of the max size is allowed
70 {
71 ScopedIgnorePlatformMessages ignore;
72
73 glTexImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 0, GL_RGBA, maxSize, maxSize, 0, GL_RGBA,
74 GL_UNSIGNED_BYTE, nullptr);
75 GLenum error = glGetError();
76 ASSERT_TRUE(error == GL_NO_ERROR || error == GL_OUT_OF_MEMORY);
77 }
78
79 // Defining a texture of the max size is allowed
80 glTexImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 0, GL_RGBA, maxSize + 1, maxSize, 0, GL_RGBA,
81 GL_UNSIGNED_BYTE, nullptr);
82 ASSERT_GL_ERROR(GL_INVALID_VALUE);
83 glTexImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 0, GL_RGBA, maxSize, maxSize + 1, 0, GL_RGBA,
84 GL_UNSIGNED_BYTE, nullptr);
85 ASSERT_GL_ERROR(GL_INVALID_VALUE);
86 }
87
88 // Test using CompressedTexImage2D cannot be used on a retangle texture
TEST_P(TextureRectangleTest,CompressedTexImage2DDisallowed)89 TEST_P(TextureRectangleTest, CompressedTexImage2DDisallowed)
90 {
91 ANGLE_SKIP_TEST_IF(!checkExtensionSupported());
92 ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_EXT_texture_compression_dxt1"));
93
94 const char data[128] = {0};
95
96 // Control case: 2D texture
97 {
98 GLTexture tex;
99 glBindTexture(GL_TEXTURE_2D, tex);
100 glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 16, 16, 0, 128,
101 data);
102 ASSERT_GL_NO_ERROR();
103 }
104
105 // Rectangle textures cannot be compressed
106 {
107 GLTexture tex;
108 glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
109 glCompressedTexImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 0, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 16,
110 16, 0, 128, data);
111 ASSERT_GL_ERROR(GL_INVALID_ENUM);
112 }
113 }
114
115 // Test using TexStorage2D to define a rectangle texture
TEST_P(TextureRectangleTest,TexStorage2D)116 TEST_P(TextureRectangleTest, TexStorage2D)
117 {
118 ANGLE_SKIP_TEST_IF(!checkExtensionSupported());
119 ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3 &&
120 !IsGLExtensionEnabled("GL_EXT_texture_storage"));
121
122 bool useES3 = getClientMajorVersion() >= 3;
123 auto TexStorage2D = [useES3](GLenum target, GLint levels, GLenum format, GLint width,
124 GLint height) {
125 if (useES3)
126 {
127 glTexStorage2D(target, levels, format, width, height);
128 }
129 else
130 {
131 glTexStorage2DEXT(target, levels, format, width, height);
132 }
133 };
134
135 // Defining one level is allowed
136 {
137 GLTexture tex;
138 glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
139 TexStorage2D(GL_TEXTURE_RECTANGLE_ANGLE, 1, GL_RGBA8UI, 16, 16);
140 ASSERT_GL_NO_ERROR();
141 }
142
143 // Having more than one level is not allowed
144 {
145 GLTexture tex;
146 glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
147 // Use 5 levels because the EXT_texture_storage extension requires a mip chain all the way
148 // to a 1x1 mip.
149 TexStorage2D(GL_TEXTURE_RECTANGLE_ANGLE, 5, GL_RGBA8UI, 16, 16);
150 ASSERT_GL_ERROR(GL_INVALID_VALUE);
151 }
152
153 GLint maxSize = 0;
154 glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_ANGLE, &maxSize);
155
156 // Defining a texture of the max size is allowed but still allow for OOM
157 {
158 ScopedIgnorePlatformMessages ignore;
159
160 GLTexture tex;
161 glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
162 TexStorage2D(GL_TEXTURE_RECTANGLE_ANGLE, 1, GL_RGBA8UI, maxSize, maxSize);
163 GLenum error = glGetError();
164 ASSERT_TRUE(error == GL_NO_ERROR || error == GL_OUT_OF_MEMORY);
165 }
166
167 // Defining a texture of the max size is disallowed
168 {
169 GLTexture tex;
170 glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
171 TexStorage2D(GL_TEXTURE_RECTANGLE_ANGLE, 1, GL_RGBA8UI, maxSize + 1, maxSize);
172 ASSERT_GL_ERROR(GL_INVALID_VALUE);
173 TexStorage2D(GL_TEXTURE_RECTANGLE_ANGLE, 1, GL_RGBA8UI, maxSize, maxSize + 1);
174 ASSERT_GL_ERROR(GL_INVALID_VALUE);
175 }
176
177 // Compressed formats are disallowed
178 if (IsGLExtensionEnabled("GL_EXT_texture_compression_dxt1"))
179 {
180 GLTexture tex;
181 glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
182 TexStorage2D(GL_TEXTURE_RECTANGLE_ANGLE, 1, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 16, 16);
183 ASSERT_GL_ERROR(GL_INVALID_ENUM);
184 }
185 }
186
187 // Test validation of disallowed texture parameters
TEST_P(TextureRectangleTest,TexParameterRestriction)188 TEST_P(TextureRectangleTest, TexParameterRestriction)
189 {
190 ANGLE_SKIP_TEST_IF(!checkExtensionSupported());
191
192 GLTexture tex;
193 glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
194
195 // Only wrap mode CLAMP_TO_EDGE is supported
196 // Wrap S
197 glTexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
198 ASSERT_GL_NO_ERROR();
199 glTexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_WRAP_S, GL_REPEAT);
200 ASSERT_GL_ERROR(GL_INVALID_ENUM);
201 glTexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
202 ASSERT_GL_ERROR(GL_INVALID_ENUM);
203
204 // Wrap T
205 glTexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
206 ASSERT_GL_NO_ERROR();
207 glTexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_WRAP_T, GL_REPEAT);
208 ASSERT_GL_ERROR(GL_INVALID_ENUM);
209 glTexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
210 ASSERT_GL_ERROR(GL_INVALID_ENUM);
211
212 // Min filter has to be nearest or linear
213 glTexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
214 ASSERT_GL_NO_ERROR();
215 glTexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
216 ASSERT_GL_NO_ERROR();
217 glTexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
218 ASSERT_GL_ERROR(GL_INVALID_ENUM);
219 glTexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
220 ASSERT_GL_ERROR(GL_INVALID_ENUM);
221 glTexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
222 ASSERT_GL_ERROR(GL_INVALID_ENUM);
223 glTexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
224 ASSERT_GL_ERROR(GL_INVALID_ENUM);
225
226 // Base level has to be 0
227 if (getClientMajorVersion() >= 3)
228 {
229 glTexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_BASE_LEVEL, 0);
230 ASSERT_GL_NO_ERROR();
231 glTexParameteri(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_BASE_LEVEL, 1);
232 ASSERT_GL_ERROR(GL_INVALID_OPERATION);
233 }
234 }
235
236 // Test validation of 'level' in GetTexParameter
TEST_P(TextureRectangleTestES31,GetTexLevelParameter)237 TEST_P(TextureRectangleTestES31, GetTexLevelParameter)
238 {
239 ANGLE_SKIP_TEST_IF(!checkExtensionSupported());
240
241 GLTexture tex;
242 glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
243 glTexImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE,
244 nullptr);
245 ASSERT_GL_NO_ERROR();
246
247 GLint param;
248 // Control case: level 0 is ok.
249 glGetTexLevelParameteriv(GL_TEXTURE_RECTANGLE_ANGLE, 0, GL_TEXTURE_INTERNAL_FORMAT, ¶m);
250 ASSERT_GL_NO_ERROR();
251
252 // Level 1 is not ok.
253 glGetTexLevelParameteriv(GL_TEXTURE_RECTANGLE_ANGLE, 1, GL_TEXTURE_INTERNAL_FORMAT, ¶m);
254 ASSERT_GL_ERROR(GL_INVALID_VALUE);
255 }
256
257 // Test validation of "level" in FramebufferTexture2D
TEST_P(TextureRectangleTest,FramebufferTexture2DLevel)258 TEST_P(TextureRectangleTest, FramebufferTexture2DLevel)
259 {
260 ANGLE_SKIP_TEST_IF(!checkExtensionSupported());
261
262 GLTexture tex;
263 glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
264 glTexImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE,
265 nullptr);
266 ASSERT_GL_NO_ERROR();
267
268 GLFramebuffer fbo;
269 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
270
271 // Using level 0 of a rectangle texture is valid.
272 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ANGLE, tex,
273 0);
274 EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
275 ASSERT_GL_NO_ERROR();
276
277 // Setting level != 0 is invalid
278 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ANGLE, tex,
279 1);
280 ASSERT_GL_ERROR(GL_INVALID_VALUE);
281 }
282
283 // Test sampling from a rectangle texture using texture2DRect in ESSL1
TEST_P(TextureRectangleTest,SamplingFromRectangleESSL1)284 TEST_P(TextureRectangleTest, SamplingFromRectangleESSL1)
285 {
286 ANGLE_SKIP_TEST_IF(!checkExtensionSupported());
287
288 GLTexture tex;
289 glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
290 glTexImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
291 &GLColor::green);
292
293 constexpr char kFS[] =
294 "#extension GL_ARB_texture_rectangle : require\n"
295 "precision mediump float;\n"
296 "uniform sampler2DRect tex;\n"
297 "void main()\n"
298 "{\n"
299 " gl_FragColor = texture2DRect(tex, vec2(0, 0));\n"
300 "}\n";
301
302 ANGLE_GL_PROGRAM(program, essl1_shaders::vs::Simple(), kFS);
303 glUseProgram(program);
304
305 GLint location = glGetUniformLocation(program, "tex");
306 ASSERT_NE(-1, location);
307 glUniform1i(location, 0);
308
309 glClearColor(0.0, 0.0, 0.0, 0.0);
310 glClear(GL_COLOR_BUFFER_BIT);
311 drawQuad(program, essl1_shaders::PositionAttrib(), 0.5f, 1.0f, false);
312 EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
313 ASSERT_GL_NO_ERROR();
314 }
315
316 // Test sampling from a rectangle texture using the texture overload in ESSL3
TEST_P(TextureRectangleTestES3,SamplingFromRectangleESSL3)317 TEST_P(TextureRectangleTestES3, SamplingFromRectangleESSL3)
318 {
319 ANGLE_SKIP_TEST_IF(!checkExtensionSupported());
320
321 GLTexture tex;
322 glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
323 glTexImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
324 &GLColor::green);
325
326 constexpr char kFS[] =
327 "#version 300 es\n"
328 "#extension GL_ARB_texture_rectangle : require\n"
329 "precision mediump float;\n"
330 "uniform sampler2DRect tex;\n"
331 "out vec4 fragColor;\n"
332 "void main()\n"
333 "{\n"
334 " fragColor = texture(tex, vec2(0, 0));\n"
335 "}\n";
336
337 ANGLE_GL_PROGRAM(program, essl3_shaders::vs::Simple(), kFS);
338 glUseProgram(program);
339
340 GLint location = glGetUniformLocation(program, "tex");
341 ASSERT_NE(-1, location);
342 glUniform1i(location, 0);
343
344 glClearColor(0.0, 0.0, 0.0, 0.0);
345 glClear(GL_COLOR_BUFFER_BIT);
346 drawQuad(program, essl3_shaders::PositionAttrib(), 0.5f, 1.0f, false);
347 EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
348 ASSERT_GL_NO_ERROR();
349 }
350
351 // Test attaching a rectangle texture and rendering to it.
TEST_P(TextureRectangleTest,RenderToRectangle)352 TEST_P(TextureRectangleTest, RenderToRectangle)
353 {
354 ANGLE_SKIP_TEST_IF(!checkExtensionSupported());
355
356 GLTexture tex;
357 glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
358 glTexImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
359 &GLColor::black);
360
361 GLFramebuffer fbo;
362 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
363 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ANGLE, tex,
364 0);
365 EXPECT_GLENUM_EQ(GL_FRAMEBUFFER_COMPLETE, glCheckFramebufferStatus(GL_FRAMEBUFFER));
366 ASSERT_GL_NO_ERROR();
367
368 // Clearing a texture is just as good as checking we can render to it, right?
369 glClearColor(0.0, 1.0, 0.0, 1.0);
370 glClear(GL_COLOR_BUFFER_BIT);
371 EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
372 ASSERT_GL_NO_ERROR();
373 }
374
TEST_P(TextureRectangleTest,DefaultSamplerParameters)375 TEST_P(TextureRectangleTest, DefaultSamplerParameters)
376 {
377 ANGLE_SKIP_TEST_IF(!checkExtensionSupported());
378
379 GLTexture tex;
380 glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
381
382 GLint minFilter = 0;
383 glGetTexParameteriv(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_MIN_FILTER, &minFilter);
384 EXPECT_EQ(GL_LINEAR, minFilter);
385
386 GLint wrapS = 0;
387 glGetTexParameteriv(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_WRAP_S, &wrapS);
388 EXPECT_EQ(GL_CLAMP_TO_EDGE, wrapS);
389
390 GLint wrapT = 0;
391 glGetTexParameteriv(GL_TEXTURE_RECTANGLE_ANGLE, GL_TEXTURE_WRAP_T, &wrapT);
392 EXPECT_EQ(GL_CLAMP_TO_EDGE, wrapT);
393 }
394
395 // Test glCopyTexImage with rectangle textures
TEST_P(TextureRectangleTestES3,CopyTexImage)396 TEST_P(TextureRectangleTestES3, CopyTexImage)
397 {
398 ANGLE_SKIP_TEST_IF(!checkExtensionSupported());
399
400 GLTexture tex;
401 glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
402
403 glBindFramebuffer(GL_FRAMEBUFFER, 0);
404 glClearColor(0, 1, 0, 1);
405 glClear(GL_COLOR_BUFFER_BIT);
406 ASSERT_GL_NO_ERROR();
407
408 // Error case: level != 0
409 glCopyTexImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 1, GL_RGBA8, 0, 0, 1, 1, 0);
410 ASSERT_GL_ERROR(GL_INVALID_VALUE);
411
412 // level = 0 works and defines the texture.
413 glCopyTexImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 0, GL_RGBA8, 0, 0, 1, 1, 0);
414 ASSERT_GL_NO_ERROR();
415
416 GLFramebuffer fbo;
417 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
418 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ANGLE, tex,
419 0);
420 EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
421 ASSERT_GL_NO_ERROR();
422 }
423
424 // Test glCopyTexSubImage with rectangle textures
TEST_P(TextureRectangleTestES3,CopyTexSubImage)425 TEST_P(TextureRectangleTestES3, CopyTexSubImage)
426 {
427 ANGLE_SKIP_TEST_IF(!checkExtensionSupported());
428
429 GLTexture tex;
430 glBindTexture(GL_TEXTURE_RECTANGLE_ANGLE, tex);
431 glTexImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
432 &GLColor::black);
433
434 glBindFramebuffer(GL_FRAMEBUFFER, 0);
435 glClearColor(0, 1, 0, 1);
436 glClear(GL_COLOR_BUFFER_BIT);
437 ASSERT_GL_NO_ERROR();
438
439 // Error case: level != 0
440 glCopyTexSubImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 1, 0, 0, 0, 0, 1, 1);
441 ASSERT_GL_ERROR(GL_INVALID_VALUE);
442
443 // level = 0 works and defines the texture.
444 glCopyTexSubImage2D(GL_TEXTURE_RECTANGLE_ANGLE, 0, 0, 0, 0, 0, 1, 1);
445 ASSERT_GL_NO_ERROR();
446
447 GLFramebuffer fbo;
448 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
449 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ANGLE, tex,
450 0);
451 EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
452 ASSERT_GL_NO_ERROR();
453 }
454
455 ANGLE_INSTANTIATE_TEST_ES2(TextureRectangleTest);
456 ANGLE_INSTANTIATE_TEST_ES3(TextureRectangleTestES3);
457 ANGLE_INSTANTIATE_TEST_ES31(TextureRectangleTestES31);
458 } // anonymous namespace
459