es3fFloatStateQueryTests.js (17057B)
1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES Utilities 3 * ------------------------------------------------ 4 * 5 * Copyright 2014 The Android Open Source Project 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 21 'use strict'; 22 goog.provide('functional.gles3.es3fFloatStateQueryTests'); 23 goog.require('framework.common.tcuTestCase'); 24 goog.require('framework.delibs.debase.deMath'); 25 goog.require('framework.delibs.debase.deRandom'); 26 goog.require('functional.gles3.es3fApiCase'); 27 goog.require('modules.shared.glsStateQuery'); 28 29 goog.scope(function() { 30 var es3fFloatStateQueryTests = functional.gles3.es3fFloatStateQueryTests; 31 var tcuTestCase = framework.common.tcuTestCase; 32 var deRandom = framework.delibs.debase.deRandom; 33 var deMath = framework.delibs.debase.deMath; 34 var es3fApiCase = functional.gles3.es3fApiCase; 35 var glsStateQuery = modules.shared.glsStateQuery; 36 37 /** 38 * @constructor 39 * @extends {es3fApiCase.ApiCase} 40 * @param {string} name 41 * @param {string} description 42 */ 43 es3fFloatStateQueryTests.DepthRangeCase = function(name, description) { 44 es3fApiCase.ApiCase.call(this, name, description, gl); 45 }; 46 47 es3fFloatStateQueryTests.DepthRangeCase.prototype = Object.create(es3fApiCase.ApiCase.prototype); 48 es3fFloatStateQueryTests.DepthRangeCase.prototype.constructor = es3fFloatStateQueryTests.DepthRangeCase; 49 50 es3fFloatStateQueryTests.DepthRangeCase.prototype.test = function() { 51 /** @type {deRandom.Random} */ var rnd = new deRandom.Random(0xabcdef); 52 53 this.check(glsStateQuery.verify(gl.DEPTH_RANGE, new Float32Array([0.0, 1.0]))); 54 55 /** @type {Array<Float32Array>} */ var fixedTests = [ 56 new Float32Array([0.5, 1.0]), 57 new Float32Array([0.0, 0.5]), 58 new Float32Array([0.0, 0.0]), 59 new Float32Array([1.0, 1.0]) 60 ]; 61 62 for (var ndx = 0; ndx < fixedTests.length; ++ndx) { 63 gl.depthRange(fixedTests[ndx][0], fixedTests[ndx][1]); 64 this.check(glsStateQuery.verify(gl.DEPTH_RANGE, fixedTests[ndx])); 65 } 66 67 /** @type {number} */ var numIterations = 120; 68 for (var i = 0; i < numIterations; ++i) { 69 // [dag] sorting to keep zNear < zFar 70 /** @type {Array<number>} */ var values = [rnd.getFloat(0, 1), rnd.getFloat(0, 1)].sort(); 71 /** @type {Float32Array} */ var depth = new Float32Array(values); 72 gl.depthRange(depth[0], depth[1]); 73 this.check(glsStateQuery.verify(gl.DEPTH_RANGE, depth)); 74 } 75 }; 76 77 /** 78 * @constructor 79 * @extends {es3fApiCase.ApiCase} 80 * @param {string} name 81 * @param {string} description 82 */ 83 es3fFloatStateQueryTests.LineWidthCase = function(name, description) { 84 es3fApiCase.ApiCase.call(this, name, description, gl); 85 }; 86 87 es3fFloatStateQueryTests.LineWidthCase.prototype = Object.create(es3fApiCase.ApiCase.prototype); 88 es3fFloatStateQueryTests.LineWidthCase.prototype.constructor = es3fFloatStateQueryTests.LineWidthCase; 89 90 es3fFloatStateQueryTests.LineWidthCase.prototype.test = function() { 91 /** @type {deRandom.Random} */ var rnd = new deRandom.Random(0xabcdef); 92 93 this.check(glsStateQuery.verify(gl.LINE_WIDTH, 1.0)); 94 95 /** @type {Float32Array} */ var range = /** @type {Float32Array} */ (gl.getParameter(gl.ALIASED_LINE_WIDTH_RANGE)); 96 97 /** @type {number} */ var numIterations = 120; 98 for (var i = 0; i < numIterations; ++i) { 99 /** @type {number} */ var reference = rnd.getFloat(range[0], range[1]); 100 101 gl.lineWidth(reference); 102 this.check(glsStateQuery.verify(gl.LINE_WIDTH, reference)); 103 } 104 }; 105 106 /** 107 * @constructor 108 * @extends {es3fApiCase.ApiCase} 109 * @param {string} name 110 * @param {string} description 111 */ 112 es3fFloatStateQueryTests.PolygonOffsetFactorCase = function(name, description) { 113 es3fApiCase.ApiCase.call(this, name, description, gl); 114 }; 115 116 es3fFloatStateQueryTests.PolygonOffsetFactorCase.prototype = Object.create(es3fApiCase.ApiCase.prototype); 117 es3fFloatStateQueryTests.PolygonOffsetFactorCase.prototype.constructor = es3fFloatStateQueryTests.PolygonOffsetFactorCase; 118 119 es3fFloatStateQueryTests.PolygonOffsetFactorCase.prototype.test = function() { 120 /** @type {deRandom.Random} */ var rnd = new deRandom.Random(0xabcdef); 121 122 this.check(glsStateQuery.verify(gl.POLYGON_OFFSET_FACTOR, 0.0)); 123 124 /** @type {Array<number>} */ var fixedTests = [0.0, 0.5, -0.5, 1.5]; 125 126 for (var ndx = 0; ndx < fixedTests.length; ++ndx) { 127 gl.polygonOffset(fixedTests[ndx], 0); 128 this.check(glsStateQuery.verify(gl.POLYGON_OFFSET_FACTOR, fixedTests[ndx])); 129 } 130 131 /** @type {number} */ var numIterations = 120; 132 for (var i = 0; i < numIterations; ++i) { 133 /** @type {number} */ var reference = rnd.getFloat(-64000, 64000); 134 135 gl.polygonOffset(reference, 0); 136 this.check(glsStateQuery.verify(gl.POLYGON_OFFSET_FACTOR, reference)); 137 } 138 }; 139 140 /** 141 * @constructor 142 * @extends {es3fApiCase.ApiCase} 143 * @param {string} name 144 * @param {string} description 145 */ 146 es3fFloatStateQueryTests.PolygonOffsetUnitsCase = function(name, description) { 147 es3fApiCase.ApiCase.call(this, name, description, gl); 148 }; 149 150 es3fFloatStateQueryTests.PolygonOffsetUnitsCase.prototype = Object.create(es3fApiCase.ApiCase.prototype); 151 es3fFloatStateQueryTests.PolygonOffsetUnitsCase.prototype.constructor = es3fFloatStateQueryTests.PolygonOffsetUnitsCase; 152 153 es3fFloatStateQueryTests.PolygonOffsetUnitsCase.prototype.test = function() { 154 /** @type {deRandom.Random} */ var rnd = new deRandom.Random(0xabcdef); 155 156 this.check(glsStateQuery.verify(gl.POLYGON_OFFSET_UNITS, 0.0)); 157 158 /** @type {Array<number>} */ var fixedTests = [0.0, 0.5, -0.5, 1.5]; 159 160 for (var ndx = 0; ndx < fixedTests.length; ++ndx) { 161 gl.polygonOffset(0, fixedTests[ndx]); 162 this.check(glsStateQuery.verify(gl.POLYGON_OFFSET_UNITS, fixedTests[ndx])); 163 } 164 165 /** @type {number} */ var numIterations = 120; 166 for (var i = 0; i < numIterations; ++i) { 167 /** @type {number} */ var reference = rnd.getFloat(-64000, 64000); 168 169 gl.polygonOffset(0, reference); 170 this.check(glsStateQuery.verify(gl.POLYGON_OFFSET_UNITS, reference)); 171 } 172 }; 173 174 /** 175 * @constructor 176 * @extends {es3fApiCase.ApiCase} 177 * @param {string} name 178 * @param {string} description 179 */ 180 es3fFloatStateQueryTests.SampleCoverageCase = function(name, description) { 181 es3fApiCase.ApiCase.call(this, name, description, gl); 182 }; 183 184 es3fFloatStateQueryTests.SampleCoverageCase.prototype = Object.create(es3fApiCase.ApiCase.prototype); 185 es3fFloatStateQueryTests.SampleCoverageCase.prototype.constructor = es3fFloatStateQueryTests.SampleCoverageCase; 186 187 es3fFloatStateQueryTests.SampleCoverageCase.prototype.test = function() { 188 /** @type {deRandom.Random} */ var rnd = new deRandom.Random(0xabcdef); 189 190 this.check(glsStateQuery.verify(gl.SAMPLE_COVERAGE_VALUE, 1.0)); 191 192 /** @type {Array<number>} */ var fixedTests = [0.0, 0.5, 0.45, 0.55]; 193 194 for (var ndx = 0; ndx < fixedTests.length; ++ndx) { 195 gl.sampleCoverage(fixedTests[ndx], false); 196 this.check(glsStateQuery.verify(gl.SAMPLE_COVERAGE_VALUE, fixedTests[ndx])); 197 } 198 199 /** @type {Array<number>} */ var clampTests = [-1.0, -1.5, 1.45, 3.55]; 200 201 for (var ndx = 0; ndx < clampTests.length; ++ndx) { 202 gl.sampleCoverage(clampTests[ndx], false); 203 this.check(glsStateQuery.verify(gl.SAMPLE_COVERAGE_VALUE, deMath.clamp(clampTests[ndx], 0.0, 1.0))); 204 } 205 206 /** @type {number} */ var numIterations = 120; 207 for (var i = 0; i < numIterations; ++i) { 208 /** @type {number} */ var reference = rnd.getFloat(0, 1); 209 /** @type {boolean} */ var invert = rnd.getBool() ? true : false; 210 211 gl.sampleCoverage(reference, invert); 212 this.check(glsStateQuery.verify(gl.SAMPLE_COVERAGE_VALUE, reference)); 213 } 214 }; 215 216 /** 217 * @constructor 218 * @extends {es3fApiCase.ApiCase} 219 * @param {string} name 220 * @param {string} description 221 */ 222 es3fFloatStateQueryTests.BlendColorCase = function(name, description) { 223 es3fApiCase.ApiCase.call(this, name, description, gl); 224 }; 225 226 es3fFloatStateQueryTests.BlendColorCase.prototype = Object.create(es3fApiCase.ApiCase.prototype); 227 es3fFloatStateQueryTests.BlendColorCase.prototype.constructor = es3fFloatStateQueryTests.BlendColorCase; 228 229 es3fFloatStateQueryTests.BlendColorCase.prototype.test = function() { 230 /** @type {deRandom.Random} */ var rnd = new deRandom.Random(0xabcdef); 231 232 this.check(glsStateQuery.verify(gl.BLEND_COLOR, new Float32Array([0, 0, 0, 0]))); 233 234 /** @type {Array<Float32Array>} */ var fixedTests = [ 235 new Float32Array([0.5, 1.0, 0.5, 1.0]), 236 new Float32Array([0.0, 0.5, 0.0, 0.5]), 237 new Float32Array([0.0, 0.0, 0.0, 0.0]), 238 new Float32Array([1.0, 1.0, 1.0, 1.0]) 239 ]; 240 for (var ndx = 0; ndx < fixedTests.length; ++ndx) { 241 gl.blendColor(fixedTests[ndx][0], fixedTests[ndx][1], fixedTests[ndx][2], fixedTests[ndx][3]); 242 this.check(glsStateQuery.verify(gl.BLEND_COLOR, fixedTests[ndx])); 243 } 244 245 /** @type {number} */ var numIterations = 120; 246 for (var i = 0; i < numIterations; ++i) { 247 /** @type {number} */ var r = rnd.getFloat(0, 1); 248 /** @type {number} */ var g = rnd.getFloat(0, 1); 249 /** @type {number} */ var b = rnd.getFloat(0, 1); 250 /** @type {number} */ var a = rnd.getFloat(0, 1); 251 252 gl.blendColor(r, g, b, a); 253 this.check(glsStateQuery.verify(gl.BLEND_COLOR, new Float32Array([r, g, b, a]))); 254 } 255 }; 256 257 /** 258 * @constructor 259 * @extends {es3fApiCase.ApiCase} 260 * @param {string} name 261 * @param {string} description 262 */ 263 es3fFloatStateQueryTests.ColorClearCase = function(name, description) { 264 es3fApiCase.ApiCase.call(this, name, description, gl); 265 }; 266 267 es3fFloatStateQueryTests.ColorClearCase.prototype = Object.create(es3fApiCase.ApiCase.prototype); 268 es3fFloatStateQueryTests.ColorClearCase.prototype.constructor = es3fFloatStateQueryTests.ColorClearCase; 269 270 es3fFloatStateQueryTests.ColorClearCase.prototype.test = function() { 271 /** @type {deRandom.Random} */ var rnd = new deRandom.Random(0xabcdef); 272 273 // [dag] In the C++ dEQP code, initial color clear value check is temorarily removed. (until the framework does not alter it) 274 this.check(glsStateQuery.verify(gl.COLOR_CLEAR_VALUE, new Float32Array([0, 0, 0, 0]))); 275 276 /** @type {Array<Float32Array>} */ var fixedTests = [ 277 new Float32Array([0.5, 1.0, 0.5, 1.0]), 278 new Float32Array([0.0, 0.5, 0.0, 0.5]), 279 new Float32Array([0.0, 0.0, 0.0, 0.0]), 280 new Float32Array([1.0, 1.0, 1.0, 1.0]) 281 ]; 282 for (var ndx = 0; ndx < fixedTests.length; ++ndx) { 283 gl.clearColor(fixedTests[ndx][0], fixedTests[ndx][1], fixedTests[ndx][2], fixedTests[ndx][3]); 284 this.check(glsStateQuery.verify(gl.COLOR_CLEAR_VALUE, fixedTests[ndx])); 285 } 286 287 /** @type {number} */ var numIterations = 120; 288 for (var i = 0; i < numIterations; ++i) { 289 /** @type {number} */ var r = rnd.getFloat(0, 1); 290 /** @type {number} */ var g = rnd.getFloat(0, 1); 291 /** @type {number} */ var b = rnd.getFloat(0, 1); 292 /** @type {number} */ var a = rnd.getFloat(0, 1); 293 294 gl.clearColor(r, g, b, a); 295 this.check(glsStateQuery.verify(gl.COLOR_CLEAR_VALUE, new Float32Array([r, g, b, a]))); 296 } 297 }; 298 299 /** 300 * @constructor 301 * @extends {es3fApiCase.ApiCase} 302 * @param {string} name 303 * @param {string} description 304 */ 305 es3fFloatStateQueryTests.DepthClearCase = function(name, description) { 306 es3fApiCase.ApiCase.call(this, name, description, gl); 307 }; 308 309 es3fFloatStateQueryTests.DepthClearCase.prototype = Object.create(es3fApiCase.ApiCase.prototype); 310 es3fFloatStateQueryTests.DepthClearCase.prototype.constructor = es3fFloatStateQueryTests.DepthClearCase; 311 312 es3fFloatStateQueryTests.DepthClearCase.prototype.test = function() { 313 /** @type {deRandom.Random} */ var rnd = new deRandom.Random(0xabcdef); 314 315 this.check(glsStateQuery.verify(gl.DEPTH_CLEAR_VALUE, 1)); 316 317 /** @type {number} */ var numIterations = 120; 318 for (var i = 0; i < numIterations; ++i) { 319 /** @type {number} */ var ref = rnd.getFloat(0, 1); 320 321 gl.clearDepth(ref); 322 this.check(glsStateQuery.verify(gl.DEPTH_CLEAR_VALUE, ref)); 323 } 324 }; 325 326 /** 327 * @constructor 328 * @extends {es3fApiCase.ApiCase} 329 * @param {string} name 330 * @param {string} description 331 */ 332 es3fFloatStateQueryTests.MaxTextureLODBiasCase = function(name, description) { 333 es3fApiCase.ApiCase.call(this, name, description, gl); 334 }; 335 336 es3fFloatStateQueryTests.MaxTextureLODBiasCase.prototype = Object.create(es3fApiCase.ApiCase.prototype); 337 es3fFloatStateQueryTests.MaxTextureLODBiasCase.prototype.constructor = es3fFloatStateQueryTests.MaxTextureLODBiasCase; 338 339 es3fFloatStateQueryTests.MaxTextureLODBiasCase.prototype.test = function() { 340 this.check(glsStateQuery.verifyGreaterOrEqual(gl.MAX_TEXTURE_LOD_BIAS, 2.0)); 341 }; 342 343 /** 344 * @constructor 345 * @extends {es3fApiCase.ApiCase} 346 * @param {string} name 347 * @param {string} description 348 */ 349 es3fFloatStateQueryTests.AliasedPointSizeRangeCase = function(name, description) { 350 es3fApiCase.ApiCase.call(this, name, description, gl); 351 }; 352 353 es3fFloatStateQueryTests.AliasedPointSizeRangeCase.prototype = Object.create(es3fApiCase.ApiCase.prototype); 354 es3fFloatStateQueryTests.AliasedPointSizeRangeCase.prototype.constructor = es3fFloatStateQueryTests.AliasedPointSizeRangeCase; 355 356 es3fFloatStateQueryTests.AliasedPointSizeRangeCase.prototype.test = function() { 357 var pointSizeRange = /** @type {Float32Array} */ (gl.getParameter(gl.ALIASED_POINT_SIZE_RANGE)); 358 /** @type {Float32Array} */ var reference = new Float32Array([1, 1]); 359 this.check(pointSizeRange[0] <= reference[0] && pointSizeRange[1] >= reference[1]); 360 }; 361 362 /** 363 * @constructor 364 * @extends {es3fApiCase.ApiCase} 365 * @param {string} name 366 * @param {string} description 367 */ 368 es3fFloatStateQueryTests.AliasedLineWidthRangeCase = function(name, description) { 369 es3fApiCase.ApiCase.call(this, name, description, gl); 370 }; 371 372 es3fFloatStateQueryTests.AliasedLineWidthRangeCase.prototype = Object.create(es3fApiCase.ApiCase.prototype); 373 es3fFloatStateQueryTests.AliasedLineWidthRangeCase.prototype.constructor = es3fFloatStateQueryTests.AliasedLineWidthRangeCase; 374 375 es3fFloatStateQueryTests.AliasedLineWidthRangeCase.prototype.test = function() { 376 var lineWidthRange = /** @type {Float32Array} */ (gl.getParameter(gl.ALIASED_LINE_WIDTH_RANGE)); 377 /** @type {Float32Array} */ var reference = new Float32Array([1, 1]); 378 this.check(lineWidthRange[0] <= reference[0] && lineWidthRange[1] >= reference[1]); 379 }; 380 381 /** 382 * @constructor 383 * @extends {tcuTestCase.DeqpTest} 384 */ 385 es3fFloatStateQueryTests.FloatStateQueryTests = function() { 386 tcuTestCase.DeqpTest.call(this, 'floats', 'Float Values'); 387 }; 388 389 es3fFloatStateQueryTests.FloatStateQueryTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype); 390 es3fFloatStateQueryTests.FloatStateQueryTests.prototype.constructor = es3fFloatStateQueryTests.FloatStateQueryTests; 391 392 es3fFloatStateQueryTests.FloatStateQueryTests.prototype.init = function() { 393 this.addChild(new es3fFloatStateQueryTests.DepthRangeCase('depth_range', 'DEPTH_RANGE')); 394 this.addChild(new es3fFloatStateQueryTests.LineWidthCase('line_width', 'LINE_WIDTH')); 395 this.addChild(new es3fFloatStateQueryTests.PolygonOffsetFactorCase('polygon_offset_factor', 'POLYGON_OFFSET_FACTOR')); 396 this.addChild(new es3fFloatStateQueryTests.PolygonOffsetUnitsCase('polygon_offset_units', 'POLYGON_OFFSET_UNITS')); 397 this.addChild(new es3fFloatStateQueryTests.SampleCoverageCase('sample_coverage_value', 'SAMPLE_COVERAGE_VALUE')); 398 this.addChild(new es3fFloatStateQueryTests.BlendColorCase('blend_color', 'BLEND_COLOR')); 399 this.addChild(new es3fFloatStateQueryTests.ColorClearCase('color_clear_value', 'COLOR_CLEAR_VALUE')); 400 this.addChild(new es3fFloatStateQueryTests.DepthClearCase('depth_clear_value', 'DEPTH_CLEAR_VALUE')); 401 this.addChild(new es3fFloatStateQueryTests.MaxTextureLODBiasCase('max_texture_lod_bias', 'MAX_TEXTURE_LOD_BIAS')); 402 this.addChild(new es3fFloatStateQueryTests.AliasedPointSizeRangeCase('aliased_point_size_range', 'ALIASED_POINT_SIZE_RANGE')); 403 this.addChild(new es3fFloatStateQueryTests.AliasedLineWidthRangeCase('aliased_line_width_range', 'ALIASED_LINE_WIDTH_RANGE')); 404 405 }; 406 407 /** 408 * Run test 409 * @param {WebGL2RenderingContext} context 410 */ 411 es3fFloatStateQueryTests.run = function(context) { 412 gl = context; 413 //Set up Test Root parameters 414 var state = tcuTestCase.runner; 415 state.setRoot(new es3fFloatStateQueryTests.FloatStateQueryTests()); 416 417 //Set up name and description of this test series. 418 setCurrentTestName(state.testCases.fullName()); 419 description(state.testCases.getDescription()); 420 421 try { 422 //Run test cases 423 tcuTestCase.runTestCases(); 424 } 425 catch (err) { 426 testFailedOptions('Failed to es3fFloatStateQueryTests.run tests', false); 427 tcuTestCase.runner.terminate(); 428 } 429 }; 430 431 });