tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

es3fBooleanStateQuery.js (14197B)

      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.es3fBooleanStateQuery');
     23 goog.require('framework.common.tcuTestCase');
     24 goog.require('functional.gles3.es3fApiCase');
     25 goog.require('modules.shared.glsStateQuery');
     26 
     27 goog.scope(function() {
     28 var es3fBooleanStateQuery = functional.gles3.es3fBooleanStateQuery;
     29 var tcuTestCase = framework.common.tcuTestCase;
     30 var glsStateQuery = modules.shared.glsStateQuery;
     31 var es3fApiCase = functional.gles3.es3fApiCase;
     32 
     33 var setParentClass = function(child, parent) {
     34    child.prototype = Object.create(parent.prototype);
     35    child.prototype.constructor = child;
     36 };
     37 
     38 /**
     39 * @constructor
     40 * @extends {es3fApiCase.ApiCase}
     41 * @param {string} name
     42 * @param {string} description
     43 * @param {number} targetName
     44 * @param {boolean} value
     45 */
     46 es3fBooleanStateQuery.IsEnabledStateTestCase = function(name, description, targetName, value) {
     47    es3fApiCase.ApiCase.call(this, name, description, gl);
     48    this.m_targetName = targetName;
     49    this.m_initial = value;
     50 };
     51 
     52 setParentClass(es3fBooleanStateQuery.IsEnabledStateTestCase, es3fApiCase.ApiCase);
     53 
     54 es3fBooleanStateQuery.IsEnabledStateTestCase.prototype.test = function() {
     55    // check inital value
     56    this.m_pass &= glsStateQuery.verify(this.m_targetName, this.m_initial);
     57 
     58    // check toggle
     59 
     60    gl.enable(this.m_targetName);
     61 
     62    this.m_pass &= glsStateQuery.verify(this.m_targetName, true);
     63 
     64    gl.disable(this.m_targetName);
     65 
     66    this.m_pass &= glsStateQuery.verify(this.m_targetName, false);
     67 };
     68 
     69 /**
     70 * @constructor
     71 * @extends {es3fApiCase.ApiCase}
     72 * @param {string} name
     73 * @param {string} description
     74 */
     75 es3fBooleanStateQuery.DepthWriteMaskTestCase = function(name, description) {
     76    es3fApiCase.ApiCase.call(this, name, description, gl);
     77 };
     78 
     79 setParentClass(es3fBooleanStateQuery.DepthWriteMaskTestCase, es3fApiCase.ApiCase);
     80 
     81 es3fBooleanStateQuery.DepthWriteMaskTestCase.prototype.test = function() {
     82    this.m_pass &= glsStateQuery.verify(gl.DEPTH_WRITEMASK, true);
     83 
     84    gl.depthMask(false);
     85    this.m_pass &= glsStateQuery.verify(gl.DEPTH_WRITEMASK, false);
     86 
     87    gl.depthMask(true);
     88    this.m_pass &= glsStateQuery.verify(gl.DEPTH_WRITEMASK, true);
     89 };
     90 
     91 /**
     92 * @constructor
     93 * @extends {es3fApiCase.ApiCase}
     94 * @param {string} name
     95 * @param {string} description
     96 */
     97 es3fBooleanStateQuery.SampleCoverageInvertTestCase = function(name, description) {
     98    es3fApiCase.ApiCase.call(this, name, description, gl);
     99 };
    100 
    101 setParentClass(es3fBooleanStateQuery.SampleCoverageInvertTestCase, es3fApiCase.ApiCase);
    102 
    103 es3fBooleanStateQuery.SampleCoverageInvertTestCase.prototype.test = function() {
    104    this.m_pass &= glsStateQuery.verify(gl.SAMPLE_COVERAGE_INVERT, false);
    105 
    106    gl.sampleCoverage(1, true);
    107    this.m_pass &= glsStateQuery.verify(gl.SAMPLE_COVERAGE_INVERT, true);
    108 
    109    gl.sampleCoverage(1, false);
    110    this.m_pass &= glsStateQuery.verify(gl.SAMPLE_COVERAGE_INVERT, false);
    111 };
    112 
    113 /**
    114 * @constructor
    115 * @extends {es3fApiCase.ApiCase}
    116 * @param {string} name
    117 * @param {string} description
    118 * @param {number} targetName
    119 * @param {boolean} value
    120 */
    121 es3fBooleanStateQuery.InitialBooleanTestCase = function(name, description, targetName, value) {
    122    es3fApiCase.ApiCase.call(this, name, description, gl);
    123    this.m_targetName = targetName;
    124    this.m_initial = value;
    125 };
    126 
    127 setParentClass(es3fBooleanStateQuery.InitialBooleanTestCase, es3fApiCase.ApiCase);
    128 
    129 es3fBooleanStateQuery.InitialBooleanTestCase.prototype.test = function() {
    130    // check inital value
    131    this.m_pass &= glsStateQuery.verify(this.m_targetName, this.m_initial);
    132 };
    133 
    134 /**
    135 * @constructor
    136 * @extends {es3fApiCase.ApiCase}
    137 * @param {string} name
    138 * @param {string} description
    139 */
    140 es3fBooleanStateQuery.ColorMaskTestCase = function(name, description) {
    141    es3fApiCase.ApiCase.call(this, name, description, gl);
    142 };
    143 
    144 setParentClass(es3fBooleanStateQuery.ColorMaskTestCase, es3fApiCase.ApiCase);
    145 
    146 es3fBooleanStateQuery.ColorMaskTestCase.prototype.test = function() {
    147    this.m_pass &= glsStateQuery.verify(gl.COLOR_WRITEMASK, [true, true, true, true]);
    148 
    149    var testMasks = [
    150        [true, true, true, true],
    151        [true, true, true, false],
    152        [true, true, false, true],
    153        [true, true, false, false],
    154        [true, false, true, true],
    155        [true, false, true, false],
    156        [true, false, false, true],
    157        [true, false, false, false],
    158        [false, true, true, true],
    159        [false, true, true, false],
    160        [false, true, false, true],
    161        [false, true, false, false],
    162        [false, false, true, true],
    163        [false, false, true, false],
    164        [false, false, false, true],
    165        [false, false, false, false]
    166    ];
    167 
    168    for (var ndx = 0; ndx < testMasks.length; ndx++) {
    169        var mask = testMasks[ndx];
    170        gl.colorMask(mask[0], mask[1], mask[2], mask[3]);
    171        this.m_pass &= glsStateQuery.verify(gl.COLOR_WRITEMASK, mask);
    172    }
    173 };
    174 
    175 /**
    176 * @constructor
    177 * @extends {es3fApiCase.ApiCase}
    178 * @param {string} name
    179 * @param {string} description
    180 */
    181 es3fBooleanStateQuery.TransformFeedbackTestCase = function(name, description) {
    182    es3fApiCase.ApiCase.call(this, name, description, gl);
    183    /** @type {WebGLTransformFeedback} */ this.m_transformfeedback = null;
    184 };
    185 
    186 setParentClass(es3fBooleanStateQuery.TransformFeedbackTestCase, es3fApiCase.ApiCase);
    187 
    188 es3fBooleanStateQuery.TransformFeedbackTestCase.prototype.testTransformFeedback = function() {
    189    throw new Error('Virtual function.');
    190 };
    191 
    192 es3fBooleanStateQuery.TransformFeedbackTestCase.prototype.test = function() {
    193    var transformFeedbackTestVertSource = '#version 300 es\n' +
    194                                                'void main (void)\n' +
    195                                                '{\n' +
    196                                                ' gl_Position = vec4(0.0);\n' +
    197                                                '}\n';
    198    var transformFeedbackTestFragSource = '#version 300 es\n' +
    199                                                'layout(location = 0) out mediump vec4 fragColor;' +
    200                                                'void main (void)\n' +
    201                                                '{\n' +
    202                                                ' fragColor = vec4(0.0);\n' +
    203                                                '}\n';
    204 
    205    this.m_transformfeedback = gl.createTransformFeedback();
    206 
    207    var shaderVert = gl.createShader(gl.VERTEX_SHADER);
    208    gl.shaderSource(shaderVert, transformFeedbackTestVertSource);
    209    gl.compileShader(shaderVert);
    210    this.m_pass &= glsStateQuery.verifyShader(shaderVert, gl.COMPILE_STATUS, true);
    211 
    212    var shaderFrag = gl.createShader(gl.FRAGMENT_SHADER);
    213    gl.shaderSource(shaderFrag, transformFeedbackTestFragSource);
    214    gl.compileShader(shaderFrag);
    215    this.m_pass &= glsStateQuery.verifyShader(shaderFrag, gl.COMPILE_STATUS, true);
    216 
    217    var shaderProg = gl.createProgram();
    218    gl.attachShader(shaderProg, shaderVert);
    219    gl.attachShader(shaderProg, shaderFrag);
    220    var transform_feedback_outputs = ['gl_Position'];
    221    gl.transformFeedbackVaryings(shaderProg, transform_feedback_outputs, gl.INTERLEAVED_ATTRIBS);
    222    gl.linkProgram(shaderProg);
    223    this.m_pass &= glsStateQuery.verifyProgram(shaderProg, gl.LINK_STATUS, true);
    224 
    225    gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, this.m_transformfeedback);
    226 
    227    var buffer = gl.createBuffer();
    228    gl.bindBuffer(gl.TRANSFORM_FEEDBACK_BUFFER, buffer);
    229    gl.bufferData(gl.TRANSFORM_FEEDBACK_BUFFER, 16, gl.DYNAMIC_READ);
    230    gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, 0, buffer);
    231 
    232    gl.useProgram(shaderProg);
    233 
    234    this.testTransformFeedback();
    235 
    236    gl.useProgram(null);
    237    gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
    238    gl.deleteTransformFeedback(this.m_transformfeedback);
    239    gl.deleteBuffer(buffer);
    240    gl.deleteShader(shaderVert);
    241    gl.deleteShader(shaderFrag);
    242    gl.deleteProgram(shaderProg);
    243 };
    244 
    245 /**
    246 * @constructor
    247 * @extends {es3fBooleanStateQuery.TransformFeedbackTestCase}
    248 * @param {string} name
    249 */
    250 es3fBooleanStateQuery.TransformFeedbackBasicTestCase = function(name) {
    251    es3fBooleanStateQuery.TransformFeedbackTestCase.call(this, name, 'Test TRANSFORM_FEEDBACK_ACTIVE and TRANSFORM_FEEDBACK_PAUSED');
    252 };
    253 
    254 setParentClass(es3fBooleanStateQuery.TransformFeedbackBasicTestCase, es3fBooleanStateQuery.TransformFeedbackTestCase);
    255 
    256 es3fBooleanStateQuery.TransformFeedbackBasicTestCase.prototype.testTransformFeedback = function() {
    257    gl.beginTransformFeedback(gl.POINTS);
    258 
    259    this.m_pass &= glsStateQuery.verify(gl.TRANSFORM_FEEDBACK_ACTIVE, true);
    260    this.m_pass &= glsStateQuery.verify(gl.TRANSFORM_FEEDBACK_PAUSED, false);
    261 
    262    gl.pauseTransformFeedback();
    263 
    264    this.m_pass &= glsStateQuery.verify(gl.TRANSFORM_FEEDBACK_ACTIVE, true);
    265    this.m_pass &= glsStateQuery.verify(gl.TRANSFORM_FEEDBACK_PAUSED, true);
    266 
    267    gl.resumeTransformFeedback();
    268 
    269    this.m_pass &= glsStateQuery.verify(gl.TRANSFORM_FEEDBACK_ACTIVE, true);
    270    this.m_pass &= glsStateQuery.verify(gl.TRANSFORM_FEEDBACK_PAUSED, false);
    271 
    272    gl.endTransformFeedback();
    273 
    274    this.m_pass &= glsStateQuery.verify(gl.TRANSFORM_FEEDBACK_ACTIVE, false);
    275    this.m_pass &= glsStateQuery.verify(gl.TRANSFORM_FEEDBACK_PAUSED, false);
    276 };
    277 
    278 /**
    279 * @constructor
    280 * @extends {es3fBooleanStateQuery.TransformFeedbackTestCase}
    281 * @param {string} name
    282 */
    283 es3fBooleanStateQuery.TransformFeedbackImplicitResumeTestCase = function(name) {
    284    es3fBooleanStateQuery.TransformFeedbackTestCase.call(this, name, 'EndTransformFeedback performs an implicit ResumeTransformFeedback.');
    285 };
    286 
    287 setParentClass(es3fBooleanStateQuery.TransformFeedbackImplicitResumeTestCase, es3fBooleanStateQuery.TransformFeedbackTestCase);
    288 
    289 es3fBooleanStateQuery.TransformFeedbackImplicitResumeTestCase.prototype.testTransformFeedback = function() {
    290    gl.beginTransformFeedback(gl.POINTS);
    291 
    292    this.m_pass &= glsStateQuery.verify(gl.TRANSFORM_FEEDBACK_ACTIVE, true);
    293    this.m_pass &= glsStateQuery.verify(gl.TRANSFORM_FEEDBACK_PAUSED, false);
    294 
    295    gl.pauseTransformFeedback();
    296 
    297    this.m_pass &= glsStateQuery.verify(gl.TRANSFORM_FEEDBACK_ACTIVE, true);
    298    this.m_pass &= glsStateQuery.verify(gl.TRANSFORM_FEEDBACK_PAUSED, true);
    299 
    300    gl.endTransformFeedback();
    301 
    302    this.m_pass &= glsStateQuery.verify(gl.TRANSFORM_FEEDBACK_ACTIVE, false);
    303    this.m_pass &= glsStateQuery.verify(gl.TRANSFORM_FEEDBACK_PAUSED, false);
    304 };
    305 
    306 /**
    307 * @constructor
    308 * @extends {tcuTestCase.DeqpTest}
    309 */
    310 es3fBooleanStateQuery.BooleanStateQuery = function() {
    311    tcuTestCase.DeqpTest.call(this, 'boolean', 'Boolean State Query tests');
    312 };
    313 
    314 es3fBooleanStateQuery.BooleanStateQuery.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
    315 es3fBooleanStateQuery.BooleanStateQuery.prototype.constructor = es3fBooleanStateQuery.BooleanStateQuery;
    316 
    317 es3fBooleanStateQuery.BooleanStateQuery.prototype.init = function() {
    318    var testRoot = this;
    319    var isEnableds = [
    320        ['rasterizer_discard', 'RASTERIZER_DISCARD', gl.RASTERIZER_DISCARD, false],
    321        ['cull_face', 'CULL_FACE', gl.CULL_FACE, false],
    322        ['polygon_offset_fill', 'POLYGON_OFFSET_FILL', gl.POLYGON_OFFSET_FILL, false],
    323        ['sample_alpha_to_coverage', 'SAMPLE_ALPHA_TO_COVERAGE', gl.SAMPLE_ALPHA_TO_COVERAGE, false],
    324        ['sample_coverage', 'SAMPLE_COVERAGE', gl.SAMPLE_COVERAGE, false],
    325        ['scissor_test', 'SCISSOR_TEST', gl.SCISSOR_TEST, false],
    326        ['stencil_test', 'STENCIL_TEST', gl.STENCIL_TEST, false],
    327        ['depth_test', 'DEPTH_TEST', gl.DEPTH_TEST, false],
    328        ['blend', 'BLEND', gl.BLEND, false],
    329        ['dither', 'DITHER', gl.DITHER, true]
    330    ];
    331    isEnableds.forEach(function(elem) {
    332        var name = elem[0];
    333        var description = elem[1];
    334        var targetName = elem[2];
    335        var value = elem[3];
    336        testRoot.addChild(new es3fBooleanStateQuery.IsEnabledStateTestCase(name, description, targetName, value));
    337    });
    338 
    339    testRoot.addChild(new es3fBooleanStateQuery.ColorMaskTestCase('color_writemask', 'COLOR_WRITEMASK'));
    340    testRoot.addChild(new es3fBooleanStateQuery.DepthWriteMaskTestCase('depth_writemask', 'DEPTH_WRITEMASK'));
    341    testRoot.addChild(new es3fBooleanStateQuery.SampleCoverageInvertTestCase('sample_coverage_invert', 'SAMPLE_COVERAGE_INVERT'));
    342    testRoot.addChild(new es3fBooleanStateQuery.InitialBooleanTestCase('transform_feedback_active_initial', 'initial TRANSFORM_FEEDBACK_ACTIVE', gl.TRANSFORM_FEEDBACK_ACTIVE, false));
    343    testRoot.addChild(new es3fBooleanStateQuery.InitialBooleanTestCase('transform_feedback_paused_initial', 'initial TRANSFORM_FEEDBACK_PAUSED', gl.TRANSFORM_FEEDBACK_PAUSED, false));
    344    testRoot.addChild(new es3fBooleanStateQuery.TransformFeedbackBasicTestCase('transform_feedback'));
    345    testRoot.addChild(new es3fBooleanStateQuery.TransformFeedbackImplicitResumeTestCase('transform_feedback_implicit_resume'));
    346 };
    347 
    348 /**
    349 * Run test
    350 * @param {WebGL2RenderingContext} context
    351 */
    352 es3fBooleanStateQuery.run = function(context) {
    353    gl = context;
    354    //Set up Test Root parameters
    355    var state = tcuTestCase.runner;
    356    state.setRoot(new es3fBooleanStateQuery.BooleanStateQuery());
    357 
    358    //Set up name and description of this test series.
    359    setCurrentTestName(state.testCases.fullName());
    360    description(state.testCases.getDescription());
    361 
    362    try {
    363        //Run test cases
    364        tcuTestCase.runTestCases();
    365    }
    366    catch (err) {
    367        testFailedOptions('Failed to es3fBooleanStateQuery.run tests', false);
    368        tcuTestCase.runner.terminate();
    369    }
    370 };
    371 
    372 });