1 /*-------------------------------------------------------------------------
2 * OpenGL Conformance Test Suite
3 * -----------------------------
4 *
5 * Copyright (c) 2014-2016 The Khronos Group Inc.
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 */ /*!
20 * \file
21 * \brief
22 */ /*-------------------------------------------------------------------*/
23
24 /*!
25 * \file esextcTextureBorderClampParameterTextureBorderColor.cpp
26 * \brief Verify that GL_TEXTURE_BORDER_COLOR_EXT state is correctly retrieved
27 * by glGetSamplerParameter*() and glGetTexParameter*() functions. (Test 6)
28 */ /*-------------------------------------------------------------------*/
29
30 #include "esextcTextureBorderClampParameterTextureBorderColor.hpp"
31 #include "gluContextInfo.hpp"
32 #include "gluDefs.hpp"
33 #include "glwEnums.hpp"
34 #include "glwFunctions.hpp"
35 #include "tcuTestLog.hpp"
36 #include <vector>
37
38 namespace glcts
39 {
40
41 /* Max number of elements in buffers allocated by the test */
42 const glw::GLuint TextureBorderClampParameterTextureBorderColor::m_buffer_length = 4;
43 /* Index of texture unit used in the test */
44 const glw::GLuint TextureBorderClampParameterTextureBorderColor::m_texture_unit_index = 0;
45
46 /** Constructor
47 *
48 * @param context Test context
49 * @param name Test case's name
50 * @param description Test case's description
51 **/
TextureBorderClampParameterTextureBorderColor(Context & context,const ExtParameters & extParams,const char * name,const char * description)52 TextureBorderClampParameterTextureBorderColor::TextureBorderClampParameterTextureBorderColor(
53 Context &context, const ExtParameters &extParams, const char *name, const char *description)
54 : TextureBorderClampBase(context, extParams, name, description)
55 , m_sampler_id(0)
56 , m_to_id(0)
57 {
58 /* Left blank on purpose */
59 }
60
61 /** Deinitializes GLES objects created during the test. */
deinit(void)62 void TextureBorderClampParameterTextureBorderColor::deinit(void)
63 {
64 /* Get GL entry points */
65 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
66
67 for (glw::GLuint i = 0; i < m_texture_targets.size(); ++i)
68 {
69 gl.bindTexture(m_texture_targets[i], 0);
70
71 GLU_EXPECT_NO_ERROR(gl.getError(), "Error binding texture object!");
72 }
73
74 gl.bindSampler(m_texture_unit_index, 0);
75 GLU_EXPECT_NO_ERROR(gl.getError(), "Error binding sampler object to texture unit!");
76
77 if (m_to_id != 0)
78 {
79 gl.deleteTextures(1, &m_to_id);
80
81 m_to_id = 0;
82 }
83
84 if (m_sampler_id != 0)
85 {
86 gl.deleteSamplers(1, &m_sampler_id);
87
88 m_sampler_id = 0;
89 }
90
91 /* Deinitialize base class */
92 TestCaseBase::deinit();
93 }
94
95 /** Initializes GLES objects used during the test. */
initTest(void)96 void TextureBorderClampParameterTextureBorderColor::initTest(void)
97 {
98 /* Check whether GL_EXT_texture_border_clamp is supported */
99 if (!m_is_texture_border_clamp_supported)
100 {
101 throw tcu::NotSupportedError(TEXTURE_BORDER_CLAMP_NOT_SUPPORTED, "", __FILE__, __LINE__);
102 }
103
104 /* Fill array with texture targets used in the test */
105 m_texture_targets.push_back(GL_TEXTURE_2D);
106 m_texture_targets.push_back(GL_TEXTURE_2D_ARRAY);
107 m_texture_targets.push_back(GL_TEXTURE_3D);
108 m_texture_targets.push_back(GL_TEXTURE_CUBE_MAP);
109
110 /* Also consider GL_TEXTURE_CUBE_MAP_ARRAY_EXT, but only if
111 * GL_EXT_texture_cube_map_array is supported
112 */
113 if (m_is_texture_cube_map_array_supported)
114 {
115 m_texture_targets.push_back(GL_TEXTURE_CUBE_MAP_ARRAY);
116 }
117 }
118
119 /** Executes the test.
120 *
121 * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
122 *
123 * Note the function throws exception should an error occur!
124 *
125 * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again.
126 **/
iterate(void)127 tcu::TestNode::IterateResult TextureBorderClampParameterTextureBorderColor::iterate(void)
128 {
129 initTest();
130
131 /* Get GL entry points */
132 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
133 glw::GLboolean test_passed = true;
134
135 /* Iterate through all texture targets */
136 for (glw::GLuint i = 0; i < m_texture_targets.size(); ++i)
137 {
138 gl.genTextures(1, &m_to_id);
139 GLU_EXPECT_NO_ERROR(gl.getError(), "Error generating a texture object!");
140
141 gl.bindTexture(m_texture_targets[i], m_to_id);
142 GLU_EXPECT_NO_ERROR(gl.getError(), "Error binding a texture object!");
143
144 gl.genSamplers(1, &m_sampler_id);
145 GLU_EXPECT_NO_ERROR(gl.getError(), "Error generating a sampler object!");
146
147 gl.bindSampler(m_texture_unit_index, m_sampler_id);
148 GLU_EXPECT_NO_ERROR(gl.getError(), "Error binding a sampler object to a texture unit!");
149
150 /* Verify default border color is set to (0.0, 0.0, 0.0, 0.0) and (0, 0, 0, 0) */
151 std::vector<glw::GLfloat> data_fp_zeros(m_buffer_length);
152
153 data_fp_zeros[0] = 0.0f;
154 data_fp_zeros[1] = 0.0f;
155 data_fp_zeros[2] = 0.0f;
156 data_fp_zeros[3] = 0.0f;
157
158 std::vector<glw::GLint> data_int_zeros(m_buffer_length);
159
160 data_int_zeros[0] = 0;
161 data_int_zeros[1] = 0;
162 data_int_zeros[2] = 0;
163 data_int_zeros[3] = 0;
164
165 std::vector<glw::GLuint> data_uint_zeros(m_buffer_length);
166
167 data_uint_zeros[0] = 0;
168 data_uint_zeros[1] = 0;
169 data_uint_zeros[2] = 0;
170 data_uint_zeros[3] = 0;
171
172 if (!verifyGLGetTexParameterfvResult(m_texture_targets[i], &data_fp_zeros[0]))
173 {
174 test_passed = false;
175 }
176
177 if (!verifyGLGetTexParameterivResult(m_texture_targets[i], &data_int_zeros[0]))
178 {
179 test_passed = false;
180 }
181
182 if (!verifyGLGetTexParameterIivResult(m_texture_targets[i], &data_int_zeros[0]))
183 {
184 test_passed = false;
185 }
186
187 if (!verifyGLGetTexParameterIuivResult(m_texture_targets[i], &data_uint_zeros[0]))
188 {
189 test_passed = false;
190 }
191
192 /* Verify setting signed integer border color of (-1, -2, 3, 4) using
193 * glSamplerParameterIivEXT() / glTexParameterIivEXT() call affects the values
194 * later reported by glGetSamplerParameterIivEXT() and glGetTexParameterIivEXT().
195 * These values should match.
196 */
197 std::vector<glw::GLint> data_int(m_buffer_length);
198
199 data_int[0] = -1;
200 data_int[1] = -2;
201 data_int[2] = 3;
202 data_int[3] = 4;
203
204 gl.texParameterIiv(m_texture_targets[i], m_glExtTokens.TEXTURE_BORDER_COLOR, &data_int[0]);
205 GLU_EXPECT_NO_ERROR(gl.getError(),
206 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glTexParameterIivEXT()");
207
208 if (!verifyGLGetTexParameterIivResult(m_texture_targets[i], &data_int[0]))
209 {
210 test_passed = false;
211 }
212
213 if (!verifyGLGetSamplerParameterIivResult(m_sampler_id, m_texture_targets[i], &data_int_zeros[0]))
214 {
215 test_passed = false;
216 }
217
218 gl.texParameterIiv(m_texture_targets[i], m_glExtTokens.TEXTURE_BORDER_COLOR, &data_int_zeros[0]);
219 GLU_EXPECT_NO_ERROR(gl.getError(),
220 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glTexParameterIivEXT()");
221
222 gl.samplerParameterIiv(m_sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &data_int[0]);
223 GLU_EXPECT_NO_ERROR(gl.getError(),
224 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glSamplerParameterIivEXT()");
225
226 if (!verifyGLGetTexParameterIivResult(m_texture_targets[i], &data_int_zeros[0]))
227 {
228 test_passed = false;
229 }
230
231 if (!verifyGLGetSamplerParameterIivResult(m_sampler_id, m_texture_targets[i], &data_int[0]))
232 {
233 test_passed = false;
234 }
235
236 gl.samplerParameterIiv(m_sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &data_int_zeros[0]);
237 GLU_EXPECT_NO_ERROR(gl.getError(),
238 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glSamplerParameterIivEXT()");
239
240 /* Verify setting unsigned integer border color of (1, 2, 3, 4) using
241 * glSamplerParameterIuivEXT() / glTexParameterIuivEXT() call affects the values
242 * later reported by glGetSamplerParameterIuivEXT() and glGetTexParameterIuivEXT().
243 * These values should match.
244 */
245 std::vector<glw::GLuint> data_uint(m_buffer_length);
246
247 data_uint[0] = 1;
248 data_uint[1] = 2;
249 data_uint[2] = 3;
250 data_uint[3] = 4;
251
252 gl.texParameterIuiv(m_texture_targets[i], m_glExtTokens.TEXTURE_BORDER_COLOR, &data_uint[0]);
253 GLU_EXPECT_NO_ERROR(gl.getError(),
254 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glTexParameterIuivEXT()");
255
256 if (!verifyGLGetTexParameterIuivResult(m_texture_targets[i], &data_uint[0]))
257 {
258 test_passed = false;
259 }
260
261 if (!verifyGLGetSamplerParameterIuivResult(m_sampler_id, m_texture_targets[i], &data_uint_zeros[0]))
262 {
263 test_passed = false;
264 }
265
266 gl.texParameterIuiv(m_texture_targets[i], m_glExtTokens.TEXTURE_BORDER_COLOR, &data_uint_zeros[0]);
267 GLU_EXPECT_NO_ERROR(gl.getError(),
268 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glTexParameterIuivEXT()");
269
270 gl.samplerParameterIuiv(m_sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &data_uint[0]);
271 GLU_EXPECT_NO_ERROR(gl.getError(),
272 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glSamplerParameterIuivEXT()");
273
274 if (!verifyGLGetTexParameterIuivResult(m_texture_targets[i], &data_uint_zeros[0]))
275 {
276 test_passed = false;
277 }
278
279 if (!verifyGLGetSamplerParameterIuivResult(m_sampler_id, m_texture_targets[i], &data_uint[0]))
280 {
281 test_passed = false;
282 }
283
284 gl.samplerParameterIuiv(m_sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &data_uint_zeros[0]);
285 GLU_EXPECT_NO_ERROR(gl.getError(),
286 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glSamplerParameterIuivEXT()");
287
288 /* Verify setting floating-point border color of (0.1, 0.2, 0.3, 0.4)
289 * affects the values later reported by glGetSamplerParameterfv() /
290 * glGetTexParameterfv(). These values should match.
291 */
292 std::vector<glw::GLfloat> data_fp(m_buffer_length);
293
294 data_fp[0] = 0.1f;
295 data_fp[1] = 0.2f;
296 data_fp[2] = 0.3f;
297 data_fp[3] = 0.4f;
298
299 gl.texParameterfv(m_texture_targets[i], m_glExtTokens.TEXTURE_BORDER_COLOR, &data_fp[0]);
300 GLU_EXPECT_NO_ERROR(gl.getError(),
301 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glTexParameterfv()");
302
303 if (!verifyGLGetTexParameterfvResult(m_texture_targets[i], &data_fp[0]))
304 {
305 test_passed = false;
306 }
307
308 if (!verifyGLGetSamplerParameterfvResult(m_sampler_id, m_texture_targets[i], &data_fp_zeros[0]))
309 {
310 test_passed = false;
311 }
312
313 gl.texParameterfv(m_texture_targets[i], m_glExtTokens.TEXTURE_BORDER_COLOR, &data_fp_zeros[0]);
314 GLU_EXPECT_NO_ERROR(gl.getError(),
315 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glTexParameterfv()");
316
317 gl.samplerParameterfv(m_sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &data_fp[0]);
318 GLU_EXPECT_NO_ERROR(gl.getError(),
319 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glSamplerParameterfv()");
320
321 if (!verifyGLGetTexParameterfvResult(m_texture_targets[i], &data_fp_zeros[0]))
322 {
323 test_passed = false;
324 }
325
326 if (!verifyGLGetSamplerParameterfvResult(m_sampler_id, m_texture_targets[i], &data_fp[0]))
327 {
328 test_passed = false;
329 }
330
331 gl.samplerParameterfv(m_sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &data_fp_zeros[0]);
332 GLU_EXPECT_NO_ERROR(gl.getError(),
333 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glSamplerParameterfv()");
334
335 /* Verify setting integer border color of
336 * (0, 1, 2, 4) using glSamplerParameteriv()
337 * / glTexParameteriv() affects the values later reported by
338 * glGetSamplerParameteriv() / glGetTexParameteriv(). The returned values
339 * should correspond to the outcome of equation 2.2 from ES3.0.2 spec
340 * applied to each component.
341 */
342 data_int[0] = 0;
343 data_int[1] = 1;
344 data_int[2] = 2;
345 data_int[3] = 4;
346
347 gl.texParameteriv(m_texture_targets[i], m_glExtTokens.TEXTURE_BORDER_COLOR, &data_int[0]);
348 GLU_EXPECT_NO_ERROR(gl.getError(),
349 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glTexParameteriv()");
350
351 if (!verifyGLGetTexParameterivResult(m_texture_targets[i], &data_int[0]))
352 {
353 test_passed = false;
354 }
355
356 if (!verifyGLGetSamplerParameterivResult(m_sampler_id, m_texture_targets[i], &data_int_zeros[0]))
357 {
358 test_passed = false;
359 }
360
361 gl.texParameteriv(m_texture_targets[i], m_glExtTokens.TEXTURE_BORDER_COLOR, &data_int_zeros[0]);
362 GLU_EXPECT_NO_ERROR(gl.getError(),
363 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glTexParameteriv()");
364
365 gl.samplerParameteriv(m_sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &data_int[0]);
366 GLU_EXPECT_NO_ERROR(gl.getError(),
367 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glSamplerParameteriv()");
368
369 if (!verifyGLGetTexParameterivResult(m_texture_targets[i], &data_int_zeros[0]))
370 {
371 test_passed = false;
372 }
373
374 if (!verifyGLGetSamplerParameterivResult(m_sampler_id, m_texture_targets[i], &data_int[0]))
375 {
376 test_passed = false;
377 }
378
379 gl.samplerParameteriv(m_sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &data_int_zeros[0]);
380 GLU_EXPECT_NO_ERROR(gl.getError(),
381 "Error setting GL_TEXTURE_BORDER_COLOR_EXT parameter using glSamplerParameteriv()");
382
383 /* Deinitialize the texture object */
384 gl.bindTexture(m_texture_targets[i], 0);
385 GLU_EXPECT_NO_ERROR(gl.getError(), "Error binding texture object!");
386
387 gl.deleteTextures(1, &m_to_id);
388 m_to_id = 0;
389
390 gl.bindSampler(m_texture_unit_index, 0);
391 GLU_EXPECT_NO_ERROR(gl.getError(), "Error binding sampler object to texture unit!");
392
393 gl.deleteSamplers(1, &m_sampler_id);
394 m_sampler_id = 0;
395 }
396
397 /* Has the test passed? */
398 if (test_passed)
399 {
400 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
401 }
402 else
403 {
404 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
405 }
406
407 return STOP;
408 }
409
410 /** Check if glGetSamplerParameterfv() returns correct border color for GL_TEXTURE_BORDER_COLOR_EXT pname
411 *
412 * @param sampler_id ID of sampler object;
413 * @param target texture target to do the call for;
414 * @param expected_data pointer to buffer with expected data
415 * @return true if both buffers are a match.
416 */
verifyGLGetSamplerParameterfvResult(glw::GLuint sampler_id,glw::GLenum target,const glw::GLfloat * expected_data)417 bool TextureBorderClampParameterTextureBorderColor::verifyGLGetSamplerParameterfvResult(
418 glw::GLuint sampler_id, glw::GLenum target, const glw::GLfloat *expected_data)
419 {
420 std::vector<glw::GLfloat> buffer(m_buffer_length);
421 std::stringstream expectedDataStream;
422 std::stringstream returnedDataStream;
423 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
424
425 memset(&buffer[0], 0, m_buffer_length * sizeof(glw::GLfloat));
426
427 gl.getSamplerParameterfv(sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &buffer[0]);
428 GLU_EXPECT_NO_ERROR(gl.getError(), "Error gettnig parameter for sampler.");
429
430 for (glw::GLuint i = 0; i < m_buffer_length; ++i)
431 {
432 if (expected_data[i] != buffer[i])
433 {
434 for (glw::GLuint j = 0; j < m_buffer_length; ++j)
435 {
436 expectedDataStream << expected_data[j] << ",";
437 returnedDataStream << buffer[j] << ",";
438 }
439
440 getTestContext().getLog() << tcu::TestLog::Message
441 << "Wrong value encountered when calling glGetSamplerParameterfv() with "
442 "GL_TEXTURE_BORDER_COLOR_EXT pname;"
443 << " texture target:" << getTexTargetString(target) << "\n"
444 << " expected values:[" << expectedDataStream.str() << "]"
445 << " result values:[" << returnedDataStream.str() << "]\n"
446 << tcu::TestLog::EndMessage;
447
448 return false;
449 }
450 }
451
452 return true;
453 }
454
455 /** Check if glGetSamplerParameteriv() returns correct border color for GL_TEXTURE_BORDER_COLOR_EXT pname
456 *
457 * @param sampler_id ID of sampler object;
458 * @param target texture target to do the call for;
459 * @param expected_data pointer to buffer with expected data
460 * @return true if both buffers are a match.
461 */
verifyGLGetSamplerParameterivResult(glw::GLuint sampler_id,glw::GLenum target,const glw::GLint * expected_data)462 bool TextureBorderClampParameterTextureBorderColor::verifyGLGetSamplerParameterivResult(glw::GLuint sampler_id,
463 glw::GLenum target,
464 const glw::GLint *expected_data)
465 {
466 std::vector<glw::GLint> buffer(m_buffer_length);
467 std::stringstream expectedDataStream;
468 std::stringstream returnedDataStream;
469 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
470
471 memset(&buffer[0], 0, m_buffer_length * sizeof(glw::GLint));
472
473 gl.getSamplerParameteriv(sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &buffer[0]);
474 GLU_EXPECT_NO_ERROR(gl.getError(), "Error getting parameter for sampler.");
475
476 for (glw::GLuint i = 0; i < m_buffer_length; ++i)
477 {
478 if (expected_data[i] != buffer[i])
479 {
480 for (glw::GLuint j = 0; j < m_buffer_length; ++j)
481 {
482 expectedDataStream << expected_data[j] << ",";
483 returnedDataStream << buffer[j] << ",";
484 }
485 getTestContext().getLog() << tcu::TestLog::Message
486 << "Wrong value encountered when calling glGetSamplerParameteriv() with "
487 "GL_TEXTURE_BORDER_COLOR_EXT pname;"
488 << " texture target:" << getTexTargetString(target) << "\n"
489 << " expected values:[" << expectedDataStream.str() << "]"
490 << " result values:[" << returnedDataStream.str() << "]\n"
491 << tcu::TestLog::EndMessage;
492 return false;
493 }
494 }
495
496 return true;
497 }
498
499 /** Check if glGetSamplerParameterIivEXT() returns correct border color for GL_TEXTURE_BORDER_COLOR_EXT pname
500 *
501 * @param sampler_id ID of sampler object;
502 * @param target texture target to do the call for;
503 * @param expected_data pointer to buffer with expected data
504 * @return true if both buffers are a match.
505 */
verifyGLGetSamplerParameterIivResult(glw::GLuint sampler_id,glw::GLenum target,const glw::GLint * expected_data)506 bool TextureBorderClampParameterTextureBorderColor::verifyGLGetSamplerParameterIivResult(
507 glw::GLuint sampler_id, glw::GLenum target, const glw::GLint *expected_data)
508 {
509 std::vector<glw::GLint> buffer(m_buffer_length);
510 std::stringstream expectedDataStream;
511 std::stringstream returnedDataStream;
512 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
513
514 memset(&buffer[0], 0, m_buffer_length * sizeof(glw::GLint));
515
516 gl.getSamplerParameterIiv(sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &buffer[0]);
517 GLU_EXPECT_NO_ERROR(gl.getError(), "Error getting parameter for sampler.");
518
519 for (glw::GLuint i = 0; i < m_buffer_length; ++i)
520 {
521 if (expected_data[i] != buffer[i])
522 {
523 for (glw::GLuint j = 0; j < m_buffer_length; ++j)
524 {
525 expectedDataStream << expected_data[j] << ",";
526 returnedDataStream << buffer[j] << ",";
527 }
528 getTestContext().getLog() << tcu::TestLog::Message
529 << "Wrong value encountered when calling glGetSamplerParameterIivEXT() with "
530 "GL_TEXTURE_BORDER_COLOR_EXT pname;"
531 << " texture target:" << getTexTargetString(target) << "\n"
532 << " expected values:[" << expectedDataStream.str() << "]"
533 << " result values:[" << returnedDataStream.str() << "]\n"
534 << tcu::TestLog::EndMessage;
535 return false;
536 }
537 }
538 return true;
539 }
540
541 /** Check if glGetSamplerParameterIuivEXT() returns correct border color for GL_TEXTURE_BORDER_COLOR_EXT pname
542 *
543 * @param sampler_id ID of sampler object;
544 * @param target texture target to do the call for;
545 * @param expected_data pointer to buffer with expected data
546 * @return true if both buffers are a match.
547 */
verifyGLGetSamplerParameterIuivResult(glw::GLuint sampler_id,glw::GLenum target,const glw::GLuint * expected_data)548 bool TextureBorderClampParameterTextureBorderColor::verifyGLGetSamplerParameterIuivResult(
549 glw::GLuint sampler_id, glw::GLenum target, const glw::GLuint *expected_data)
550 {
551 std::vector<glw::GLuint> buffer(m_buffer_length);
552 std::stringstream expectedDataStream;
553 std::stringstream returnedDataStream;
554 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
555
556 memset(&buffer[0], 0, m_buffer_length * sizeof(glw::GLuint));
557
558 gl.getSamplerParameterIuiv(sampler_id, m_glExtTokens.TEXTURE_BORDER_COLOR, &buffer[0]);
559 GLU_EXPECT_NO_ERROR(gl.getError(), "Error getting parameter for sampler.");
560
561 for (glw::GLuint i = 0; i < m_buffer_length; ++i)
562 {
563 if (expected_data[i] != buffer[i])
564 {
565 for (glw::GLuint j = 0; j < m_buffer_length; ++j)
566 {
567 expectedDataStream << expected_data[j] << ",";
568 returnedDataStream << buffer[j] << ",";
569 }
570 getTestContext().getLog() << tcu::TestLog::Message
571 << "Wrong value encountered when calling glGetSamplerParameterIuivEXT() with "
572 "GL_TEXTURE_BORDER_COLOR_EXT pname;"
573 << " texture target:" << getTexTargetString(target) << "\n"
574 << " expected values:[" << expectedDataStream.str() << "]"
575 << " result values:[" << returnedDataStream.str() << "]\n"
576 << tcu::TestLog::EndMessage;
577 return false;
578 }
579 }
580 return true;
581 }
582
583 /** Check if glGetTexParameterfv() returns correct border color for GL_TEXTURE_BORDER_COLOR_EXT pname
584 *
585 * @param target texture target to do the call for;
586 * @param expected_data pointer to buffer with expected data
587 * @return true if both buffers are a match.
588 */
verifyGLGetTexParameterfvResult(glw::GLenum target,const glw::GLfloat * expected_data)589 bool TextureBorderClampParameterTextureBorderColor::verifyGLGetTexParameterfvResult(glw::GLenum target,
590 const glw::GLfloat *expected_data)
591 {
592 std::vector<glw::GLfloat> buffer(m_buffer_length);
593 std::stringstream expectedDataStream;
594 std::stringstream returnedDataStream;
595 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
596
597 memset(&buffer[0], 0, m_buffer_length * sizeof(glw::GLfloat));
598
599 gl.getTexParameterfv(target, m_glExtTokens.TEXTURE_BORDER_COLOR, &buffer[0]);
600 GLU_EXPECT_NO_ERROR(gl.getError(), "Error getting parameter for texture.");
601
602 for (glw::GLuint i = 0; i < m_buffer_length; ++i)
603 {
604 if (de::abs(expected_data[i] - buffer[i]) > TestCaseBase::m_epsilon_float)
605 {
606 for (glw::GLuint j = 0; j < m_buffer_length; ++j)
607 {
608 expectedDataStream << expected_data[j] << ",";
609 returnedDataStream << buffer[j] << ",";
610 }
611 getTestContext().getLog()
612 << tcu::TestLog::Message
613 << "Wrong value encountered when calling glGetTexParameterfv() with GL_TEXTURE_BORDER_COLOR_EXT pname;"
614 << " texture target:" << getTexTargetString(target) << "\n"
615 << " expected values:[" << expectedDataStream.str() << "]"
616 << " result values:[" << returnedDataStream.str() << "]\n"
617 << tcu::TestLog::EndMessage;
618 return false;
619 }
620 }
621 return true;
622 }
623
624 /** Check if glGetTexParameteriv() returns correct border color for GL_TEXTURE_BORDER_COLOR_EXT pname
625 *
626 * @param target texture target to do the call for;
627 * @param expected_data pointer to buffer with expected data
628 * @return true if both buffers are a match.
629 */
verifyGLGetTexParameterivResult(glw::GLenum target,const glw::GLint * expected_data)630 bool TextureBorderClampParameterTextureBorderColor::verifyGLGetTexParameterivResult(glw::GLenum target,
631 const glw::GLint *expected_data)
632 {
633 std::vector<glw::GLint> buffer(m_buffer_length);
634 std::stringstream expectedDataStream;
635 std::stringstream returnedDataStream;
636 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
637
638 memset(&buffer[0], 0, m_buffer_length * sizeof(glw::GLint));
639
640 gl.getTexParameteriv(target, m_glExtTokens.TEXTURE_BORDER_COLOR, &buffer[0]);
641 GLU_EXPECT_NO_ERROR(gl.getError(), "Error getting parameter for texture.");
642
643 for (glw::GLuint i = 0; i < m_buffer_length; ++i)
644 {
645 if (expected_data[i] != buffer[i])
646 {
647 for (glw::GLuint j = 0; j < m_buffer_length; ++j)
648 {
649 expectedDataStream << expected_data[j] << ",";
650 returnedDataStream << buffer[j] << ",";
651 }
652 getTestContext().getLog()
653 << tcu::TestLog::Message
654 << "Wrong value encountered when calling glGetTexParameteriv() with GL_TEXTURE_BORDER_COLOR_EXT pname;"
655 << " texture target:" << getTexTargetString(target) << "\n"
656 << " expected values:[" << expectedDataStream.str() << "]"
657 << " result values:[" << returnedDataStream.str() << "]\n"
658 << tcu::TestLog::EndMessage;
659
660 return false;
661 }
662 }
663 return true;
664 }
665
666 /** Check if glGetTexParameterIivEXT() returns correct border color for GL_TEXTURE_BORDER_COLOR_EXT pname
667 *
668 * @param target texture target to do the call for;
669 * @param expected_data pointer to buffer with expected data
670 * @return true if both buffers are a match.
671 */
verifyGLGetTexParameterIivResult(glw::GLenum target,const glw::GLint * expected_data)672 bool TextureBorderClampParameterTextureBorderColor::verifyGLGetTexParameterIivResult(glw::GLenum target,
673 const glw::GLint *expected_data)
674 {
675 std::vector<glw::GLint> buffer(m_buffer_length);
676 std::stringstream expectedDataStream;
677 std::stringstream returnedDataStream;
678 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
679
680 memset(&buffer[0], 0, m_buffer_length * sizeof(glw::GLint));
681
682 gl.getTexParameterIiv(target, m_glExtTokens.TEXTURE_BORDER_COLOR, &buffer[0]);
683 GLU_EXPECT_NO_ERROR(gl.getError(), "Error getting parameter for texture.");
684
685 for (glw::GLuint i = 0; i < m_buffer_length; ++i)
686 {
687 if (expected_data[i] != buffer[i])
688 {
689 for (glw::GLuint j = 0; j < m_buffer_length; ++j)
690 {
691 expectedDataStream << expected_data[j] << ",";
692 returnedDataStream << buffer[j] << ",";
693 }
694 getTestContext().getLog() << tcu::TestLog::Message
695 << "Wrong value encountered when calling glGetTexParameterIivEXT() with "
696 "GL_TEXTURE_BORDER_COLOR_EXT pname;"
697 << " texture target:" << getTexTargetString(target) << "\n"
698 << " expected values:[" << expectedDataStream.str() << "]"
699 << " result values:[" << returnedDataStream.str() << "]\n"
700 << tcu::TestLog::EndMessage;
701
702 return false;
703 }
704 }
705 return true;
706 }
707
708 /** Check if glGetTexParameterIuivEXT() returns correct border color for GL_TEXTURE_BORDER_COLOR_EXT pname
709 *
710 * @param target texture target to do the call for;
711 * @param expected_data pointer to buffer with expected data
712 * @return true if both buffers are a match.
713 */
verifyGLGetTexParameterIuivResult(glw::GLenum target,const glw::GLuint * expected_data)714 bool TextureBorderClampParameterTextureBorderColor::verifyGLGetTexParameterIuivResult(glw::GLenum target,
715 const glw::GLuint *expected_data)
716 {
717 std::vector<glw::GLuint> buffer(m_buffer_length);
718 std::stringstream expectedDataStream;
719 std::stringstream returnedDataStream;
720 const glw::Functions &gl = m_context.getRenderContext().getFunctions();
721
722 memset(&buffer[0], 0, m_buffer_length * sizeof(glw::GLuint));
723
724 gl.getTexParameterIuiv(target, m_glExtTokens.TEXTURE_BORDER_COLOR, &buffer[0]);
725 GLU_EXPECT_NO_ERROR(gl.getError(), "Error getting parameter for texture.");
726
727 for (glw::GLuint i = 0; i < m_buffer_length; ++i)
728 {
729 if (expected_data[i] != buffer[i])
730 {
731 for (glw::GLuint j = 0; j < m_buffer_length; ++j)
732 {
733 expectedDataStream << expected_data[j] << ",";
734 returnedDataStream << buffer[j] << ",";
735 }
736 getTestContext().getLog() << tcu::TestLog::Message
737 << "Wrong value encountered when calling glGetTexParameterIuivEXT() with "
738 "GL_TEXTURE_BORDER_COLOR_EXT pname;"
739 << " texture target:" << getTexTargetString(target) << "\n"
740 << " expected values:[" << expectedDataStream.str() << "]"
741 << " result values:[" << returnedDataStream.str() << "]\n"
742 << tcu::TestLog::EndMessage;
743
744 return false;
745 }
746 }
747 return true;
748 }
749
750 } // namespace glcts
751