tor-browser

es3fTextureSpecificationTests.js (287040B)

---

/*-------------------------------------------------------------------------
* drawElements Quality Program OpenGL ES Utilities
* ------------------------------------------------
*
* Copyright 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the 'License');
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an 'AS IS' BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/

'use strict';
goog.provide('functional.gles3.es3fTextureSpecificationTests');
goog.require('framework.common.tcuImageCompare');
goog.require('framework.common.tcuLogImage');
goog.require('framework.common.tcuPixelFormat');
goog.require('framework.common.tcuSurface');
goog.require('framework.common.tcuTestCase');
goog.require('framework.common.tcuTexture');
goog.require('framework.common.tcuTextureUtil');
goog.require('framework.delibs.debase.deMath');
goog.require('framework.delibs.debase.deRandom');
goog.require('framework.delibs.debase.deString');
goog.require('framework.opengl.gluShaderUtil');
goog.require('framework.opengl.gluTextureUtil');
goog.require('framework.opengl.simplereference.sglrGLContext');
goog.require('framework.opengl.simplereference.sglrReferenceContext');
goog.require('framework.referencerenderer.rrUtil');
goog.require('functional.gles3.es3fFboTestUtil');

goog.scope(function() {
   var es3fTextureSpecificationTests =
       functional.gles3.es3fTextureSpecificationTests;
   var tcuPixelFormat = framework.common.tcuPixelFormat;
   var tcuImageCompare = framework.common.tcuImageCompare;
   var tcuSurface = framework.common.tcuSurface;
   var tcuTestCase = framework.common.tcuTestCase;
   var tcuTexture = framework.common.tcuTexture;
   var tcuTextureUtil = framework.common.tcuTextureUtil;
   var deMath = framework.delibs.debase.deMath;
   var deRandom = framework.delibs.debase.deRandom;
   var deString = framework.delibs.debase.deString;
   var gluShaderUtil = framework.opengl.gluShaderUtil;
   var gluTextureUtil = framework.opengl.gluTextureUtil;
   var sglrGLContext = framework.opengl.simplereference.sglrGLContext;
   var sglrReferenceContext =
       framework.opengl.simplereference.sglrReferenceContext;
   var rrUtil = framework.referencerenderer.rrUtil;
   var es3fFboTestUtil = functional.gles3.es3fFboTestUtil;
   var tcuLogImage = framework.common.tcuLogImage;

   /**
    * @param {number} internalFormat
    * @return {tcuTexture.TextureFormat}
    */
   es3fTextureSpecificationTests.mapGLUnsizedInternalFormat = function(
       internalFormat
   ) {
       switch (internalFormat) {
           case gl.ALPHA:
               return new tcuTexture.TextureFormat(
                   tcuTexture.ChannelOrder.A,
                   tcuTexture.ChannelType.UNORM_INT8
               );
           case gl.LUMINANCE:
               return new tcuTexture.TextureFormat(
                   tcuTexture.ChannelOrder.L,
                   tcuTexture.ChannelType.UNORM_INT8
               );
           case gl.LUMINANCE_ALPHA:
               return new tcuTexture.TextureFormat(
                   tcuTexture.ChannelOrder.LA,
                   tcuTexture.ChannelType.UNORM_INT8
               );
           case gl.RGB:
               return new tcuTexture.TextureFormat(
                   tcuTexture.ChannelOrder.RGB,
                   tcuTexture.ChannelType.UNORM_INT8
               );
           case gl.RGBA:
               return new tcuTexture.TextureFormat(
                   tcuTexture.ChannelOrder.RGBA,
                   tcuTexture.ChannelType.UNORM_INT8
               );
           default:
               throw new Error(
                   'Can\'t map GL unsized internal format (' +
                   internalFormat.toString(16) + ') to texture format'
               );
       }
   };

   var VIEWPORT_WIDTH = 256;
   var VIEWPORT_HEIGHT = 256;

   /**
    * @param {number} width
    * @param {number} height
    * @param {number=} depth
    * @return {number}
    */
   es3fTextureSpecificationTests.maxLevelCount = function(
       width, height, depth
   ) {
       depth = depth || 0;
       return deMath.logToFloor(Math.max(width, Math.max(height, depth))) + 1;
   };

   /**
    * @param {deRandom.Random} rnd
    * @param {Array<number>} minVal
    * @param {Array<number>} maxVal
    * @param {number} size
    * @return {Array<number>}
    */
   es3fTextureSpecificationTests.randomVector = function(
       rnd, minVal, maxVal, size
   ) {
       var res = [];
       for (var ndx = 0; ndx < size; ndx++)
           res[ndx] = rnd.getFloat(minVal[ndx], maxVal[ndx]);
       return res;
   };

   /**
    * @param {tcuPixelFormat.PixelFormat} pixelFormat
    * @param {tcuTexture.TextureFormat} textureFormat
    * @return {Array<number>} (ivec4)
    */
   es3fTextureSpecificationTests.getPixelFormatCompareDepth = function(
       pixelFormat, textureFormat
   ) {
       switch (textureFormat.order) {
           case tcuTexture.ChannelOrder.L:
           case tcuTexture.ChannelOrder.LA:
               return [
                   pixelFormat.redBits, pixelFormat.redBits,
                   pixelFormat.redBits, pixelFormat.alphaBits
               ];
           default:
               return [
                   pixelFormat.redBits, pixelFormat.greenBits,
                   pixelFormat.blueBits, pixelFormat.alphaBits
               ];
       }
   };

   /**
    * @param {tcuPixelFormat.PixelFormat} pixelFormat
    * @param {tcuTexture.TextureFormat} textureFormat
    * @return {Array<number>} (uvec4)
    */
   es3fTextureSpecificationTests.computeCompareThreshold = function(
       pixelFormat, textureFormat
   ) {
       /** @type {Array<number>} */
       var texFormatBits = tcuTextureUtil.getTextureFormatBitDepth(
           textureFormat
       );
       /** @type {Array<number>} */
       var pixelFormatBits =
           es3fTextureSpecificationTests.getPixelFormatCompareDepth(
               pixelFormat, textureFormat
           );
       /** @type {Array<number>} */
       var accurateFmtBits = deMath.min(pixelFormatBits, texFormatBits);
       /** @type {Array<number>} */
       var compareBits = deMath.addScalar(
           tcuTextureUtil.select(
               accurateFmtBits, [8, 8, 8, 8],
               deMath.greaterThan(accurateFmtBits, [0, 0, 0, 0])
           ), - 1
       );

       var result = [];
       for (var i = 0; i < compareBits.length; i++)
           result.push(1 << compareBits[i]);
       return result;
   };

   /**
    * @constructor
    * @extends {tcuTestCase.DeqpTest}
    * @param {string} name
    * @param {string} desc
    * context
    */
   es3fTextureSpecificationTests.TextureSpecCase = function(name, desc) {
       tcuTestCase.DeqpTest.call(this, name, desc);
       /**
        * @type {
        *     ?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext
        * }
        */
        this.m_context = null;
   };

   es3fTextureSpecificationTests.TextureSpecCase.prototype = Object.create(
       tcuTestCase.DeqpTest.prototype
   );

   es3fTextureSpecificationTests.TextureSpecCase.prototype.constructor =
       es3fTextureSpecificationTests.TextureSpecCase;

   /**
    * deinit
    */
   es3fTextureSpecificationTests.TextureSpecCase.prototype.deinit =
   function() {
       gl.pixelStorei(gl.UNPACK_ALIGNMENT, 4);
       gl.pixelStorei(gl.UNPACK_ROW_LENGTH, 0);
       gl.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, 0);
       gl.pixelStorei(gl.UNPACK_SKIP_PIXELS, 0);
       gl.pixelStorei(gl.UNPACK_SKIP_ROWS, 0);
       gl.pixelStorei(gl.UNPACK_SKIP_IMAGES, 0);

       gl.bindBuffer(gl.PIXEL_UNPACK_BUFFER, null);
   }

   /**
    * createTexture - Needs to be overridden
    */
   es3fTextureSpecificationTests.TextureSpecCase.prototype.createTexture =
   function() {
       throw new Error('Must override');
   };

   /**
    * verifyTexture - Needs to be overridden
    * @param {sglrGLContext.GLContext} webgl2Context
    * @param {sglrReferenceContext.ReferenceContext} refContext
    * @return {boolean}
    */
   es3fTextureSpecificationTests.TextureSpecCase.prototype.verifyTexture =
   function(
       webgl2Context, refContext
   ) {
       throw new Error('Must override');
   };

   /**
    * @return {tcuTestCase.IterateResult}
    */
   es3fTextureSpecificationTests.TextureSpecCase.prototype.iterate = function() {
       if (gl.canvas.width < VIEWPORT_WIDTH ||
           gl.canvas.height < VIEWPORT_HEIGHT)
           throw new Error('Too small viewport', '');

       // Context size, and viewport for GLES3
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));
       var width = Math.min(gl.canvas.width, VIEWPORT_WIDTH);
       var height = Math.min(gl.canvas.height, VIEWPORT_HEIGHT);
       var x = rnd.getInt(0, gl.canvas.width - width);
       var y = rnd.getInt(0, gl.canvas.height - height);

       // Contexts.
       /** @type {sglrGLContext.GLContext} */
       var webgl2Context = new sglrGLContext.GLContext(
           gl, [x, y, width, height]
       );

       /** @type {sglrReferenceContext.ReferenceContextBuffers} */
       var refBuffers = new sglrReferenceContext.ReferenceContextBuffers(
           new tcuPixelFormat.PixelFormat(
               8, 8, 8, gl.getParameter(gl.ALPHA_BITS) ? 8 : 0
           ), 0 /* depth */, 0 /* stencil */, width, height
       );

       /** @type {sglrReferenceContext.ReferenceContext} */
       var refContext = new sglrReferenceContext.ReferenceContext(
           new sglrReferenceContext.ReferenceContextLimits(gl),
           refBuffers.getColorbuffer(), refBuffers.getDepthbuffer(),
           refBuffers.getStencilbuffer()
       );

       // Clear color buffer.
       for (var ndx = 0; ndx < 2; ndx++) {
           this.m_context = ndx ? refContext : webgl2Context;
           // C++ port uses (0.125, 0.25, 0.5, 1.0), but here we use (0, 0, 0, 0)
           // in order to optimize the `clear' op in ReferenceContext.
           this.m_context.clearColor(0, 0, 0, 0);
           this.m_context.clear(
               gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT |
               gl.STENCIL_BUFFER_BIT
           );
       }

       // Construct texture using both GLES3 and reference contexts.
       for (var ndx = 0; ndx < 2; ndx++) {
           this.m_context = ndx ? refContext : webgl2Context;
           this.createTexture();
           checkMessage(
               this.m_context.getError() == gl.NO_ERROR,
               'Problem creating texture.'
           );
       }

       // Verify results.
       if (this.verifyTexture(webgl2Context, refContext))
           testPassed();
       else
           testFailed('Verification failed');

       return tcuTestCase.IterateResult.STOP;
   };

   /**
    * @param {tcuSurface.Surface} dst
    * @param {
    *  ?WebGLProgram|
    *  framework.opengl.simplereference.sglrShaderProgram.ShaderProgram
    * } program
    * @param {number} width
    * @param {number} height
    */
   es3fTextureSpecificationTests.TextureSpecCase.prototype.renderTex =
   function(dst, program, width, height) {
       var targetW = this.m_context.getWidth();
       var targetH = this.m_context.getHeight();

       var w = width / targetW;
       var h = height / targetH;

       rrUtil.drawQuad(
           this.m_context, program, [-1.0, -1.0, 0.0],
           [-1.0 + w * 2.0, -1.0 + h * 2.0, 0.0]
       );

       // Read pixels back.
       dst.readViewport(this.m_context, [0, 0, width, height]);
   };

   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.TextureSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {tcuTexture.TextureFormat} format
    * @param {number} width
    * @param {number} height
    * @param {number} numLevels
    */
   es3fTextureSpecificationTests.Texture2DSpecCase = function(
       name, desc, format, width, height, numLevels
   ) {
       es3fTextureSpecificationTests.TextureSpecCase.call(this, name, desc);

       this.m_texFormat = format;
       this.m_texFormatInfo = tcuTextureUtil.getTextureFormatInfo(format);
       this.m_width = width;
       this.m_height = height;
       this.m_numLevels = numLevels;
   };

   es3fTextureSpecificationTests.Texture2DSpecCase.prototype = Object.create(
       es3fTextureSpecificationTests.TextureSpecCase.prototype
   );

   es3fTextureSpecificationTests.Texture2DSpecCase.prototype.constructor =
       es3fTextureSpecificationTests.Texture2DSpecCase;

   /**
    * @param {sglrGLContext.GLContext} webgl2Context
    * @param {sglrReferenceContext.ReferenceContext} refContext
    */
   es3fTextureSpecificationTests.Texture2DSpecCase.prototype.verifyTexture =
   function(
       webgl2Context, refContext
   ) {
       /** @type {es3fFboTestUtil.Texture2DShader} */
       var shader = new es3fFboTestUtil.Texture2DShader(
           [gluTextureUtil.getSampler2DType(this.m_texFormat)],
           gluShaderUtil.DataType.FLOAT_VEC4
       );

       var shaderIDgles = webgl2Context.createProgram(shader);
       var shaderIDRef = refContext.createProgram(shader);

       shader.setTexScaleBias(
           0, this.m_texFormatInfo.lookupScale,
           this.m_texFormatInfo.lookupBias
       );

       // Set state.
       for (var ndx = 0; ndx < 2; ndx++) {
           var ctx = ndx ? refContext : webgl2Context;

           this.m_context = ctx;

           this.m_context.texParameteri(
               gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST_MIPMAP_NEAREST
           );
           this.m_context.texParameteri(
               gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST
           );
           this.m_context.texParameteri(
               gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE
           );
           this.m_context.texParameteri(
               gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE
           );
           this.m_context.texParameteri(
               gl.TEXTURE_2D, gl.TEXTURE_MAX_LEVEL, this.m_numLevels - 1
           );
       }

       for (var levelNdx = 0; levelNdx < this.m_numLevels; levelNdx++) {
           var levelW = Math.max(1, this.m_width >> levelNdx);
           var levelH = Math.max(1, this.m_height >> levelNdx);
           /** @type {tcuSurface.Surface} */ var reference = new tcuSurface.Surface();
           /** @type {tcuSurface.Surface} */ var result = new tcuSurface.Surface();

           for (var ndx = 0; ndx < 2; ndx++) {
               /** @type {tcuSurface.Surface} */
               var dst = ndx ? reference : result;
               var ctx = ndx ? refContext : webgl2Context;
               var shaderID = ndx ? shaderIDRef : shaderIDgles;

               this.m_context = ctx;
               shader.setUniforms(ctx, shaderID);
               this.renderTex(dst, shaderID, levelW, levelH);
           }

           var threshold =
           es3fTextureSpecificationTests.computeCompareThreshold(
               tcuPixelFormat.PixelFormatFromContext(gl), this.m_texFormat
           );
           var levelStr = levelNdx.toString();
           var name = 'Level' + levelStr;
           var desc = 'Level ' + levelStr;
           var isOk = tcuImageCompare.intThresholdCompare(
               name, desc, reference.getAccess(), result.getAccess(),
               threshold, levelNdx == 0 ?
               tcuImageCompare.CompareLogMode.RESULT :
               tcuImageCompare.CompareLogMode.ON_ERROR
           );

           if (!isOk) {
               testFailed('Image comparison failed');
               return false;
           } else {
               // tcuLogImage.logImageWithInfo(result.getAccess(),'Comparison OK on level: ' + levelNdx);
           }
       }
       return true;
   };

   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.TextureSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {tcuTexture.TextureFormat} format
    * @param {number} size
    * @param {number} numLevels
    */
   es3fTextureSpecificationTests.TextureCubeSpecCase = function(
       name, desc, format, size, numLevels
   ) {
       es3fTextureSpecificationTests.TextureSpecCase.call(
           this, name, desc
       );
       this.m_texFormat = format;
       this.m_texFormatInfo = tcuTextureUtil.getTextureFormatInfo(format);
       this.m_size = size;
       this.m_numLevels = numLevels;
   };

   es3fTextureSpecificationTests.TextureCubeSpecCase.prototype =
       Object.create(es3fTextureSpecificationTests.TextureSpecCase.prototype);

   es3fTextureSpecificationTests.TextureCubeSpecCase.prototype.constructor =
       es3fTextureSpecificationTests.TextureCubeSpecCase;

   /**
    * @param {sglrGLContext.GLContext} webgl2Context
    * @param {sglrReferenceContext.ReferenceContext} refContext
    */
   es3fTextureSpecificationTests.TextureCubeSpecCase.prototype.verifyTexture =
   function(
       webgl2Context, refContext
   ) {
       /** @type {es3fFboTestUtil.TextureCubeShader} */
       var shader = new es3fFboTestUtil.TextureCubeShader(
           gluTextureUtil.getSamplerCubeType(this.m_texFormat),
           gluShaderUtil.DataType.FLOAT_VEC4
       );
       var shaderIDgles = webgl2Context.createProgram(shader);
       var shaderIDRef = refContext.createProgram(shader);

       shader.setTexScaleBias(
           this.m_texFormatInfo.lookupScale, this.m_texFormatInfo.lookupBias
       );

       // Set state.
       for (var ndx = 0; ndx < 2; ndx++) {
           var ctx = ndx ? refContext : webgl2Context;

           this.m_context = ctx;

           this.m_context.texParameteri(
               gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER,
               gl.NEAREST_MIPMAP_NEAREST
           );
           this.m_context.texParameteri(
               gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER,
               gl.NEAREST
           );
           this.m_context.texParameteri(
               gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S,
               gl.CLAMP_TO_EDGE
           );
           this.m_context.texParameteri(
               gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T,
               gl.CLAMP_TO_EDGE
           );
           this.m_context.texParameteri(
               gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAX_LEVEL,
               this.m_numLevels - 1
           );
       }

       for (var levelNdx = 0; levelNdx < this.m_numLevels; levelNdx++) {
           var levelSize = Math.max(1, this.m_size >> levelNdx);
           var isOk = true;

           for (var f in tcuTexture.CubeFace) {
               var face = tcuTexture.CubeFace[f];
               /** @type {tcuSurface.Surface} */
               var reference = new tcuSurface.Surface();
               /** @type {tcuSurface.Surface} */
               var result = new tcuSurface.Surface();

               if (levelSize <= 2)
                   continue; // Fuzzy compare doesn't work for images this small.

               shader.setFace(face);

               for (var ndx = 0; ndx < 2; ndx++) {
                   /** @type {tcuSurface.Surface} */
                   var dst = ndx ? reference : result;
                   ctx = ndx ? refContext : webgl2Context;
                   var shaderID = ndx ? shaderIDRef : shaderIDgles;

                   this.m_context = ctx;
                   shader.setUniforms(ctx, shaderID);
                   this.renderTex(dst, shaderID, levelSize, levelSize);
               }

               var threshold = 0.02;
               var faceStr = face.toString();
               var levelStr = levelNdx.toString();
               var name = 'Level' + levelStr;
               var desc = 'Level ' + levelStr + ', face ' + faceStr;
               var isFaceOk = tcuImageCompare.fuzzyCompare(
                   name, desc, reference.getAccess(), result.getAccess(),
                   threshold, levelNdx == 0 ?
                   tcuImageCompare.CompareLogMode.RESULT :
                   tcuImageCompare.CompareLogMode.ON_ERROR
               );

               if (!isFaceOk) {
                   testFailed('Image comparison failed');
                   return false;
               }
           }

       }
       return true;
   };

   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.TextureSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {tcuTexture.TextureFormat} format
    * @param {number} width
    * @param {number} height
    * @param {number} numLayers
    * @param {number} numLevels
    */
   es3fTextureSpecificationTests.Texture2DArraySpecCase = function(
       name, desc, format, width, height, numLayers, numLevels
   ) {
       es3fTextureSpecificationTests.TextureSpecCase.call(
           this, name, desc
       );
       this.m_texFormat = format;
       this.m_texFormatInfo = tcuTextureUtil.getTextureFormatInfo(format);
       this.m_width = width;
       this.m_height = height;
       this.m_numLayers = numLayers;
       this.m_numLevels = numLevels;
   };

   es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype =
       Object.create(es3fTextureSpecificationTests.TextureSpecCase.prototype);

   es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype.constructor =
       es3fTextureSpecificationTests.Texture2DArraySpecCase;

   /**
    * @param {sglrGLContext.GLContext} webgl2Context
    * @param {sglrReferenceContext.ReferenceContext} refContext
    */
   es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype.verifyTexture =
   function(
       webgl2Context, refContext
   ) {
       /** @type {es3fFboTestUtil.Texture2DArrayShader} */
       var shader = new es3fFboTestUtil.Texture2DArrayShader(
           gluTextureUtil.getSampler2DArrayType(this.m_texFormat),
           gluShaderUtil.DataType.FLOAT_VEC4
       );
       var shaderIDgles = webgl2Context.createProgram(shader);
       var shaderIDRef = refContext.createProgram(shader);

       shader.setTexScaleBias(
           this.m_texFormatInfo.lookupScale, this.m_texFormatInfo.lookupBias
       );

       // Set state.
       for (var ndx = 0; ndx < 2; ndx++) {
           var ctx = ndx ? refContext : webgl2Context;

           this.m_context = ctx;

           this.m_context.texParameteri(
               gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER,
               gl.NEAREST_MIPMAP_NEAREST
           );
           this.m_context.texParameteri(
               gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER,
               gl.NEAREST
           );
           this.m_context.texParameteri(
               gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_S,
               gl.CLAMP_TO_EDGE
           );
           this.m_context.texParameteri(
               gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_T,
               gl.CLAMP_TO_EDGE
           );
           this.m_context.texParameteri(
               gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_R,
               gl.CLAMP_TO_EDGE
           );
           this.m_context.texParameteri(
               gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAX_LEVEL,
               this.m_numLevels - 1
           );
       }

       for (var layerNdx = 0; layerNdx < this.m_numLayers; layerNdx++) {
           var layerOk = true;

           shader.setLayer(layerNdx);
           for (var levelNdx = 0; levelNdx < this.m_numLevels; levelNdx++) {
               var levelW = Math.max(1, this.m_width >> levelNdx);
               var levelH = Math.max(1, this.m_height >> levelNdx);

               if (levelW == 1 || levelH == 1) {
                   // Rendering to texture of size x1 is problematic in referencerenderer
                   // due to its deviation from c++ code: crbug.com/613206
                   continue;
               }
               /** @type {tcuSurface.Surface} */
               var reference = new tcuSurface.Surface();
               /** @type {tcuSurface.Surface} */
               var result = new tcuSurface.Surface();

               var isOk = true;

               for (var ndx = 0; ndx < 2; ndx++) {
                   /** @type {tcuSurface.Surface} */
                   var dst = ndx ? reference : result;
                   ctx = ndx ? refContext : webgl2Context;
                   var shaderID = ndx ? shaderIDRef : shaderIDgles;

                   this.m_context = ctx;
                   shader.setUniforms(ctx, shaderID);
                   this.renderTex(dst, shaderID, levelW, levelH);
               }

               var threshold =
               es3fTextureSpecificationTests.computeCompareThreshold(
                   tcuPixelFormat.PixelFormatFromContext(gl), this.m_texFormat
               );
               var levelStr = levelNdx.toString();
               var layerStr = layerNdx.toString();
               var name = 'Layer' + layerStr + 'Level' + levelStr;
               var desc = 'Layer ' + layerStr + ', Level ' + levelStr;
               var depthOk = tcuImageCompare.intThresholdCompare(
                   name, desc, reference.getAccess(), result.getAccess(),
                   threshold, (levelNdx == 0 && layerNdx == 0) ?
                   tcuImageCompare.CompareLogMode.RESULT :
                   tcuImageCompare.CompareLogMode.ON_ERROR
               );

               if (!depthOk) {
                   testFailed('Image comparison failed');
                   return false;
               }
           }

       }
       return true;
   };

   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.TextureSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {tcuTexture.TextureFormat} format
    * @param {number} width
    * @param {number} height
    * @param {number} depth
    * @param {number} numLevels
    */
   es3fTextureSpecificationTests.Texture3DSpecCase = function(
       name, desc, format, width, height, depth, numLevels
   ) {
       es3fTextureSpecificationTests.TextureSpecCase.call(
           this, name, desc
       );
       this.m_texFormat = format;
       this.m_texFormatInfo = tcuTextureUtil.getTextureFormatInfo(format);
       this.m_width = width;
       this.m_height = height;
       this.m_depth = depth;
       this.m_numLevels = numLevels;
   };

   es3fTextureSpecificationTests.Texture3DSpecCase.prototype =
       Object.create(es3fTextureSpecificationTests.TextureSpecCase.prototype);

   es3fTextureSpecificationTests.Texture3DSpecCase.prototype.constructor =
       es3fTextureSpecificationTests.Texture3DSpecCase;

   /**
    * @param {sglrGLContext.GLContext} webgl2Context
    * @param {sglrReferenceContext.ReferenceContext} refContext
    */
   es3fTextureSpecificationTests.Texture3DSpecCase.prototype.verifyTexture =
   function(
       webgl2Context, refContext
   ) {
       /** @type {es3fFboTestUtil.Texture3DShader} */
       var shader = new es3fFboTestUtil.Texture3DShader(
           gluTextureUtil.getSampler3D(this.m_texFormat),
           gluShaderUtil.DataType.FLOAT_VEC4
       );
       var shaderIDgles = webgl2Context.createProgram(shader);
       var shaderIDRef = refContext.createProgram(shader);

       shader.setTexScaleBias(
           this.m_texFormatInfo.lookupScale, this.m_texFormatInfo.lookupBias
       );

       // Set state.
       for (var ndx = 0; ndx < 2; ndx++) {
           var ctx = ndx ? refContext : webgl2Context;

           this.m_context = ctx;

           this.m_context.texParameteri(
               gl.TEXTURE_3D, gl.TEXTURE_MIN_FILTER,
               gl.NEAREST_MIPMAP_NEAREST
           );
           this.m_context.texParameteri(
               gl.TEXTURE_3D, gl.TEXTURE_MAG_FILTER,
               gl.NEAREST
           );
           this.m_context.texParameteri(
               gl.TEXTURE_3D, gl.TEXTURE_WRAP_S,
               gl.CLAMP_TO_EDGE
           );
           this.m_context.texParameteri(
               gl.TEXTURE_3D, gl.TEXTURE_WRAP_T,
               gl.CLAMP_TO_EDGE
           );
           this.m_context.texParameteri(
               gl.TEXTURE_3D, gl.TEXTURE_WRAP_R,
               gl.CLAMP_TO_EDGE
           );
           this.m_context.texParameteri(
               gl.TEXTURE_3D, gl.TEXTURE_MAX_LEVEL,
               this.m_numLevels - 1
           );
       }

       for (var levelNdx = 0; levelNdx < this.m_numLevels; levelNdx++) {
           var levelW = Math.max(1, this.m_width >> levelNdx);
           var levelH = Math.max(1, this.m_height >> levelNdx);
           var levelD = Math.max(1, this.m_depth >> levelNdx);
           var levelOk = true;

           if (levelW == 1 || levelH == 1) {
               // Rendering to texture of size x1 is problematic in referencerenderer
               // due to its deviation from c++ code: crbug.com/613206
               continue;
           }

           for (var depth = 0; depth < levelD; depth++) {
               /** @type {tcuSurface.Surface} */
               var reference = new tcuSurface.Surface();
               /** @type {tcuSurface.Surface} */
               var result = new tcuSurface.Surface();

               shader.setDepth((depth + 0.5) / levelD);

               for (var ndx = 0; ndx < 2; ndx++) {
                   /** @type {tcuSurface.Surface} */
                   var dst = ndx ? reference : result;
                   ctx = ndx ? refContext : webgl2Context;
                   var shaderID = ndx ? shaderIDRef : shaderIDgles;

                   this.m_context = ctx;
                   shader.setUniforms(ctx, shaderID);
                   this.renderTex(dst, shaderID, levelW, levelH);
               }

               var threshold =
               es3fTextureSpecificationTests.computeCompareThreshold(
                   tcuPixelFormat.PixelFormatFromContext(gl), this.m_texFormat
               );
               var levelStr = levelNdx.toString();
               var sliceStr = depth.toString();
               var name = 'Layer' + levelStr + 'Slice' + sliceStr;
               var desc = 'Layer ' + levelStr + ', Slice ' + sliceStr;
               var depthOk = tcuImageCompare.intThresholdCompare(
                   name, desc, reference.getAccess(), result.getAccess(),
                   threshold, (levelNdx == 0 && depth == 0) ?
                   tcuImageCompare.CompareLogMode.RESULT :
                   tcuImageCompare.CompareLogMode.ON_ERROR
               );

               if (!depthOk) {
                   testFailed('Image comparison failed');
                   return false;
               }
           }

       }
       return true;
   };

   // Basic TexImage2D() with 2D texture usage
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} format
    * @param {number} dataType
    * @param {number} width
    * @param {number} height
    */
   es3fTextureSpecificationTests.BasicTexImage2DCase = function(
       name, desc, format, dataType, width, height
   ) {
       // Unsized internal format.
       es3fTextureSpecificationTests.Texture2DSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLTransferFormat(
               format, dataType
           ), width, height,
           es3fTextureSpecificationTests.maxLevelCount(
               width, height
           )
       );

       this.m_internalFormat = format;
       this.m_format = format;
       this.m_dataType = dataType;
   };

   es3fTextureSpecificationTests.BasicTexImage2DCase.prototype = Object.create(
       es3fTextureSpecificationTests.Texture2DSpecCase.prototype
   );

   es3fTextureSpecificationTests.BasicTexImage2DCase.prototype.constructor =
       es3fTextureSpecificationTests.BasicTexImage2DCase;

   /**
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @return {es3fTextureSpecificationTests.BasicTexImage2DCase}
    */
   es3fTextureSpecificationTests.newBasicTexImage2DCaseInternal = function(
       name, desc, internalFormat, width, height
   ) {
       // Sized internal format.
       var fmt = gluTextureUtil.getTransferFormat(
           gluTextureUtil.mapGLInternalFormat(internalFormat)
       );
       var testcase = new es3fTextureSpecificationTests.BasicTexImage2DCase(
           name, desc, fmt.format, fmt.dataType, width, height
       );
       testcase.m_internalFormat = internalFormat;
       return testcase;
   };

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.BasicTexImage2DCase.prototype.createTexture =
   function() {
       var tex = null;
       var levelData = new tcuTexture.TextureLevel(
           this.m_texFormat, this.m_width, this.m_height
       );
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);
           var gMin = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );
           var gMax = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );

           levelData.setSize(levelW, levelH);
           tcuTextureUtil.fillWithComponentGradients(
               levelData.getAccess(), gMin, gMax
           );

           this.m_context.texImage2D(
               gl.TEXTURE_2D, ndx, this.m_internalFormat, levelW, levelH, 0,
               this.m_format, this.m_dataType,
               levelData.getAccess().getDataPtr()
           );
       }
   };

   // Basic TexImage2D() with cubemap usage
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} format
    * @param {number} dataType
    * @param {number} size
    */
   es3fTextureSpecificationTests.BasicTexImageCubeCase = function(
       name, desc, format, dataType, size
   ) {
       // Unsized internal format.
       es3fTextureSpecificationTests.TextureCubeSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLTransferFormat(
               format, dataType
           ), size, deMath.logToFloor(size) + 1
       );

       this.m_internalFormat = format;
       this.m_format = format;
       this.m_dataType = dataType;
   };

   es3fTextureSpecificationTests.BasicTexImageCubeCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.TextureCubeSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   BasicTexImageCubeCase.prototype.constructor =
       es3fTextureSpecificationTests.BasicTexImageCubeCase;

   /**
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} size
    * @return {es3fTextureSpecificationTests.BasicTexImageCubeCase}
    */
   es3fTextureSpecificationTests.newBasicTexImageCubeCaseInternal = function(
       name, desc, internalFormat, size
   ) {
       // Sized internal format.
       var fmt = gluTextureUtil.getTransferFormat(
           gluTextureUtil.mapGLInternalFormat(internalFormat)
       );
       var testcase = new es3fTextureSpecificationTests.BasicTexImageCubeCase(
           name, desc, fmt.format, fmt.dataType, size
       );
       testcase.m_internalFormat = internalFormat;
       return testcase;
   };

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   BasicTexImageCubeCase.prototype.createTexture =
   function() {
       var tex = null;
       var levelData = new tcuTexture.TextureLevel(
           this.m_texFormat, this.m_size, this.m_size
       );
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelSize = Math.max(1, this.m_size >> ndx);

           levelData.setSize(levelSize, levelSize);

           for (var f in tcuTexture.CubeFace) {
               var face = tcuTexture.CubeFace[f];
               var gMin = es3fTextureSpecificationTests.randomVector(
                   rnd, this.m_texFormatInfo.valueMin,
                   this.m_texFormatInfo.valueMax, 4
               );
               var gMax = es3fTextureSpecificationTests.randomVector(
                   rnd, this.m_texFormatInfo.valueMin,
                   this.m_texFormatInfo.valueMax, 4
               );

               tcuTextureUtil.fillWithComponentGradients(
                   levelData.getAccess(), gMin, gMax
               );

               this.m_context.texImage2D(
                   es3fTextureSpecificationTests.s_cubeMapFaces[face],
                   ndx, this.m_internalFormat, levelSize, levelSize, 0,
                   this.m_format, this.m_dataType,
                   levelData.getAccess().getDataPtr()
               );
           }
       }
   };

   // Basic TexImage3D() with 2D array texture usage
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DArraySpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @param {number} numLayers
    */
   es3fTextureSpecificationTests.BasicTexImage2DArrayCase = function(
       name, desc, internalFormat, width, height, numLayers
   ) {
       es3fTextureSpecificationTests.Texture2DArraySpecCase.call(
           this, name, desc,
           gluTextureUtil.mapGLInternalFormat(internalFormat), width, height,
           numLayers, es3fTextureSpecificationTests.maxLevelCount(
               width, height
           )
       );

       this.m_internalFormat = internalFormat;
   };

   es3fTextureSpecificationTests.BasicTexImage2DArrayCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype
       );

   es3fTextureSpecificationTests.
   BasicTexImage2DArrayCase.prototype.constructor =
       es3fTextureSpecificationTests.BasicTexImage2DArrayCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   BasicTexImage2DArrayCase.prototype.createTexture =
   function() {
       var tex = null;
       var levelData = new tcuTexture.TextureLevel(
           this.m_texFormat, this.m_width, this.m_height
       );
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));
       var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat);

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D_ARRAY, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);

           var gMin = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );
           var gMax = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );

           levelData.setSize(levelW, levelH, this.m_numLayers);
           tcuTextureUtil.fillWithComponentGradients(
               levelData.getAccess(), gMin, gMax
           );

           this.m_context.texImage3D(
               gl.TEXTURE_2D_ARRAY, ndx, this.m_internalFormat, levelW, levelH,
               this.m_numLayers, 0, transferFmt.format,
               transferFmt.dataType, levelData.getAccess().getDataPtr()
           );
       }
   };

   // Basic TexImage3D() with 3D texture usage
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture3DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @param {number} depth
    */
   es3fTextureSpecificationTests.BasicTexImage3DCase = function(
       name, desc, internalFormat, width, height, depth
   ) {
       es3fTextureSpecificationTests.Texture3DSpecCase.call(
           this, name, desc,
           gluTextureUtil.mapGLInternalFormat(internalFormat), width, height,
           depth, es3fTextureSpecificationTests.maxLevelCount(
               width, height, depth
           )
       );

       this.m_internalFormat = internalFormat;
   };

   es3fTextureSpecificationTests.BasicTexImage3DCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture3DSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   BasicTexImage3DCase.prototype.constructor =
       es3fTextureSpecificationTests.BasicTexImage3DCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   BasicTexImage3DCase.prototype.createTexture =
   function() {
       var tex = null;
       var levelData = new tcuTexture.TextureLevel(
           this.m_texFormat, this.m_width, this.m_height
       );
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));
       var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat);

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_3D, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);
           var levelD = Math.max(1, this.m_depth >> ndx);

           var gMin = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );
           var gMax = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );

           levelData.setSize(levelW, levelH, levelD);
           tcuTextureUtil.fillWithComponentGradients(
               levelData.getAccess(), gMin, gMax
           );

           this.m_context.texImage3D(
               gl.TEXTURE_3D, ndx, this.m_internalFormat, levelW, levelH,
               levelD, 0, transferFmt.format, transferFmt.dataType,
               levelData.getAccess().getDataPtr()
           );
       }
   };

   // Randomized 2D texture specification using TexImage2D
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} format
    * @param {number} dataType
    * @param {number} width
    * @param {number} height
    */
   es3fTextureSpecificationTests.RandomOrderTexImage2DCase = function(
       name, desc, format, dataType, width, height
   ) {
       // Unsized internal format.
       es3fTextureSpecificationTests.Texture2DSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLTransferFormat(
               format, dataType
           ), width, height,
           es3fTextureSpecificationTests.maxLevelCount(
               width, height
           )
       );

       this.m_internalFormat = format;
       this.m_format = format;
       this.m_dataType = dataType;
   };

   es3fTextureSpecificationTests.RandomOrderTexImage2DCase.prototype = Object.create(
       es3fTextureSpecificationTests.Texture2DSpecCase.prototype
   );

   es3fTextureSpecificationTests.
   RandomOrderTexImage2DCase.prototype.constructor =
       es3fTextureSpecificationTests.RandomOrderTexImage2DCase;

   /**
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @return {es3fTextureSpecificationTests.RandomOrderTexImage2DCase}
    */
   es3fTextureSpecificationTests.newRandomOrderTexImage2DCaseInternal =
   function(name, desc, internalFormat, width, height) {
       // Sized internal format.
       var fmt = gluTextureUtil.getTransferFormat(
           gluTextureUtil.mapGLInternalFormat(internalFormat)
       );
       var testcase = new es3fTextureSpecificationTests.RandomOrderTexImage2DCase(
           name, desc, fmt.format, fmt.dataType, width, height
       );
       testcase.m_internalFormat = internalFormat;
       return testcase;
   };

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   RandomOrderTexImage2DCase.prototype.createTexture = function() {
       var tex = null;
       var levelData = new tcuTexture.TextureLevel(
           this.m_texFormat, this.m_width, this.m_height
       );
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       var levels = [];
       for (var i = 0; i < this.m_numLevels; i++)
           levels[i] = i;
       levels = rnd.shuffle(levels);

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelNdx = levels[ndx];
           var levelW = Math.max(1, this.m_width >> levelNdx);
           var levelH = Math.max(1, this.m_height >> levelNdx);
           var gMin = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );
           var gMax = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );

           levelData.setSize(levelW, levelH);
           tcuTextureUtil.fillWithComponentGradients(
               levelData.getAccess(), gMin, gMax
           );

           this.m_context.texImage2D(
               gl.TEXTURE_2D, levelNdx, this.m_internalFormat, levelW, levelH, 0,
               this.m_format, this.m_dataType,
               levelData.getAccess().getDataPtr()
           );
       }
   };

   // Randomized cubemap texture specification using TexImage2D
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} format
    * @param {number} dataType
    * @param {number} size
    */
   es3fTextureSpecificationTests.RandomOrderTexImageCubeCase = function(
       name, desc, format, dataType, size
   ) {
       // Unsized internal format.
       es3fTextureSpecificationTests.TextureCubeSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLTransferFormat(
               format, dataType
           ), size, deMath.logToFloor(size) + 1
       );

       this.m_internalFormat = format;
       this.m_format = format;
       this.m_dataType = dataType;
   };

   es3fTextureSpecificationTests.RandomOrderTexImageCubeCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.TextureCubeSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   RandomOrderTexImageCubeCase.prototype.constructor =
       es3fTextureSpecificationTests.RandomOrderTexImageCubeCase;

   /**
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} size
    * @return {es3fTextureSpecificationTests.RandomOrderTexImageCubeCase}
    */
   es3fTextureSpecificationTests.newRandomOrderTexImageCubeCaseInternal =
   function(name, desc, internalFormat, size) {
       // Sized internal format.
       var fmt = gluTextureUtil.getTransferFormat(
           gluTextureUtil.mapGLInternalFormat(internalFormat)
       );
       var testcase = new es3fTextureSpecificationTests.RandomOrderTexImageCubeCase(
           name, desc, fmt.format, fmt.dataType, size
       );
       testcase.m_internalFormat = internalFormat;
       return testcase;
   };

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   RandomOrderTexImageCubeCase.prototype.createTexture =
   function() {
       var tex = null;
       var levelData = new tcuTexture.TextureLevel(
           this.m_texFormat, this.m_size, this.m_size
       );
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       // Level-face pairs.
       var images = [];

       for (var ndx = 0; ndx < this.m_numLevels; ndx++)
           for (var f in tcuTexture.CubeFace) {
               var face = tcuTexture.CubeFace[f];
               images[ndx * 6 + face] = {ndx: ndx, face: face};
           }

       images = rnd.shuffle(images);

       for (var ndx = 0; ndx < images.length; ndx++) {
           var levelNdx = images[ndx].ndx;
           /** @type {framework.common.tcuTexture.CubeFace} */
           var face = images[ndx].face;
           var levelSize = Math.max(1, this.m_size >> levelNdx);

           var gMin = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );
           var gMax = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );

           levelData.setSize(levelSize, levelSize);
           tcuTextureUtil.fillWithComponentGradients(
               levelData.getAccess(), gMin, gMax
           );

           this.m_context.texImage2D(
               es3fTextureSpecificationTests.s_cubeMapFaces[face],
               levelNdx, this.m_internalFormat, levelSize, levelSize, 0,
               this.m_format, this.m_dataType,
               levelData.getAccess().getDataPtr()
           );
       }
   };

   // TexImage2D() unpack alignment case.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} format
    * @param {number} dataType
    * @param {number} width
    * @param {number} height
    * @param {number} numLevels
    * @param {number} alignment
    */
   es3fTextureSpecificationTests.TexImage2DAlignCase = function(
       name, desc, format, dataType, width, height, numLevels, alignment
   ) {
       // Unsized internal format.
       es3fTextureSpecificationTests.Texture2DSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLTransferFormat(
               format, dataType
           ), width, height, numLevels
       );

       this.m_internalFormat = format;
       this.m_format = format;
       this.m_dataType = dataType;
       this.m_alignment = alignment;
   };

   es3fTextureSpecificationTests.TexImage2DAlignCase.prototype = Object.create(
       es3fTextureSpecificationTests.Texture2DSpecCase.prototype
   );

   es3fTextureSpecificationTests.
   TexImage2DAlignCase.prototype.constructor =
       es3fTextureSpecificationTests.TexImage2DAlignCase;

   /**
   * @param {string} name
   * @param {string} desc
   * @param {number} internalFormat
   * @param {number} width
   * @param {number} height
   * @param {number} numLevels
   * @param {number} alignment
    * @return {es3fTextureSpecificationTests.TexImage2DAlignCase}
    */
   es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal = function(
       name, desc, internalFormat, width, height, numLevels, alignment
   ) {
       // Sized internal format.
       var fmt = gluTextureUtil.getTransferFormat(
           gluTextureUtil.mapGLInternalFormat(internalFormat)
       );
       var testcase = new es3fTextureSpecificationTests.TexImage2DAlignCase(
           name, desc, fmt.format, fmt.dataType,
           width, height, numLevels, alignment
       );
       testcase.m_internalFormat = internalFormat;
       return testcase;
   };

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.TexImage2DAlignCase.prototype.createTexture =
   function() {
       var tex = null;
       /** @type {ArrayBuffer} */ var data;

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment);

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);
           var colorA = deMath.add(
               deMath.multiply(
                   [1.0, 0.0, 0.0, 1.0],
                   deMath.subtract(
                       this.m_texFormatInfo.valueMax,
                       this.m_texFormatInfo.valueMin
                   )
               ), this.m_texFormatInfo.valueMin
           );
           var colorB = deMath.add(
               deMath.multiply(
                   [0.0, 1.0, 0.0, 1.0],
                   deMath.subtract(
                       this.m_texFormatInfo.valueMax,
                       this.m_texFormatInfo.valueMin
                   )
               ), this.m_texFormatInfo.valueMin
           );

           var rowPitch = deMath.deAlign32(
               levelW * this.m_texFormat.getPixelSize(), this.m_alignment
           );
           var cellSize = Math.max(1, Math.min(levelW >> 2, levelH >> 2));
           data = new ArrayBuffer(rowPitch * levelH);
           var access = new tcuTexture.PixelBufferAccess({format: this.m_texFormat, width: levelW,
                   height: levelH, rowPitch: rowPitch, data: data}
               );
           tcuTextureUtil.fillWithGrid(access, cellSize, colorA, colorB
           );

           this.m_context.texImage2D(
               gl.TEXTURE_2D, ndx, this.m_internalFormat, levelW, levelH, 0,
               this.m_format, this.m_dataType,
               access.getDataPtr()
           );
       }
   };

   // TexImageCube unpack alignment case.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} format
    * @param {number} dataType
    * @param {number} size
    * @param {number} numLevels
    * @param {number} alignment
    */
   es3fTextureSpecificationTests.TexImageCubeAlignCase = function(
       name, desc, format, dataType, size, numLevels, alignment
   ) {
       // Unsized internal format.
       es3fTextureSpecificationTests.TextureCubeSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLTransferFormat(
               format, dataType
           ), size, numLevels
       );

       this.m_internalFormat = format;
       this.m_format = format;
       this.m_dataType = dataType;
       this.m_alignment = alignment;
   };

   es3fTextureSpecificationTests.TexImageCubeAlignCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.TextureCubeSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexImageCubeAlignCase.prototype.constructor =
       es3fTextureSpecificationTests.TexImageCubeAlignCase;

   /**
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} size
    * @param {number} numLevels
    * @param {number} alignment
    * @return {es3fTextureSpecificationTests.TexImageCubeAlignCase}
    */
   es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal =
   function(name, desc, internalFormat, size, numLevels, alignment) {
       // Sized internal format.
       var fmt = gluTextureUtil.getTransferFormat(
           gluTextureUtil.mapGLInternalFormat(internalFormat)
       );
       var testcase = new es3fTextureSpecificationTests.TexImageCubeAlignCase(
           name, desc, fmt.format, fmt.dataType, size, numLevels, alignment
       );
       testcase.m_internalFormat = internalFormat;
       return testcase;
   };

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexImageCubeAlignCase.prototype.createTexture =
   function() {
       var tex = null;
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));
       /** @type {ArrayBuffer} */ var data;

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment);

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelSize = Math.max(1, this.m_size >> ndx);
           var cellSize = Math.max(1, levelSize >> 2);
           var rowPitch = deMath.deAlign32(
               this.m_texFormat.getPixelSize() * levelSize, this.m_alignment
           );
           var colorA = deMath.add(deMath.multiply(
               [1.0, 0.0, 0.0, 1.0], deMath.subtract(
                   this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin
               )), this.m_texFormatInfo.valueMin
           );
           var colorB = deMath.add(deMath.multiply(
               [0.0, 1.0, 0.0, 1.0], deMath.subtract(
                   this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin
               )), this.m_texFormatInfo.valueMin
           );

           data = new ArrayBuffer(rowPitch * levelSize);
           var access = new tcuTexture.PixelBufferAccess({format: this.m_texFormat, width: levelSize,
                   height: levelSize, rowPitch: rowPitch, data: data}
               );
           tcuTextureUtil.fillWithGrid(access, cellSize, colorA, colorB
           );

           for (var f in tcuTexture.CubeFace) {
               var face = tcuTexture.CubeFace[f];
               this.m_context.texImage2D(
                   es3fTextureSpecificationTests.s_cubeMapFaces[face],
                   ndx, this.m_internalFormat, levelSize, levelSize, 0,
                   this.m_format, this.m_dataType,
                   access.getDataPtr()
               );
           }
       }
   };

   // TexImage2D() unpack parameters case.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @param {number} rowLength
    * @param {number} skipRows
    * @param {number} skipPixels
    * @param {number} alignment
    */
   es3fTextureSpecificationTests.TexImage2DParamsCase = function(
       name, desc, internalFormat, width, height, rowLength, skipRows,
       skipPixels, alignment
   ) {
       es3fTextureSpecificationTests.Texture2DSpecCase.call(
           this, name, desc,
           gluTextureUtil.mapGLInternalFormat(internalFormat),
           width, height, 1
       );
       this.m_internalFormat = internalFormat;
       this.m_rowLength = rowLength;
       this.m_skipRows = skipRows;
       this.m_skipPixels = skipPixels;
       this.m_alignment = alignment;
   };

   es3fTextureSpecificationTests.TexImage2DParamsCase.prototype =
   Object.create(es3fTextureSpecificationTests.Texture2DSpecCase.prototype);

   es3fTextureSpecificationTests.TexImage2DParamsCase.prototype.constructor =
       es3fTextureSpecificationTests.TexImage2DParamsCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.TexImage2DParamsCase.prototype.createTexture =
   function() {
       var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat);
       var pixelSize = this.m_texFormat.getPixelSize();
       var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_width;
       var rowPitch = deMath.deAlign32(rowLength * pixelSize, this.m_alignment);
       var height = this.m_height + this.m_skipRows;
       var tex = null;
       /** @type {ArrayBuffer} */ var data;

       assertMsgOptions(
           this.m_numLevels == 1, 'Number of levels different to 1',
           false, true
       );

       // Fill data with grid.
       data = new ArrayBuffer(rowPitch * height + this.m_skipPixels * pixelSize);

       var cScale = deMath.subtract(
           this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin
       );
       var cBias = this.m_texFormatInfo.valueMin;
       var colorA = deMath.add(
           deMath.multiply(
               [1.0, 0.0, 0.0, 1.0], cScale
           ), cBias
       );
       var colorB = deMath.add(
           deMath.multiply(
               [0.0, 1.0, 0.0, 1.0], cScale
           ), cBias
       );

       var accessWithOffset = new tcuTexture.PixelBufferAccess({
               format: this.m_texFormat,
               width: this.m_width,
               height: this.m_height,
               rowPitch: rowPitch,
               data: data,
               offset: this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize
               });
       tcuTextureUtil.fillWithGrid(accessWithOffset, 4, colorA, colorB
       );
       var access = new tcuTexture.PixelBufferAccess({
               format: this.m_texFormat,
               width: this.m_width,
               height: this.m_height,
               rowPitch: rowPitch,
               data: data,
               });

       this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment);

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D, tex);
       this.m_context.texImage2D(
           gl.TEXTURE_2D, 0, this.m_internalFormat,
           this.m_width, this.m_height, 0,
           transferFmt.format, transferFmt.dataType, access.getDataPtr()
       );
   };

   // TexImage3D() unpack parameters case.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture3DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @param {number} depth
    * @param {number} imageHeight
    * @param {number} rowLength
    * @param {number} skipImages
    * @param {number} skipRows
    * @param {number} skipPixels
    * @param {number} alignment
    */
   es3fTextureSpecificationTests.TexImage3DParamsCase = function(
       name, desc, internalFormat, width, height, depth, imageHeight,
       rowLength, skipImages, skipRows, skipPixels, alignment
   ) {
       es3fTextureSpecificationTests.Texture3DSpecCase.call(
           this, name, desc,
           gluTextureUtil.mapGLInternalFormat(internalFormat),
           width, height, depth, 1
       );

       this.m_internalFormat = internalFormat;
       this.m_imageHeight = imageHeight;
       this.m_rowLength = rowLength;
       this.m_skipImages = skipImages;
       this.m_skipRows = skipRows;
       this.m_skipPixels = skipPixels;
       this.m_alignment = alignment;
   };

   es3fTextureSpecificationTests.TexImage3DParamsCase.prototype =
   Object.create(es3fTextureSpecificationTests.Texture3DSpecCase.prototype);

   es3fTextureSpecificationTests.TexImage3DParamsCase.prototype.constructor =
       es3fTextureSpecificationTests.Texture3DSpecCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.TexImage3DParamsCase.prototype.createTexture =
   function() {
       var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat);
       var pixelSize = this.m_texFormat.getPixelSize();
       var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_width;
       var rowPitch = deMath.deAlign32(rowLength * pixelSize, this.m_alignment);
       var imageHeight = this.m_imageHeight > 0 ?
           this.m_imageHeight : this.m_height;
       var slicePitch = imageHeight * rowPitch;

       var tex = null;
       /** @type {ArrayBuffer} */ var data;

       assertMsgOptions(
           this.m_numLevels == 1, 'Number of levels different to 1',
           false, true
       );

       // Fill data with grid.
       data = new ArrayBuffer(slicePitch * (this.m_depth + this.m_skipImages) +
                              this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize);

       var cScale = deMath.subtract(
           this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin
       );
       var cBias = this.m_texFormatInfo.valueMin;
       var colorA = deMath.add(
           deMath.multiply(
               [1.0, 0.0, 0.0, 1.0], cScale
           ), cBias
       );
       var colorB = deMath.add(
           deMath.multiply(
               [0.0, 1.0, 0.0, 1.0], cScale
           ), cBias
       );

       var accessWithOffset = new tcuTexture.PixelBufferAccess({
               format: this.m_texFormat,
               width: this.m_width,
               height: this.m_height,
               depth: this.m_depth,
               rowPitch: rowPitch,
               slicePitch: slicePitch,
               data: data,
               offset: this.m_skipImages * slicePitch + this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize
           });
       var access = new tcuTexture.PixelBufferAccess({
               format: this.m_texFormat,
               width: this.m_width,
               height: this.m_height,
               depth: this.m_depth,
               rowPitch: rowPitch,
               slicePitch: slicePitch,
               data: data
           });
       tcuTextureUtil.fillWithGrid(
           accessWithOffset, 4, colorA, colorB
       );

       this.m_context.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, this.m_imageHeight);
       this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_IMAGES, this.m_skipImages);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment);

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_3D, tex);
       this.m_context.texImage3D(
           gl.TEXTURE_3D, 0, this.m_internalFormat,
           this.m_width, this.m_height, this.m_depth, 0,
           transferFmt.format, transferFmt.dataType, access.getDataPtr()
       );
   };

   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} format
    * @param {number} dataType
    * @param {number} width
    * @param {number} height
    */
   es3fTextureSpecificationTests.BasicTexSubImage2DCase = function(
       name, desc, format, dataType, width, height
   ) {
       es3fTextureSpecificationTests.Texture2DSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLTransferFormat(
               format, dataType
           ), width, height, es3fTextureSpecificationTests.maxLevelCount(
               width, height
           )
       );

       this.m_format = format;
       this.m_internalFormat = format;
       this.m_dataType = dataType;
   };

   es3fTextureSpecificationTests.BasicTexSubImage2DCase.prototype =
   Object.create(es3fTextureSpecificationTests.Texture2DSpecCase.prototype);

   es3fTextureSpecificationTests.BasicTexSubImage2DCase.prototype.constructor =
       es3fTextureSpecificationTests.BasicTexSubImage2DCase;

   /**
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @return {es3fTextureSpecificationTests.BasicTexSubImage2DCase}
    */
   es3fTextureSpecificationTests.newBasicTexSubImage2DCaseInternal =
   function(name, desc, internalFormat, width, height) {
       // Sized internal format.
       var fmt = gluTextureUtil.getTransferFormat(
           gluTextureUtil.mapGLInternalFormat(internalFormat)
       );
       var testcase = new es3fTextureSpecificationTests.BasicTexSubImage2DCase(
           name, desc, fmt.format, fmt.dataType, width, height
       );
       testcase.m_internalFormat = internalFormat;
       return testcase;
   };

   /**
    */
   es3fTextureSpecificationTests.
   BasicTexSubImage2DCase.prototype.createTexture = function() {
       var tex = null;
       var data = new tcuTexture.TextureLevel(
           this.m_texFormat, this.m_width, this.m_height
       );
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);
           var gMin = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );
           var gMax = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );

           data.setSize(levelW, levelH);
           tcuTextureUtil.fillWithComponentGradients(
               data.getAccess(), gMin, gMax
           );

           this.m_context.texImage2D(
               gl.TEXTURE_2D, ndx, this.m_internalFormat, levelW, levelH, 0,
               this.m_format, this.m_dataType,
               data.getAccess().getDataPtr()
           );
       }

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);

           var w = rnd.getInt(1, levelW);
           var h = rnd.getInt(1, levelH);
           var x = rnd.getInt(0, levelW - w);
           var y = rnd.getInt(0, levelH - h);

           var colorA = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );
           var colorB = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );
           var cellSize = rnd.getInt(2, 16);

           data.setSize(w, h);
           tcuTextureUtil.fillWithGrid(
               data.getAccess(), cellSize, colorA, colorB
           );

           this.m_context.texSubImage2D(
               gl.TEXTURE_2D, ndx, x, y, w, h, this.m_format, this.m_dataType,
               data.getAccess().getDataPtr()
           );
       }
   };

   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} format
    * @param {number} dataType
    * @param {number} size
    */
   es3fTextureSpecificationTests.BasicTexSubImageCubeCase = function(
       name, desc, format, dataType, size
   ) {
       es3fTextureSpecificationTests.TextureCubeSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLTransferFormat(
               format, dataType
           ), size, deMath.logToFloor(size) + 1
       );

       this.m_internalFormat = format;
       this.m_format = format;
       this.m_dataType = dataType;
   };

   es3fTextureSpecificationTests.BasicTexSubImageCubeCase.prototype =
   Object.create(es3fTextureSpecificationTests.TextureCubeSpecCase.prototype);

   es3fTextureSpecificationTests.
   BasicTexSubImageCubeCase.prototype.constructor =
       es3fTextureSpecificationTests.BasicTexSubImageCubeCase;

   /**
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} size
    */
   es3fTextureSpecificationTests.newBasicTexSubImageCubeCaseInternal =
   function(name, desc, internalFormat, size) {
       // Sized internal format.
       var fmt = gluTextureUtil.getTransferFormat(
           gluTextureUtil.mapGLInternalFormat(internalFormat)
       );
       var testcase =
           new es3fTextureSpecificationTests.BasicTexSubImageCubeCase(
           name, desc, fmt.format, fmt.dataType,
           size);
       testcase.m_internalFormat = internalFormat;
       return testcase;
   };

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   BasicTexSubImageCubeCase.prototype.createTexture = function() {
       var tex = null;
       var data = new tcuTexture.TextureLevel(
           this.m_texFormat, this.m_size, this.m_size
       );
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelSize = Math.max(1, this.m_size >> ndx);
           data.setSize(levelSize, levelSize);

           for (var face = /** @type {tcuTexture.CubeFace} */ (0);
               face < es3fTextureSpecificationTests.s_cubeMapFaces.length;
               face++) {
               var gMin = es3fTextureSpecificationTests.randomVector(
                   rnd, this.m_texFormatInfo.valueMin,
                   this.m_texFormatInfo.valueMax, 4
               );
               var gMax = es3fTextureSpecificationTests.randomVector(
                   rnd, this.m_texFormatInfo.valueMin,
                   this.m_texFormatInfo.valueMax, 4
               );

               tcuTextureUtil.fillWithComponentGradients(
                   data.getAccess(), gMin, gMax
               );

               this.m_context.texImage2D(
                   es3fTextureSpecificationTests.s_cubeMapFaces[face], ndx,
                   this.m_internalFormat, levelSize, levelSize, 0,
                   this.m_format, this.m_dataType,
                   data.getAccess().getDataPtr()
               );
           }
       }

       // Re-specify parts of each face and level.
       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelSize = Math.max(1, this.m_size >> ndx);

           for (var f in tcuTexture.CubeFace) {
               var face = tcuTexture.CubeFace[f];

               var w = rnd.getInt(1, levelSize);
               var h = rnd.getInt(1, levelSize);
               var x = rnd.getInt(0, levelSize - w);
               var y = rnd.getInt(0, levelSize - h);

               var colorA = es3fTextureSpecificationTests.randomVector(
                   rnd, this.m_texFormatInfo.valueMin,
                   this.m_texFormatInfo.valueMax, 4
               );
               var colorB = es3fTextureSpecificationTests.randomVector(
                   rnd, this.m_texFormatInfo.valueMin,
                   this.m_texFormatInfo.valueMax, 4
               );
               var cellSize = rnd.getInt(2, 16);

               data.setSize(w, h);
               tcuTextureUtil.fillWithGrid(
                   data.getAccess(), cellSize, colorA, colorB
               );

               this.m_context.texSubImage2D(
                   es3fTextureSpecificationTests.s_cubeMapFaces[face],
                   ndx, x, y, w, h, this.m_format,
                   this.m_dataType, data.getAccess().getDataPtr()
               );
           }
       }
   };

   // TexSubImage2D() unpack parameters case.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @param {number} subX
    * @param {number} subY
    * @param {number} subW
    * @param {number} subH
    * @param {number} rowLength
    * @param {number} skipRows
    * @param {number} skipPixels
    * @param {number} alignment
    */
   es3fTextureSpecificationTests.TexSubImage2DParamsCase = function(
       name, desc, internalFormat, width, height, subX, subY, subW, subH,
       rowLength, skipRows, skipPixels, alignment
   ) {
       es3fTextureSpecificationTests.Texture2DSpecCase.call(
           this, name, desc,
           gluTextureUtil.mapGLInternalFormat(internalFormat),
           width, height, 1
       );
       this.m_internalFormat = internalFormat;
       this.m_subX = subX;
       this.m_subY = subY;
       this.m_subW = subW;
       this.m_subH = subH;
       this.m_rowLength = rowLength;
       this.m_skipRows = skipRows;
       this.m_skipPixels = skipPixels;
       this.m_alignment = alignment;
   };

   es3fTextureSpecificationTests.TexSubImage2DParamsCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture2DSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexSubImage2DParamsCase.prototype.constructor =
       es3fTextureSpecificationTests.TexSubImage2DParamsCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexSubImage2DParamsCase.prototype.createTexture = function() {
       var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat);
       var pixelSize = this.m_texFormat.getPixelSize();
       var tex = null;
       /** @type {ArrayBuffer} */ var data;

       assertMsgOptions(
           this.m_numLevels == 1, 'Number of levels different to 1',
           false, true
       );

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D, tex);

       // First fill texture with gradient.
       data = new ArrayBuffer(
           deMath.deAlign32(this.m_width * pixelSize, 4) * this.m_height
       );
       var access = new tcuTexture.PixelBufferAccess({
               format: this.m_texFormat,
               width: this.m_width,
               height: this.m_height,
               rowPitch: deMath.deAlign32(this.m_width * pixelSize, 4),
               data: data
           });
       tcuTextureUtil.fillWithComponentGradients(access, this.m_texFormatInfo.valueMin, this.m_texFormatInfo.valueMax
       );
       this.m_context.texImage2D(
           gl.TEXTURE_2D, 0, this.m_internalFormat, this.m_width,
           this.m_height, 0, transferFmt.format, transferFmt.dataType,
           access.getDataPtr()
       );

       // Fill data with grid.
       var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_subW;
       var rowPitch = deMath.deAlign32(rowLength * pixelSize, this.m_alignment);
       var height = this.m_subH + this.m_skipRows;
       var cScale = deMath.subtract(
           this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin
       );
       var cBias = this.m_texFormatInfo.valueMin;
       var colorA = deMath.add(
           deMath.multiply(
               [1.0, 0.0, 0.0, 1.0], cScale
           ), cBias
       );
       var colorB = deMath.add(
           deMath.multiply(
               [0.0, 1.0, 0.0, 1.0], cScale
           ), cBias
       );

       data = new ArrayBuffer(rowPitch * height + this.m_skipPixels * pixelSize);
       tcuTextureUtil.fillWithGrid(
           new tcuTexture.PixelBufferAccess({
               format: this.m_texFormat,
               width: this.m_subW,
               height: this.m_subH,
               rowPitch: rowPitch,
               data: data,
               offset: this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize
               }) ,
           4, colorA, colorB
       );

       access = new tcuTexture.PixelBufferAccess({
               format: this.m_texFormat,
               width: this.m_subW,
               height: this.m_subH,
               rowPitch: rowPitch,
               data: data
           });
       this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment);
       this.m_context.texSubImage2D(
           gl.TEXTURE_2D, 0, this.m_subX, this.m_subY,
           this.m_subW, this.m_subH,
           transferFmt.format, transferFmt.dataType,
           access.getDataPtr()
       );
   };

   // Basic TexSubImage3D() with 3D texture usage
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture3DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @param {number} depth
    */
   es3fTextureSpecificationTests.BasicTexSubImage3DCase = function(
       name, desc, internalFormat, width, height, depth
   ) {
       es3fTextureSpecificationTests.Texture3DSpecCase.call(
           this, name, desc,
           gluTextureUtil.mapGLInternalFormat(internalFormat),
           width, height, depth, es3fTextureSpecificationTests.maxLevelCount(
               width, height, depth
           )
       );

       this.m_internalFormat = internalFormat;
   };

   es3fTextureSpecificationTests.BasicTexSubImage3DCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture3DSpecCase.prototype
       );

   es3fTextureSpecificationTests.BasicTexSubImage3DCase.prototype.constructor =
   es3fTextureSpecificationTests.BasicTexSubImage3DCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   BasicTexSubImage3DCase.prototype.createTexture = function() {
       var tex = null;
       var data = new tcuTexture.TextureLevel(
           this.m_texFormat, this.m_width, this.m_height
       );
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));
       var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat);

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_3D, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       // First specify full texture.
       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);
           var levelD = Math.max(1, this.m_depth >> ndx);

           var gMin = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );
           var gMax = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );

           data.setSize(levelW, levelH, levelD);
           tcuTextureUtil.fillWithComponentGradients(
               data.getAccess(), gMin, gMax
           );

           this.m_context.texImage3D(
               gl.TEXTURE_3D, ndx, this.m_internalFormat, levelW, levelH,
               levelD, 0, transferFmt.format, transferFmt.dataType,
               data.getAccess().getDataPtr()
           );
       }

       // Re-specify parts of each level.
       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);
           var levelD = Math.max(1, this.m_depth >> ndx);

           var w = rnd.getInt(1, levelW);
           var h = rnd.getInt(1, levelH);
           var d = rnd.getInt(1, levelD);
           var x = rnd.getInt(0, levelW - w);
           var y = rnd.getInt(0, levelH - h);
           var z = rnd.getInt(0, levelD - d);

           var colorA = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );
           var colorB = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );
           var cellSize = rnd.getInt(2, 16);

           data.setSize(w, h, d);
           tcuTextureUtil.fillWithGrid(
               data.getAccess(), cellSize, colorA, colorB
           );

           this.m_context.texSubImage3D(
               gl.TEXTURE_3D, ndx, x, y, z, w, h, d,
               transferFmt.format, transferFmt.dataType,
               data.getAccess().getDataPtr()
           );
       }
   };

   // TexSubImage2D() to texture initialized with empty data
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} format
    * @param {number} dataType
    * @param {number} width
    * @param {number} height
    */
   es3fTextureSpecificationTests.TexSubImage2DEmptyTexCase = function(
       name, desc, format, dataType, width, height
   ) {
       es3fTextureSpecificationTests.Texture2DSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLTransferFormat(
               format, dataType
           ), width, height, es3fTextureSpecificationTests.maxLevelCount(
               width, height
           )
       );

       this.m_format = format;
       this.m_internalFormat = format;
       this.m_dataType = dataType;
   };

   es3fTextureSpecificationTests.TexSubImage2DEmptyTexCase.prototype =
   Object.create(es3fTextureSpecificationTests.Texture2DSpecCase.prototype);

   es3fTextureSpecificationTests.
   TexSubImage2DEmptyTexCase.prototype.constructor =
       es3fTextureSpecificationTests.TexSubImage2DEmptyTexCase;

   /**
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    */
   es3fTextureSpecificationTests.newTexSubImage2DEmptyTexCaseInternal =
   function(name, desc, internalFormat, width, height) {
       // Sized internal format.
       var fmt = gluTextureUtil.getTransferFormat(
           gluTextureUtil.mapGLInternalFormat(internalFormat)
       );
       var testcase =
           new es3fTextureSpecificationTests.TexSubImage2DEmptyTexCase(
               name, desc, fmt.format, fmt.dataType, width, height
           );
       testcase.m_internalFormat = internalFormat;
       return testcase;
   };

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexSubImage2DEmptyTexCase.prototype.createTexture = function() {
       var tex = null;
       var data = new tcuTexture.TextureLevel(
           this.m_texFormat, this.m_width, this.m_height
       );
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       // First allocate storage for each level.
       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);

           this.m_context.texImage2D(
               gl.TEXTURE_2D, ndx, this.m_internalFormat, levelW, levelH, 0,
               this.m_format, this.m_dataType,
               null
           );
       }

       // Specify pixel data to all levels using glTexSubImage2D()
       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);
           var gMin = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );
           var gMax = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );

           data.setSize(levelW, levelH);
           tcuTextureUtil.fillWithComponentGradients(
               data.getAccess(), gMin, gMax
           );

           this.m_context.texSubImage2D(
               gl.TEXTURE_2D, ndx, 0, 0, levelW, levelH,
               this.m_format, this.m_dataType,
               data.getAccess().getDataPtr()
           );
       }
   };

   // TexSubImage2D() to empty cubemap texture
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} format
    * @param {number} dataType
    * @param {number} size
    */
   es3fTextureSpecificationTests.TexSubImageCubeEmptyTexCase = function(
       name, desc, format, dataType, size
   ) {
       // Unsized internal format.
       es3fTextureSpecificationTests.TextureCubeSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLTransferFormat(
               format, dataType
           ), size, deMath.logToFloor(size) + 1
       );

       this.m_internalFormat = format;
       this.m_format = format;
       this.m_dataType = dataType;
   };

   es3fTextureSpecificationTests.TexSubImageCubeEmptyTexCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.TextureCubeSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexSubImageCubeEmptyTexCase.prototype.constructor =
       es3fTextureSpecificationTests.TexSubImageCubeEmptyTexCase;

   /**
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} size
    * @return {es3fTextureSpecificationTests.TexSubImageCubeEmptyTexCase}
    */
   es3fTextureSpecificationTests.newTexSubImageCubeEmptyTexCaseInternal =
   function(name, desc, internalFormat, size) {
       // Sized internal format.
       var fmt = gluTextureUtil.getTransferFormat(
           gluTextureUtil.mapGLInternalFormat(internalFormat)
       );
       var testcase =
           new es3fTextureSpecificationTests.TexSubImageCubeEmptyTexCase(
               name, desc, fmt.format, fmt.dataType, size
           );
       testcase.m_internalFormat = internalFormat;
       return testcase;
   };

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexSubImageCubeEmptyTexCase.prototype.createTexture =
   function() {
       var tex = null;
       var data = new tcuTexture.TextureLevel(
           this.m_texFormat, this.m_size, this.m_size
       );
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       // Specify storage for each level.
       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelSize = Math.max(1, this.m_size >> ndx);

           for (var f in tcuTexture.CubeFace) {
               var face = tcuTexture.CubeFace[f];
               this.m_context.texImage2D(
                   es3fTextureSpecificationTests.s_cubeMapFaces[face],
                   ndx, this.m_internalFormat, levelSize, levelSize, 0,
                   this.m_format, this.m_dataType,
                   null
               );
           }
       }

       // Specify data using glTexSubImage2D()
       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelSize = Math.max(1, this.m_size >> ndx);

           data.setSize(levelSize, levelSize);

           for (var f in tcuTexture.CubeFace) {
               var face = tcuTexture.CubeFace[f];
               var gMin = es3fTextureSpecificationTests.randomVector(
                   rnd, this.m_texFormatInfo.valueMin,
                   this.m_texFormatInfo.valueMax, 4
               );
               var gMax = es3fTextureSpecificationTests.randomVector(
                   rnd, this.m_texFormatInfo.valueMin,
                   this.m_texFormatInfo.valueMax, 4
               );

               tcuTextureUtil.fillWithComponentGradients(
                   data.getAccess(), gMin, gMax
               );

               this.m_context.texSubImage2D(
                   es3fTextureSpecificationTests.s_cubeMapFaces[face],
                   ndx, 0, 0, levelSize, levelSize, this.m_format,
                   this.m_dataType, data.getAccess().getDataPtr()
               );
           }
       }
   };

   // TexSubImage2D() unpack alignment with 2D texture
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} format
    * @param {number} dataType
    * @param {number} width
    * @param {number} height
    * @param {number} subX
    * @param {number} subY
    * @param {number} subW
    * @param {number} subH
    * @param {number} alignment
    */
   es3fTextureSpecificationTests.TexSubImage2DAlignCase = function(
       name, desc, format, dataType, width, height, subX, subY, subW, subH,
       alignment
   ) {
       // Unsized internal format.
       es3fTextureSpecificationTests.Texture2DSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLTransferFormat(
               format, dataType
           ), width, height, 1
       );

       this.m_internalFormat = format;
       this.m_format = format;
       this.m_dataType = dataType;
       this.m_subX = subX;
       this.m_subY = subY;
       this.m_subW = subW;
       this.m_subH = subH;
       this.m_alignment = alignment;
   };

   es3fTextureSpecificationTests.TexSubImage2DAlignCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture2DSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexSubImage2DAlignCase.prototype.constructor =
       es3fTextureSpecificationTests.TexSubImage2DAlignCase;

   /**
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @param {number} subX
    * @param {number} subY
    * @param {number} subW
    * @param {number} subH
    * @param {number} alignment
    * @return {es3fTextureSpecificationTests.TexSubImage2DAlignCase}
    */
   es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal = function(
       name, desc, internalFormat, width, height, subX, subY, subW, subH,
       alignment
   ) {
       // Sized internal format.
       var fmt = gluTextureUtil.getTransferFormat(
           gluTextureUtil.mapGLInternalFormat(internalFormat)
       );
       var testcase = new es3fTextureSpecificationTests.TexSubImage2DAlignCase(
           name, desc, fmt.format, fmt.dataType,
           width, height, subX, subY, subW, subH, alignment
       );
       testcase.m_internalFormat = internalFormat;
       return testcase;
   };

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexSubImage2DAlignCase.prototype.createTexture = function() {
       var tex = null;
       /** @type {ArrayBuffer} */ var data;

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D, tex);

       // Specify base level.
       data = new ArrayBuffer(this.m_texFormat.getPixelSize() *
           this.m_width * this.m_height
       );
       var access = new tcuTexture.PixelBufferAccess({
               format: this.m_texFormat,
               width: this.m_width,
               height: this.m_height,
               data: data
           });
       tcuTextureUtil.fillWithComponentGradients(access, [0, 0, 0, 0], [1, 1, 1, 1]);

       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
       this.m_context.texImage2D(gl.TEXTURE_2D, 0, this.m_internalFormat,
           this.m_width, this.m_height, 0, this.m_format, this.m_dataType,
           access.getDataPtr()
       );

       // Re-specify subrectangle.
       var rowPitch = deMath.deAlign32(
           this.m_texFormat.getPixelSize() * this.m_subW, this.m_alignment
       );
       data = new ArrayBuffer(rowPitch * this.m_subH);
       access = new tcuTexture.PixelBufferAccess({
               format: this.m_texFormat,
               width: this.m_subW,
               height: this.m_subH,
               rowPitch: rowPitch,
               data: data
           });
       tcuTextureUtil.fillWithGrid(access, 4, [1, 0, 0, 1], [0, 1, 0, 1]
       );

       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment);
       this.m_context.texSubImage2D(
           gl.TEXTURE_2D, 0, this.m_subX, this.m_subY, this.m_subW,
           this.m_subH, this.m_format, this.m_dataType, access.getDataPtr()
       );
   };

   // TexSubImage2D() unpack alignment with cubemap texture
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} format
    * @param {number} dataType
    * @param {number} size
    * @param {number} subX
    * @param {number} subY
    * @param {number} subW
    * @param {number} subH
    * @param {number} alignment
    */
   es3fTextureSpecificationTests.TexSubImageCubeAlignCase = function(
       name, desc, format, dataType, size, subX, subY, subW, subH, alignment
   ) {
       // Unsized internal format.
       es3fTextureSpecificationTests.TextureCubeSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLTransferFormat(
               format, dataType
           ), size, 1
       );

       this.m_internalFormat = format;
       this.m_format = format;
       this.m_dataType = dataType;
       this.m_subX = subX;
       this.m_subY = subY;
       this.m_subW = subW;
       this.m_subH = subH;
       this.m_alignment = alignment;
   };

   es3fTextureSpecificationTests.TexSubImageCubeAlignCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.TextureCubeSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexSubImageCubeAlignCase.prototype.constructor =
       es3fTextureSpecificationTests.TexSubImageCubeAlignCase;

   /**
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} size
    * @param {number} subX
    * @param {number} subY
    * @param {number} subW
    * @param {number} subH
    * @param {number} alignment
    * @return {es3fTextureSpecificationTests.TexSubImageCubeAlignCase}
    */
   es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal =
   function(
       name, desc, internalFormat, size,
       subX, subY, subW, subH, alignment
   ) {
       // Sized internal format.
       var fmt = gluTextureUtil.getTransferFormat(
           gluTextureUtil.mapGLInternalFormat(internalFormat)
       );
       var testcase =
           new es3fTextureSpecificationTests.TexSubImageCubeAlignCase(
               name, desc, fmt.format, fmt.dataType, size,
               subX, subY, subW, subH, alignment
           );
       testcase.m_internalFormat = internalFormat;
       return testcase;
   };

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexSubImageCubeAlignCase.prototype.createTexture =
   function() {
       var tex = null;
       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex);

       var data = new ArrayBuffer(this.m_texFormat.getPixelSize() * this.m_size * this.m_size);
       var access = new tcuTexture.PixelBufferAccess({
               format: this.m_texFormat,
               width: this.m_size,
               height: this.m_size,
               data: data
           });
       tcuTextureUtil.fillWithComponentGradients(access, [0, 0, 0, 0], [1, 1, 1, 1]
       );

       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
       for (var f in tcuTexture.CubeFace) {
           var face = tcuTexture.CubeFace[f];
           this.m_context.texImage2D(
               es3fTextureSpecificationTests.s_cubeMapFaces[face],
               0, this.m_internalFormat, this.m_size, this.m_size, 0,
               this.m_format, this.m_dataType,
               access.getDataPtr()
           );
       }

       // Re-specify subrectangle.
       var rowPitch = deMath.deAlign32(
           this.m_texFormat.getPixelSize() * this.m_subW, this.m_alignment
       );
       data = new ArrayBuffer(rowPitch * this.m_subH);
       access = new tcuTexture.PixelBufferAccess({
               format: this.m_texFormat,
               width: this.m_subW,
               height: this.m_subH,
               rowPitch: rowPitch,
               data: data
       });
       tcuTextureUtil.fillWithGrid(access, 4, [1, 0, 0, 1], [0, 1, 0, 1]
       );
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment);
       for (var f in tcuTexture.CubeFace) {
           var face = tcuTexture.CubeFace[f];
           this.m_context.texSubImage2D(
               es3fTextureSpecificationTests.s_cubeMapFaces[face],
               0, this.m_subX, this.m_subY, this.m_subW, this.m_subH,
               this.m_format, this.m_dataType, access.getDataPtr()
           );
       }
   };

   // TexSubImage3D() unpack parameters case.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture3DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @param {number} depth
    * @param {number} subX ,
    * @param {number} subY ,
    * @param {number} subZ ,
    * @param {number} subW ,
    * @param {number} subH ,
    * @param {number} subD ,
    * @param {number} imageHeight ,
    * @param {number} rowLength ,
    * @param {number} skipImages ,
    * @param {number} skipRows ,
    * @param {number} skipPixels ,
    * @param {number} alignment
    */
   es3fTextureSpecificationTests.TexSubImage3DParamsCase = function(
       name, desc, internalFormat, width, height, depth,
       subX, subY, subZ, subW, subH, subD,
       imageHeight, rowLength, skipImages, skipRows, skipPixels, alignment
   ) {
       es3fTextureSpecificationTests.Texture3DSpecCase.call(
           this, name, desc,
           gluTextureUtil.mapGLInternalFormat(internalFormat),
           width, height, depth, 1
       );

       this.m_internalFormat = internalFormat;
       this.m_subX = subX;
       this.m_subY = subY;
       this.m_subZ = subZ;
       this.m_subW = subW;
       this.m_subH = subH;
       this.m_subD = subD;
       this.m_imageHeight = imageHeight;
       this.m_rowLength = rowLength;
       this.m_skipImages = skipImages;
       this.m_skipRows = skipRows;
       this.m_skipPixels = skipPixels;
       this.m_alignment = alignment;
   };

   es3fTextureSpecificationTests.TexSubImage3DParamsCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture3DSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexSubImage3DParamsCase.prototype.constructor =
       es3fTextureSpecificationTests.TexSubImage3DParamsCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexSubImage3DParamsCase.prototype.createTexture = function() {
       var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat);
       var pixelSize = this.m_texFormat.getPixelSize();
       var tex = null;
       var rowPitch = deMath.deAlign32(pixelSize * this.m_width, 4);
       var slicePitch = rowPitch * this.m_height;
       assertMsgOptions(
           this.m_numLevels == 1, 'Numbel of levels different than 1',
           false, true
       );

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_3D, tex);

       // Fill with gradient.

       var data = new ArrayBuffer(slicePitch * this.m_depth);
       var access = new tcuTexture.PixelBufferAccess({
                           format: this.m_texFormat,
                           width: this.m_width,
                           height: this.m_height,
                           depth: this.m_depth,
                           rowPitch: rowPitch,
                           slicePitch: slicePitch,
                           data: data
                       });
       tcuTextureUtil.fillWithComponentGradients(access, this.m_texFormatInfo.valueMin, this.m_texFormatInfo.valueMax);

       this.m_context.texImage3D(
           gl.TEXTURE_3D, 0, this.m_internalFormat, this.m_width,
           this.m_height, this.m_depth, 0, transferFmt.format,
           transferFmt.dataType, access.getDataPtr()
       );

       // Fill data with grid.
       var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_subW;
       rowPitch = deMath.deAlign32(rowLength * pixelSize, this.m_alignment);
       var imageHeight = this.m_imageHeight > 0 ? this.m_imageHeight : this.m_subH;
       slicePitch = imageHeight * rowPitch;
       var cScale = deMath.subtract(this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin);
       var cBias = this.m_texFormatInfo.valueMin;
       var colorA = deMath.add(
           deMath.multiply([1.0, 0.0, 0.0, 1.0], cScale), cBias
       );
       var colorB = deMath.add(
           deMath.multiply([0.0, 1.0, 0.0, 1.0], cScale), cBias
       );

       data = new ArrayBuffer(slicePitch * (this.m_depth + this.m_skipImages) +
                              this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize);
       var accessWithOffset = new tcuTexture.PixelBufferAccess({
               format: this.m_texFormat,
               width: this.m_subW,
               height: this.m_subH,
               depth: this.m_subD,
               rowPitch: rowPitch,
               slicePitch: slicePitch,
               data: data,
               offset: this.m_skipImages * slicePitch + this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize
           });
       access = new tcuTexture.PixelBufferAccess({
               format: this.m_texFormat,
               width: this.m_subW,
               height: this.m_subH,
               depth: this.m_subD,
               rowPitch: rowPitch,
               slicePitch: slicePitch,
               data: data
           });
       tcuTextureUtil.fillWithGrid(accessWithOffset, 4, colorA, colorB);

       this.m_context.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, this.m_imageHeight);
       this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_IMAGES, this.m_skipImages);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment);
       this.m_context.texSubImage3D(
           gl.TEXTURE_3D, 0, this.m_subX, this.m_subY, this.m_subZ,
           this.m_subW, this.m_subH, this.m_subD,
           transferFmt.format, transferFmt.dataType, access.getDataPtr()
       );
   };

   // Basic CopyTexImage2D() with 2D texture usage
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    */
   es3fTextureSpecificationTests.BasicCopyTexImage2DCase = function(
       name, desc, internalFormat, width, height
   ) {
       es3fTextureSpecificationTests.Texture2DSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLTransferFormat(
               internalFormat, gl.UNSIGNED_BYTE
           ), width, height, es3fTextureSpecificationTests.maxLevelCount(
               width, height
           )
       );

       this.m_internalFormat = internalFormat;
   };

   es3fTextureSpecificationTests.BasicCopyTexImage2DCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture2DSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   BasicCopyTexImage2DCase.prototype.constructor =
       es3fTextureSpecificationTests.BasicCopyTexImage2DCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   BasicCopyTexImage2DCase.prototype.createTexture = function() {
       var pixelFormat = tcuPixelFormat.PixelFormatFromContext(gl);
       var targetHasRGB = pixelFormat.redBits > 0 &&
           pixelFormat.greenBits > 0 &&
           pixelFormat.blueBits > 0;
       var targetHasAlpha = pixelFormat.alphaBits > 0;
       var fmt = es3fTextureSpecificationTests.mapGLUnsizedInternalFormat(
               this.m_internalFormat
       );
       var texHasRGB = fmt.order != tcuTexture.ChannelOrder.A;
       var texHasAlpha = fmt.order == tcuTexture.ChannelOrder.RGBA ||
           fmt.order == tcuTexture.ChannelOrder.LA ||
           fmt.order == tcuTexture.ChannelOrder.A;
       var tex = null;
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));
       /** @type {es3fFboTestUtil.GradientShader} */
       var shader = new es3fFboTestUtil.GradientShader(
           gluShaderUtil.DataType.FLOAT_VEC4
       );
       var shaderID = this.m_context.createProgram(shader);

       if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha))
           throw new Error(
               'Copying from current framebuffer is not supported'
           );

       // Fill render target with gradient.
       shader.setGradient(
           this.m_context, shaderID, [0, 0, 0, 0], [1, 1, 1, 1]
       );
       rrUtil.drawQuad(
           this.m_context, shaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
       );

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D, tex);

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);
           var x = rnd.getInt(0, this.m_width - levelW);
           var y = rnd.getInt(0, this.m_height - levelH);

           this.m_context.copyTexImage2D(
               gl.TEXTURE_2D, ndx, this.m_internalFormat, x, y,
               levelW, levelH, 0
           );
       }
   };

   // Basic CopyTexImage2D() with cubemap usage
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} size
    */
   es3fTextureSpecificationTests.BasicCopyTexImageCubeCase = function(
       name, desc, internalFormat, size
   ) {
       es3fTextureSpecificationTests.TextureCubeSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLTransferFormat(
               internalFormat, gl.UNSIGNED_BYTE
           ), size, deMath.logToFloor(size) + 1
       );

       this.m_internalFormat = internalFormat;
   };

   es3fTextureSpecificationTests.BasicCopyTexImageCubeCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.TextureCubeSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   BasicCopyTexImageCubeCase.prototype.constructor =
       es3fTextureSpecificationTests.BasicCopyTexImageCubeCase;

   es3fTextureSpecificationTests.
   BasicCopyTexImageCubeCase.prototype.createTexture = function() {
       var pixelFormat = tcuPixelFormat.PixelFormatFromContext(gl);
       var targetHasRGB = pixelFormat.redBits > 0 &&
           pixelFormat.greenBits > 0 &&
           pixelFormat.blueBits > 0;
       var targetHasAlpha = pixelFormat.alphaBits > 0;
       var fmt = es3fTextureSpecificationTests.mapGLUnsizedInternalFormat(
               this.m_internalFormat
       );
       var texHasRGB = fmt.order != tcuTexture.ChannelOrder.A;
       var texHasAlpha = fmt.order == tcuTexture.ChannelOrder.RGBA ||
           fmt.order == tcuTexture.ChannelOrder.LA ||
           fmt.order == tcuTexture.ChannelOrder.A;
       var tex = null;
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));
       /** @type {es3fFboTestUtil.GradientShader} */
       var shader = new es3fFboTestUtil.GradientShader(
           gluShaderUtil.DataType.FLOAT_VEC4
       );
       var shaderID = this.m_context.createProgram(shader);

       if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha))
           throw new Error(
               'Copying from current framebuffer is not supported'
           );

       // Fill render target with gradient.
       shader.setGradient(
           this.m_context, shaderID, [0, 0, 0, 0], [1, 1, 1, 1]
       );
       rrUtil.drawQuad(
           this.m_context, shaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
       );

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex);

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelSize = Math.max(1, this.m_size >> ndx);

           for (var f in tcuTexture.CubeFace) {
               var face = tcuTexture.CubeFace[f];
               var x = rnd.getInt(0, this.m_size - levelSize);
               var y = rnd.getInt(0, this.m_size - levelSize);

               this.m_context.copyTexImage2D(
                   es3fTextureSpecificationTests.s_cubeMapFaces[face], ndx,
                   this.m_internalFormat, x, y, levelSize, levelSize, 0
               );
           }
       }
   };

   // Basic CopyTexSubImage2D() with 2D texture usage
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} format
    * @param {number} dataType
    * @param {number} width
    * @param {number} height
    */
   es3fTextureSpecificationTests.BasicCopyTexSubImage2DCase = function(
       name, desc, format, dataType, width, height
   ) {
       es3fTextureSpecificationTests.Texture2DSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLTransferFormat(
               format, dataType
           ), width, height, es3fTextureSpecificationTests.maxLevelCount(
               width, height
           )
       );

       this.m_format = format;
       this.m_dataType = dataType;
   };

   es3fTextureSpecificationTests.BasicCopyTexSubImage2DCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture2DSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   BasicCopyTexSubImage2DCase.prototype.constructor =
       es3fTextureSpecificationTests.BasicCopyTexSubImage2DCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   BasicCopyTexSubImage2DCase.prototype.createTexture = function() {
       var pixelFormat = tcuPixelFormat.PixelFormatFromContext(gl);
       var targetHasRGB = pixelFormat.redBits > 0 &&
           pixelFormat.greenBits > 0 &&
           pixelFormat.blueBits > 0;
       var targetHasAlpha = pixelFormat.alphaBits > 0;
       var fmt = gluTextureUtil.mapGLTransferFormat(
               this.m_format, this.m_dataType
       );
       var texHasRGB = fmt.order != tcuTexture.ChannelOrder.A;
       var texHasAlpha = fmt.order == tcuTexture.ChannelOrder.RGBA ||
           fmt.order == tcuTexture.ChannelOrder.LA ||
           fmt.order == tcuTexture.ChannelOrder.A;
       var tex = null;
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));
       /** @type {es3fFboTestUtil.GradientShader} */
       var shader = new es3fFboTestUtil.GradientShader(
           gluShaderUtil.DataType.FLOAT_VEC4
       );
       var shaderID = this.m_context.createProgram(shader);

       if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha))
           throw new Error(
               'Copying from current framebuffer is not supported'
           );

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       // First specify full texture.
       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);

           var colorA = es3fTextureSpecificationTests.randomVector(
               rnd, [0, 0, 0, 0], [1, 1, 1, 1], 4
           );
           var colorB = es3fTextureSpecificationTests.randomVector(
               rnd, [0, 0, 0, 0], [1, 1, 1, 1], 4
           );
           var cellSize = rnd.getInt(2, 16);

           var data = new tcuTexture.TextureLevel(fmt, levelW, levelH);
           tcuTextureUtil.fillWithGrid(
               data.getAccess(), cellSize, colorA, colorB
           );

           this.m_context.texImage2D(
               gl.TEXTURE_2D, ndx, this.m_format, levelW, levelH, 0, this.m_format, this.m_dataType, data.getAccess().getDataPtr()
           );
       }

       // Fill render target with gradient.
       shader.setGradient(
           this.m_context, shaderID, [0, 0, 0, 0], [1, 1, 1, 1]
       );
       rrUtil.drawQuad(
           this.m_context, shaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
       );

       // Re-specify parts of each level.
       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);

           var w = rnd.getInt(1, levelW);
           var h = rnd.getInt(1, levelH);
           var xo = rnd.getInt(0, levelW - w);
           var yo = rnd.getInt(0, levelH - h);

           var x = rnd.getInt(0, this.m_width - w);
           var y = rnd.getInt(0, this.m_height - h);

           this.m_context.copyTexSubImage2D(
               gl.TEXTURE_2D, ndx, xo, yo, x, y, w, h
           );
       }
   };

   // Basic CopyTexSubImage2D() with cubemap usage
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} format
    * @param {number} dataType
    * @param {number} size
    */
   es3fTextureSpecificationTests.BasicCopyTexSubImageCubeCase = function(
       name, desc, format, dataType, size
   ) {
       es3fTextureSpecificationTests.TextureCubeSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLTransferFormat(
               format, dataType
           ), size, deMath.logToFloor(size) + 1
       );

       this.m_format = format;
       this.m_dataType = dataType;
   };

   es3fTextureSpecificationTests.BasicCopyTexSubImageCubeCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.TextureCubeSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   BasicCopyTexSubImageCubeCase.prototype.constructor =
       es3fTextureSpecificationTests.BasicCopyTexSubImageCubeCase;

   es3fTextureSpecificationTests.
   BasicCopyTexSubImageCubeCase.prototype.createTexture = function() {
       var pixelFormat = tcuPixelFormat.PixelFormatFromContext(gl);
       var targetHasRGB = pixelFormat.redBits > 0 &&
           pixelFormat.greenBits > 0 &&
           pixelFormat.blueBits > 0;
       var targetHasAlpha = pixelFormat.alphaBits > 0;
       var fmt = gluTextureUtil.mapGLTransferFormat(this.m_format, this.m_dataType);
       var texHasRGB = fmt.order != tcuTexture.ChannelOrder.A;
       var texHasAlpha = fmt.order == tcuTexture.ChannelOrder.RGBA ||
           fmt.order == tcuTexture.ChannelOrder.LA ||
           fmt.order == tcuTexture.ChannelOrder.A;
       var tex = null;
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));
       /** @type {es3fFboTestUtil.GradientShader} */
       var shader = new es3fFboTestUtil.GradientShader(
           gluShaderUtil.DataType.FLOAT_VEC4
       );
       var shaderID = this.m_context.createProgram(shader);

       if ((texHasRGB && !targetHasRGB) || (texHasAlpha && !targetHasAlpha))
           throw new Error(
               'Copying from current framebuffer is not supported'
           );

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       var data = new tcuTexture.TextureLevel(fmt);

       // First specify full texture.
       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelSize = Math.max(1, this.m_size >> ndx);

           data.setSize(levelSize, levelSize);

           for (var f in tcuTexture.CubeFace) {
               var face = tcuTexture.CubeFace[f];
               var colorA = es3fTextureSpecificationTests.randomVector(
                   rnd, [0, 0, 0, 0], [1, 1, 1, 1], 4
               );
               var colorB = es3fTextureSpecificationTests.randomVector(
                   rnd, [0, 0, 0, 0], [1, 1, 1, 1], 4
               );
               var cellSize = rnd.getInt(2, 16);

               tcuTextureUtil.fillWithGrid(
                   data.getAccess(), cellSize, colorA, colorB
               );

               this.m_context.texImage2D(
                   es3fTextureSpecificationTests.s_cubeMapFaces[face],
                   ndx, this.m_format, levelSize, levelSize, 0, this.m_format,
                   this.m_dataType, data.getAccess().getDataPtr()
               );
           }
       }

       // Fill render target with gradient.
       shader.setGradient(
           this.m_context, shaderID, [0, 0, 0, 0], [1, 1, 1, 1]
       );
       rrUtil.drawQuad(
           this.m_context, shaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
       );

       // Re-specify parts of each face and level.
       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelSize = Math.max(1, this.m_size >> ndx);

           for (var f in es3fTextureSpecificationTests.s_cubeMapFaces) {
               var w = rnd.getInt(1, levelSize);
               var h = rnd.getInt(1, levelSize);
               var xo = rnd.getInt(0, levelSize - w);
               var yo = rnd.getInt(0, levelSize - h);

               var x = rnd.getInt(0, this.m_size - w);
               var y = rnd.getInt(0, this.m_size - h);

               this.m_context.copyTexSubImage2D(
                   es3fTextureSpecificationTests.s_cubeMapFaces[f],
                   ndx, xo, yo, x, y, w, h
               );
           }
       }
   };

   // Basic glTexStorage2D() with 2D texture usage
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @param {number} numLevels
    */
   es3fTextureSpecificationTests.BasicTexStorage2DCase = function(
       name, desc, internalFormat, width, height, numLevels
   ) {
       es3fTextureSpecificationTests.Texture2DSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), width, height, numLevels
       );

       this.m_internalFormat = internalFormat;
   };

   es3fTextureSpecificationTests.BasicTexStorage2DCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture2DSpecCase.prototype
       );

   es3fTextureSpecificationTests.BasicTexStorage2DCase.prototype.constructor =
       es3fTextureSpecificationTests.BasicTexStorage2DCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   BasicTexStorage2DCase.prototype.createTexture = function() {
       var fmt = gluTextureUtil.mapGLInternalFormat(this.m_internalFormat);
       var transferFmt = gluTextureUtil.getTransferFormat(fmt);
       var tex = null;
       var levelData = new tcuTexture.TextureLevel(
           fmt, this.m_width, this.m_height
       );
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D, tex);
       this.m_context.texStorage2D(
           gl.TEXTURE_2D, this.m_numLevels, this.m_internalFormat,
           this.m_width, this.m_height
       );

       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);
           var gMin = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );
           var gMax = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );

           levelData.setSize(levelW, levelH);
           tcuTextureUtil.fillWithComponentGradients(
               levelData.getAccess(), gMin, gMax
           );

           this.m_context.texSubImage2D(
               gl.TEXTURE_2D, ndx, 0, 0, levelW, levelH,
               transferFmt.format, transferFmt.dataType,
               levelData.getAccess().getDataPtr()
           );
       }
   };

   // Basic glTexStorage2D() with cubemap usage
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} size
    * @param {number} numLevels
    */
   es3fTextureSpecificationTests.BasicTexStorageCubeCase = function(
       name, desc, internalFormat, size, numLevels
   ) {
       es3fTextureSpecificationTests.TextureCubeSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), size, numLevels
       );

       this.m_internalFormat = internalFormat;
   };

   es3fTextureSpecificationTests.BasicTexStorageCubeCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.TextureCubeSpecCase.prototype
       );

   es3fTextureSpecificationTests.BasicTexStorageCubeCase.prototype.constructor =
       es3fTextureSpecificationTests.BasicTexStorageCubeCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.BasicTexStorageCubeCase.prototype.createTexture = function() {
       var fmt = gluTextureUtil.mapGLInternalFormat(this.m_internalFormat);
       var transferFmt = gluTextureUtil.getTransferFormat(fmt);
       var tex = null;
       var levelData = new tcuTexture.TextureLevel(
           fmt, this.m_size, this.m_size
       );
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex);
       this.m_context.texStorage2D(
           gl.TEXTURE_CUBE_MAP, this.m_numLevels, this.m_internalFormat,
           this.m_size, this.m_size
       );

       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelSize = Math.max(1, this.m_size >> ndx);

           levelData.setSize(levelSize, levelSize);

           for (var f in tcuTexture.CubeFace) {
               var face = tcuTexture.CubeFace[f];
               var gMin = es3fTextureSpecificationTests.randomVector(
                   rnd, this.m_texFormatInfo.valueMin,
                   this.m_texFormatInfo.valueMax, 4
               );
               var gMax = es3fTextureSpecificationTests.randomVector(
                   rnd, this.m_texFormatInfo.valueMin,
                   this.m_texFormatInfo.valueMax, 4
               );

               tcuTextureUtil.fillWithComponentGradients(
                   levelData.getAccess(), gMin, gMax
               );

               this.m_context.texSubImage2D(
                   es3fTextureSpecificationTests.s_cubeMapFaces[face],
                   ndx, 0, 0, levelSize, levelSize,
                   transferFmt.format, transferFmt.dataType,
                   levelData.getAccess().getDataPtr()
               );
           }
       }
   };

   // Basic glTexStorage3D() with 2D array texture usage
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DArraySpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @param {number} numLayers
    * @param {number} numLevels
    */
   es3fTextureSpecificationTests.BasicTexStorage2DArrayCase = function(
       name, desc, internalFormat, width, height, numLayers, numLevels
   ) {
       es3fTextureSpecificationTests.Texture2DArraySpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), width, height, numLayers, numLevels
       );
       this.m_internalFormat = internalFormat;
   };

   es3fTextureSpecificationTests.BasicTexStorage2DArrayCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype
       );

   es3fTextureSpecificationTests.
   BasicTexStorage2DArrayCase.prototype.constructor =
       es3fTextureSpecificationTests.BasicTexStorage2DArrayCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.BasicTexStorage2DArrayCase.prototype.createTexture = function() {
       var tex = null;
       var levelData = new tcuTexture.TextureLevel(
           this.m_texFormat, this.m_width, this.m_height
       );
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));
       var transferFmt = gluTextureUtil.getTransferFormat(
           this.m_texFormat
       );

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D_ARRAY, tex);
       this.m_context.texStorage3D(
           gl.TEXTURE_2D_ARRAY, this.m_numLevels, this.m_internalFormat,
           this.m_width, this.m_height, this.m_numLayers
       );

       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);
           var gMin = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );
           var gMax = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );

           levelData.setSize(levelW, levelH, this.m_numLayers);
           tcuTextureUtil.fillWithComponentGradients(
               levelData.getAccess(), gMin, gMax
           );

           this.m_context.texSubImage3D(
               gl.TEXTURE_2D_ARRAY, ndx, 0, 0, 0, levelW, levelH,
               this.m_numLayers, transferFmt.format, transferFmt.dataType,
               levelData.getAccess().getDataPtr()
           );
       }
   };

   // Basic TexStorage3D() with 3D texture usage
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture3DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @param {number} depth
    * @param {number} numLevels
    */
   es3fTextureSpecificationTests.BasicTexStorage3DCase = function(
       name, desc, internalFormat, width, height, depth, numLevels
   ) {
       es3fTextureSpecificationTests.Texture3DSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), width, height, depth, numLevels
       );

       this.m_internalFormat = internalFormat;
   };

   es3fTextureSpecificationTests.BasicTexStorage3DCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture3DSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   BasicTexStorage3DCase.prototype.constructor =
       es3fTextureSpecificationTests.BasicTexStorage3DCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   BasicTexStorage3DCase.prototype.createTexture = function() {
       var tex = null;
       var levelData = new tcuTexture.TextureLevel(
           this.m_texFormat, this.m_width, this.m_height
       );
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));
       var transferFmt = gluTextureUtil.getTransferFormat(
           this.m_texFormat
       );

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_3D, tex);
       this.m_context.texStorage3D(
           gl.TEXTURE_3D, this.m_numLevels, this.m_internalFormat,
           this.m_width, this.m_height, this.m_depth
       );

       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);
           var levelD = Math.max(1, this.m_depth >> ndx);
           var gMin = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );
           var gMax = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );

           levelData.setSize(levelW, levelH, levelD);
           tcuTextureUtil.fillWithComponentGradients(
               levelData.getAccess(), gMin, gMax
           );

           this.m_context.texSubImage3D(
               gl.TEXTURE_3D, ndx, 0, 0, 0, levelW, levelH,
               levelD, transferFmt.format, transferFmt.dataType,
               levelData.getAccess().getDataPtr()
           );
       }
   };

   // Pixel buffer object cases.

   // TexImage2D() from pixel buffer object.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @param {number} rowLength
    * @param {number} skipRows
    * @param {number} skipPixels
    * @param {number} alignment
    * @param {number} offset
    */
   es3fTextureSpecificationTests.TexImage2DBufferCase = function(
       name, desc, internalFormat, width, height, rowLength,
       skipRows, skipPixels, alignment, offset
   ) {
       es3fTextureSpecificationTests.Texture2DSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), width, height, 1
       );

       this.m_internalFormat = internalFormat;
       this.m_rowLength = rowLength;
       this.m_skipRows = skipRows;
       this.m_skipPixels = skipPixels;
       this.m_alignment = alignment;
       this.m_offset = offset;
   };

   es3fTextureSpecificationTests.TexImage2DBufferCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture2DSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexImage2DBufferCase.prototype.constructor =
       es3fTextureSpecificationTests.TexImage2DBufferCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.TexImage2DBufferCase.prototype.createTexture =
   function() {
       var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat);
       var pixelSize = this.m_texFormat.getPixelSize();
       var rowLength = this.m_rowLength > 0 ?
           this.m_rowLength :
           this.m_width + this.m_skipPixels;
       var rowPitch = deMath.deAlign32(
           rowLength * pixelSize, this.m_alignment
       );
       var height = this.m_height + this.m_skipRows;
       var buf = null;
       var tex = null;
       var data = new ArrayBuffer(rowPitch * height + this.m_skipPixels * pixelSize + this.m_offset);

       assertMsgOptions(
           this.m_numLevels == 1, 'Number of levels different than 1',
           false, true
       );

       // Fill data with grid.
       var cScale = deMath.subtract(this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin);
       var cBias = this.m_texFormatInfo.valueMin;
       var colorA = deMath.add(
           deMath.multiply([1.0, 0.0, 0.0, 1.0], cScale), cBias
       );
       var colorB = deMath.add(
           deMath.multiply([0.0, 1.0, 0.0, 1.0], cScale), cBias
       );

       var access = new tcuTexture.PixelBufferAccess({
                   format: this.m_texFormat,
                   width: this.m_width,
                   height: this.m_height,
                   rowPitch: rowPitch,
                   data: data,
                   offset: this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize + this.m_offset
                   });
       tcuTextureUtil.fillWithGrid(access, 4, colorA, colorB);

       // Create buffer and upload.
       buf = this.m_context.createBuffer();
       this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf);
       this.m_context.bufferData(gl.PIXEL_UNPACK_BUFFER, data, gl.STATIC_DRAW
       );

       this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment);

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D, tex);
       this.m_context.texImage2D(gl.TEXTURE_2D, 0, this.m_internalFormat,
           this.m_width, this.m_height, 0, transferFmt.format, transferFmt.dataType,
           this.m_offset
       );
   };

   // TexImage2D() cubemap from pixel buffer object case
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} size
    * @param {number} rowLength
    * @param {number} skipRows
    * @param {number} skipPixels
    * @param {number} alignment
    * @param {number} offset
    */
   es3fTextureSpecificationTests.TexImageCubeBufferCase = function(
       name, desc, internalFormat, size, rowLength, skipRows, skipPixels,
       alignment, offset
   ) {
       es3fTextureSpecificationTests.TextureCubeSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), size, 1
       );

       this.m_internalFormat = internalFormat;
       this.m_rowLength = rowLength;
       this.m_skipRows = skipRows;
       this.m_skipPixels = skipPixels;
       this.m_alignment = alignment;
       this.m_offset = offset;
   };

   es3fTextureSpecificationTests.TexImageCubeBufferCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.TextureCubeSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexImageCubeBufferCase.prototype.constructor =
       es3fTextureSpecificationTests.TexImageCubeBufferCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexImageCubeBufferCase.prototype.createTexture = function() {
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));
       var tex = null;
       var fmt = gluTextureUtil.getTransferFormat(this.m_texFormat);
       var pixelSize = this.m_texFormat.getPixelSize();
       var rowLength = this.m_rowLength > 0 ?
           this.m_rowLength : this.m_size + this.m_skipPixels;
       var rowPitch = deMath.deAlign32(
           rowLength * pixelSize, this.m_alignment
       );
       var height = this.m_size + this.m_skipRows;

       var data = new ArrayBuffer(rowPitch * height + this.m_skipPixels * pixelSize + this.m_offset);
       var access = new tcuTexture.PixelBufferAccess({
                           format: this.m_texFormat,
                           width: this.m_size,
                           height: this.m_size,
                           rowPitch: rowPitch,
                           data: data,
                           offset: this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize + this.m_offset
                       });

       assertMsgOptions(
           this.m_numLevels == 1, 'Number of levels is different than 1',
           false, true
       );

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       for (var f in tcuTexture.CubeFace) {
           var face = tcuTexture.CubeFace[f];
           var buf = null;

           var gMin = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );
           var gMax = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );

           tcuTextureUtil.fillWithComponentGradients(access, gMin, gMax);

           // Create buffer and upload.
           buf = this.m_context.createBuffer();
           this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf);
           this.m_context.bufferData(gl.PIXEL_UNPACK_BUFFER, data, gl.STATIC_DRAW);

           this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength);
           this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows);
           this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels);
           this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment);

           this.m_context.texImage2D(
               es3fTextureSpecificationTests.s_cubeMapFaces[face], 0,
               this.m_internalFormat, this.m_size, this.m_size, 0, fmt.format,
               fmt.dataType, this.m_offset);
       }
   };

   // TexImage3D() 2D array from pixel buffer object.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DArraySpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @param {number} depth
    * @param {number} imageHeight
    * @param {number} rowLength
    * @param {number} skipImages
    * @param {number} skipRows
    * @param {number} skipPixels
    * @param {number} alignment
    * @param {number} offset
    */
   es3fTextureSpecificationTests.TexImage2DArrayBufferCase = function(
       name, desc, internalFormat, width, height, depth, imageHeight,
       rowLength, skipImages, skipRows, skipPixels, alignment, offset
   ) {
       es3fTextureSpecificationTests.Texture2DArraySpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), width, height, depth, 1
       );

       this.m_internalFormat = internalFormat;
       this.m_imageHeight = imageHeight;
       this.m_rowLength = rowLength;
       this.m_skipImages = skipImages;
       this.m_skipRows = skipRows;
       this.m_skipPixels = skipPixels;
       this.m_alignment = alignment;
       this.m_offset = offset;
   };

   es3fTextureSpecificationTests.TexImage2DArrayBufferCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexImage2DArrayBufferCase.prototype.constructor =
       es3fTextureSpecificationTests.TexImage2DArrayBufferCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexImage2DArrayBufferCase.prototype.createTexture = function() {
       var transferFmt = gluTextureUtil.getTransferFormat(
           this.m_texFormat
       );
       var pixelSize = this.m_texFormat.getPixelSize();
       var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_width;
       var rowPitch = deMath.deAlign32(
           rowLength * pixelSize, this.m_alignment
       );
       var imageHeight = this.m_imageHeight > 0 ?
           this.m_imageHeight : this.m_height;
       var slicePitch = imageHeight * rowPitch;
       var tex = null;
       var buf = null;
       var data = new ArrayBuffer(
           slicePitch * (this.m_numLayers + this.m_skipImages) +
           this.m_skipRows * rowPitch + this.m_skipPixels * pixelSize + this.m_offset
       );

       assertMsgOptions(
           this.m_numLevels == 1, 'Number of levels is different than 1',
           false, true
       );

       // Fill data with grid.
       var cScale = deMath.subtract(this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin);
       var cBias = this.m_texFormatInfo.valueMin;
       var colorA = deMath.add(
           deMath.multiply([1.0, 0.0, 0.0, 1.0], cScale), cBias
       );
       var colorB = deMath.add(
           deMath.multiply([0.0, 1.0, 0.0, 1.0], cScale), cBias
       );

       var access = new tcuTexture.PixelBufferAccess({
                       format: this.m_texFormat,
                       width: this.m_width,
                       height: this.m_height,
                       depth: this.m_numLayers,
                       rowPitch: rowPitch,
                       slicePitch: slicePitch,
                       data: data,
                       offset: this.m_skipImages * slicePitch +
                           this.m_skipRows * rowPitch +
                           this.m_skipPixels * pixelSize +
                           this.m_offset
                       });
       tcuTextureUtil.fillWithGrid(access, 4, colorA, colorB);

       // Create buffer and upload.
       buf = this.m_context.createBuffer();
       this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf);
       this.m_context.bufferData(gl.PIXEL_UNPACK_BUFFER, data, gl.STATIC_DRAW);

       this.m_context.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, this.m_imageHeight);
       this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_IMAGES, this.m_skipImages);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment);

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D_ARRAY, tex);
       this.m_context.texImage3D(
           gl.TEXTURE_2D_ARRAY, 0, this.m_internalFormat, this.m_width,
           this.m_height, this.m_numLayers, 0, transferFmt.format,
           transferFmt.dataType, this.m_offset
       );
   };

   // TexImage3D() from pixel buffer object.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture3DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @param {number} depth
    * @param {number} imageHeight
    * @param {number} rowLength
    * @param {number} skipImages
    * @param {number} skipRows
    * @param {number} skipPixels
    * @param {number} alignment
    * @param {number} offset
    */
   es3fTextureSpecificationTests.TexImage3DBufferCase = function(
       name, desc, internalFormat, width, height, depth, imageHeight,
       rowLength, skipImages, skipRows, skipPixels, alignment, offset
   ) {
       es3fTextureSpecificationTests.Texture3DSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), width, height, depth, 1
       );

       this.m_internalFormat = internalFormat;
       this.m_imageHeight = imageHeight;
       this.m_rowLength = rowLength;
       this.m_skipImages = skipImages;
       this.m_skipRows = skipRows;
       this.m_skipPixels = skipPixels;
       this.m_alignment = alignment;
       this.m_offset = offset;
   };

   es3fTextureSpecificationTests.TexImage3DBufferCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture3DSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexImage3DBufferCase.prototype.constructor =
       es3fTextureSpecificationTests.TexImage3DBufferCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexImage3DBufferCase.prototype.createTexture = function() {
       var transferFmt = gluTextureUtil.getTransferFormat(
           this.m_texFormat
       );
       var pixelSize = this.m_texFormat.getPixelSize();
       var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_width;
       var rowPitch = deMath.deAlign32(
           rowLength * pixelSize, this.m_alignment
       );
       var imageHeight = this.m_imageHeight > 0 ?
           this.m_imageHeight : this.m_height;
       var slicePitch = imageHeight * rowPitch;
       var tex = null;
       var buf = null;
       var data = new ArrayBuffer(
           slicePitch * (this.m_depth + this.m_skipImages) +
           rowPitch * this.m_skipRows + pixelSize * this.m_skipPixels + this.m_offset
       );

       assertMsgOptions(
           this.m_numLevels == 1, 'Number of levels is different than 1',
           false, true
       );

       // Fill data with grid.
       var cScale = deMath.subtract(this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin);
       var cBias = this.m_texFormatInfo.valueMin;
       var colorA = deMath.add(
           deMath.multiply([1.0, 0.0, 0.0, 1.0], cScale), cBias
       );
       var colorB = deMath.add(
           deMath.multiply([0.0, 1.0, 0.0, 1.0], cScale), cBias
       );

       var access = new tcuTexture.PixelBufferAccess({
                       format: this.m_texFormat,
                       width: this.m_width,
                       height: this.m_height,
                       depth: this.m_depth,
                       rowPitch: rowPitch,
                       slicePitch: slicePitch,
                       data: data,
                       offset: this.m_skipImages * slicePitch +
                           this.m_skipRows * rowPitch +
                           this.m_skipPixels * pixelSize +
                           this.m_offset
                       });
       tcuTextureUtil.fillWithGrid(access, 4, colorA, colorB);

       // Create buffer and upload.
       buf = this.m_context.createBuffer();
       this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf);
       this.m_context.bufferData(gl.PIXEL_UNPACK_BUFFER, data, gl.STATIC_DRAW);

       this.m_context.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, this.m_imageHeight);
       this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_IMAGES, this.m_skipImages);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment);

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_3D, tex);
       this.m_context.texImage3D(
           gl.TEXTURE_3D, 0, this.m_internalFormat, this.m_width,
           this.m_height, this.m_depth, 0, transferFmt.format,
           transferFmt.dataType, this.m_offset
       );
   };

   // TexSubImage2D() PBO case.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @param {number} subX
    * @param {number} subY
    * @param {number} subW
    * @param {number} subH
    * @param {number} rowLength
    * @param {number} skipRows
    * @param {number} skipPixels
    * @param {number} alignment
    * @param {number} offset
    */
   es3fTextureSpecificationTests.TexSubImage2DBufferCase = function(
       name, desc, internalFormat, width, height, subX, subY, subW, subH,
       rowLength, skipRows, skipPixels, alignment, offset
   ) {
       es3fTextureSpecificationTests.Texture2DSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), width, height, 1
       );
       this.m_internalFormat = internalFormat;
       this.m_subX = subX;
       this.m_subY = subY;
       this.m_subW = subW;
       this.m_subH = subH;
       this.m_rowLength = rowLength;
       this.m_skipRows = skipRows;
       this.m_skipPixels = skipPixels;
       this.m_alignment = alignment;
       this.m_offset = offset;
   };

   es3fTextureSpecificationTests.TexSubImage2DBufferCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture2DSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexSubImage2DBufferCase.prototype.constructor =
       es3fTextureSpecificationTests.TexSubImage2DBufferCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexSubImage2DBufferCase.prototype.createTexture = function() {
       var transferFmt = gluTextureUtil.getTransferFormat(
           this.m_texFormat
       );
       var pixelSize = this.m_texFormat.getPixelSize();
       var tex = null;
       var buf = null;
       var data = new ArrayBuffer(
           deMath.deAlign32(this.m_width * pixelSize, 4) * this.m_height
       );

       assertMsgOptions(
           this.m_numLevels == 1, 'Number of levels is different than 1',
           false, true
       );

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D, tex);

       var access = new tcuTexture.PixelBufferAccess({
                       format: this.m_texFormat,
                       width: this.m_width,
                       height: this.m_height,
                       rowPitch: deMath.deAlign32(this.m_width * pixelSize, 4),
                       data: data
                       });
       // First fill texture with gradient.
       tcuTextureUtil.fillWithComponentGradients(access, this.m_texFormatInfo.valueMin, this.m_texFormatInfo.valueMax);
       this.m_context.texImage2D(
           gl.TEXTURE_2D, 0, this.m_internalFormat,
           this.m_width, this.m_height, 0, transferFmt.format,
           transferFmt.dataType, access.getDataPtr()
       );

       // Fill data with grid.
       var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_subW;
       var rowPitch = deMath.deAlign32(
           rowLength * pixelSize, this.m_alignment
       );
       var height = this.m_subH + this.m_skipRows;
       var cScale = deMath.subtract(this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin);
       var cBias = this.m_texFormatInfo.valueMin;
       var colorA = deMath.add(
           deMath.multiply([1.0, 0.0, 0.0, 1.0], cScale), cBias
       );
       var colorB = deMath.add(
           deMath.multiply([0.0, 1.0, 0.0, 1.0], cScale), cBias
       );

       access = new tcuTexture.PixelBufferAccess({
                       format: this.m_texFormat,
                       width: this.m_subW,
                       height: this.m_subH,
                       rowPitch: rowPitch,
                       data: new ArrayBuffer(rowPitch * height + this.m_offset),
                       offset: this.m_skipRows * rowPitch +
                               this.m_skipPixels * pixelSize +
                               this.m_offset
                       });
       tcuTextureUtil.fillWithGrid(access, 4, colorA, colorB);

       buf = this.m_context.createBuffer();
       this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf);
       this.m_context.bufferData(gl.PIXEL_UNPACK_BUFFER, access.getBuffer(), gl.STATIC_DRAW);

       this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment);

       this.m_context.texSubImage2D(
           gl.TEXTURE_2D, 0, this.m_subX, this.m_subY,
           this.m_subW, this.m_subH, transferFmt.format,
           transferFmt.dataType, this.m_offset
       );
   };

   // TexSubImage2D() cubemap PBO case.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.TextureCubeSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} size
    * @param {number} subX
    * @param {number} subY
    * @param {number} subW
    * @param {number} subH
    * @param {number} rowLength
    * @param {number} skipRows
    * @param {number} skipPixels
    * @param {number} alignment
    * @param {number} offset
    */
   es3fTextureSpecificationTests.TexSubImageCubeBufferCase = function(
       name, desc, internalFormat, size, subX, subY, subW, subH, rowLength,
       skipRows, skipPixels, alignment, offset
   ) {
       es3fTextureSpecificationTests.TextureCubeSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), size, 1
       );

       this.m_internalFormat = internalFormat;
       this.m_subX = subX;
       this.m_subY = subY;
       this.m_subW = subW;
       this.m_subH = subH;
       this.m_rowLength = rowLength;
       this.m_skipRows = skipRows;
       this.m_skipPixels = skipPixels;
       this.m_alignment = alignment;
       this.m_offset = offset;
   };

   es3fTextureSpecificationTests.TexSubImageCubeBufferCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.TextureCubeSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexSubImageCubeBufferCase.prototype.constructor =
       es3fTextureSpecificationTests.TexSubImageCubeBufferCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexSubImageCubeBufferCase.prototype.createTexture = function() {
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));
       var transferFmt = gluTextureUtil.getTransferFormat(
           this.m_texFormat
       );
       var pixelSize = this.m_texFormat.getPixelSize();
       var tex = null;
       var buf = null;
       var data = new ArrayBuffer(
           deMath.deAlign32(this.m_size * pixelSize, 4) * this.m_size
       );
       var access = new tcuTexture.PixelBufferAccess({
                           format: this.m_texFormat,
                           width: this.m_size,
                           height: this.m_size,
                           rowPitch: deMath.deAlign32(this.m_size * pixelSize, 4),
                           data: data
                       });
       assertMsgOptions(
           this.m_numLevels == 1, 'Number of levels is different than 1',
           false, true
       );

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_CUBE_MAP, tex);

       // Fill faces with different gradients.

       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       for (var f in tcuTexture.CubeFace) {
           var face = tcuTexture.CubeFace[f];
           var gMin = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );
           var gMax = es3fTextureSpecificationTests.randomVector(
               rnd, this.m_texFormatInfo.valueMin,
               this.m_texFormatInfo.valueMax, 4
           );

           tcuTextureUtil.fillWithComponentGradients(access, gMin, gMax);

           this.m_context.texImage2D(
               es3fTextureSpecificationTests.s_cubeMapFaces[face], 0,
               this.m_internalFormat, this.m_size, this.m_size, 0,
               transferFmt.format, transferFmt.dataType,
               access.getDataPtr()
           );
       }

       // Fill data with grid.
       var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_subW;
       var rowPitch = deMath.deAlign32(
           rowLength * pixelSize, this.m_alignment
       );
       var height = this.m_subH + this.m_skipRows;
       var cScale = deMath.subtract(this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin);
       var cBias = this.m_texFormatInfo.valueMin;
       var colorA = deMath.add(
           deMath.multiply([1.0, 0.0, 0.0, 1.0], cScale), cBias
       );
       var colorB = deMath.add(
           deMath.multiply([0.0, 1.0, 0.0, 1.0], cScale), cBias
       );

       data = new ArrayBuffer(rowPitch * height + this.m_skipPixels * pixelSize + this.m_offset);
       var accessSub = new tcuTexture.PixelBufferAccess({
                       format: this.m_texFormat,
                       width: this.m_subW,
                       height: this.m_subH,
                       rowPitch: rowPitch,
                       data: data,
                       offset: this.m_skipRows * rowPitch +
                           this.m_skipPixels * pixelSize +
                           this.m_offset
                       });
       tcuTextureUtil.fillWithGrid(accessSub, 4, colorA, colorB);

       buf = this.m_context.createBuffer();
       this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf);
       this.m_context.bufferData(
           gl.PIXEL_UNPACK_BUFFER, data, gl.STATIC_DRAW
       );

       this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment);

       for (var f in tcuTexture.CubeFace) {
           var face = tcuTexture.CubeFace[f];
           this.m_context.texSubImage2D(
               es3fTextureSpecificationTests.s_cubeMapFaces[face], 0,
               this.m_subX, this.m_subY, this.m_subW, this.m_subH,
               transferFmt.format, transferFmt.dataType, this.m_offset
           );
       }
   };

   // TexSubImage3D() 2D array PBO case.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DArraySpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @param {number} depth
    * @param {number} subX
    * @param {number} subY
    * @param {number} subZ
    * @param {number} subW
    * @param {number} subH
    * @param {number} subD
    * @param {number} imageHeight
    * @param {number} rowLength
    * @param {number} skipImages
    * @param {number} skipRows
    * @param {number} skipPixels
    * @param {number} alignment
    * @param {number} offset
    */
   es3fTextureSpecificationTests.TexSubImage2DArrayBufferCase = function(
       name, desc, internalFormat, width, height, depth, subX, subY, subZ,
       subW, subH, subD, imageHeight, rowLength, skipImages, skipRows,
       skipPixels, alignment, offset
   ) {
       es3fTextureSpecificationTests.Texture2DArraySpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), width, height, depth, 1
       );
       this.m_internalFormat = internalFormat;
       this.m_subX = subX;
       this.m_subY = subY;
       this.m_subZ = subZ;
       this.m_subW = subW;
       this.m_subH = subH;
       this.m_subD = subD;
       this.m_imageHeight = imageHeight;
       this.m_rowLength = rowLength;
       this.m_skipImages = skipImages;
       this.m_skipRows = skipRows;
       this.m_skipPixels = skipPixels;
       this.m_alignment = alignment;
       this.m_offset = offset;
   };

   es3fTextureSpecificationTests.TexSubImage2DArrayBufferCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexSubImage2DArrayBufferCase.prototype.constructor =
       es3fTextureSpecificationTests.TexSubImage2DArrayBufferCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexSubImage2DArrayBufferCase.prototype.createTexture = function() {
       var transferFmt = gluTextureUtil.getTransferFormat(
           this.m_texFormat
       );
       var pixelSize = this.m_texFormat.getPixelSize();
       var tex = null;
       var buf = null;
       /** @type {ArrayBuffer} */ var data;

       assertMsgOptions(
           this.m_numLevels == 1, 'Number of levels is different than 1',
           false, true
       );

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D_ARRAY, tex);

       // Fill with gradient.
       var rowPitch = deMath.deAlign32(pixelSize * this.m_width, 4);
       var slicePitch = rowPitch * this.m_height;

       data = new ArrayBuffer(slicePitch * this.m_numLayers);
       var access = new tcuTexture.PixelBufferAccess({
                       format: this.m_texFormat,
                       width: this.m_width,
                       height: this.m_height,
                       depth: this.m_numLayers,
                       rowPitch: rowPitch,
                       slicePitch: slicePitch,
                       data: data
                   });
       tcuTextureUtil.fillWithComponentGradients(access, this.m_texFormatInfo.valueMin, this.m_texFormatInfo.valueMax
       );

       this.m_context.texImage3D(gl.TEXTURE_2D_ARRAY, 0, this.m_internalFormat, this.m_width, this.m_height,
           this.m_numLayers, 0, transferFmt.format, transferFmt.dataType, access.getDataPtr());

       // Fill data with grid.
       var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_subW;
       rowPitch = deMath.deAlign32(
           rowLength * pixelSize, this.m_alignment
       );
       var height = this.m_subH + this.m_skipRows;
       var cScale = deMath.subtract(this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin);

       var cBias = this.m_texFormatInfo.valueMin;
       var colorA = deMath.add(
           deMath.multiply([1.0, 0.0, 0.0, 1.0], cScale), cBias
       );
       var colorB = deMath.add(
           deMath.multiply([0.0, 1.0, 0.0, 1.0], cScale), cBias
       );

       var accessSub = new tcuTexture.PixelBufferAccess({
                       format: this.m_texFormat,
                       width: this.m_subW,
                       height: this.m_subH,
                       rowPitch: rowPitch,
                       data: new ArrayBuffer(rowPitch * height + this.m_offset),
                       offset: this.m_skipRows * rowPitch +
                               this.m_skipPixels * pixelSize +
                               this.m_offset
                   });
       tcuTextureUtil.fillWithGrid(accessSub, 4, colorA, colorB);

       buf = this.m_context.createBuffer();
       this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf);
       this.m_context.bufferData(
           gl.PIXEL_UNPACK_BUFFER, accessSub.getBuffer(), gl.STATIC_DRAW
       );

       this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment);
   };

   // TexSubImage3D() PBO case.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture3DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} width
    * @param {number} height
    * @param {number} depth
    * @param {number} subX
    * @param {number} subY
    * @param {number} subZ
    * @param {number} subW
    * @param {number} subH
    * @param {number} subD
    * @param {number} imageHeight
    * @param {number} rowLength
    * @param {number} skipImages
    * @param {number} skipRows
    * @param {number} skipPixels
    * @param {number} alignment
    * @param {number} offset
    */
   es3fTextureSpecificationTests.TexSubImage3DBufferCase = function(
       name, desc, internalFormat, width, height, depth, subX, subY, subZ,
       subW, subH, subD, imageHeight, rowLength, skipImages, skipRows,
       skipPixels, alignment, offset
   ) {
       es3fTextureSpecificationTests.Texture3DSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), width, height, depth, 1
       );

       this.m_internalFormat = internalFormat;
       this.m_subX = subX;
       this.m_subY = subY;
       this.m_subZ = subZ;
       this.m_subW = subW;
       this.m_subH = subH;
       this.m_subD = subD;
       this.m_imageHeight = imageHeight;
       this.m_rowLength = rowLength;
       this.m_skipImages = skipImages;
       this.m_skipRows = skipRows;
       this.m_skipPixels = skipPixels;
       this.m_alignment = alignment;
       this.m_offset = offset;
   };

   es3fTextureSpecificationTests.TexSubImage3DBufferCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture3DSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexSubImage3DBufferCase.prototype.constructor =
       es3fTextureSpecificationTests.TexSubImage3DBufferCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexSubImage3DBufferCase.prototype.createTexture = function() {
       var transferFmt = gluTextureUtil.getTransferFormat(
           this.m_texFormat
       );
       var pixelSize = this.m_texFormat.getPixelSize();
       var tex = null;
       var buf = null;
       /** @type {ArrayBuffer} */ var data;

       assertMsgOptions(
           this.m_numLevels == 1, 'Number of levels is different than 1',
           false, true
       );

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_3D, tex);

       // Fill with gradient.
       var rowPitch = deMath.deAlign32(pixelSize * this.m_width, 4);
       var slicePitch = rowPitch * this.m_height;

       data = new ArrayBuffer(slicePitch * this.m_depth);
       var access = new tcuTexture.PixelBufferAccess({
                       format: this.m_texFormat,
                       width: this.m_width,
                       height: this.m_height,
                       depth: this.m_depth,
                       rowPitch: rowPitch,
                       slicePitch: slicePitch,
                       data: data});
       tcuTextureUtil.fillWithComponentGradients(access, this.m_texFormatInfo.valueMin, this.m_texFormatInfo.valueMax
       );

       this.m_context.texImage3D(
           gl.TEXTURE_3D, 0, this.m_internalFormat, this.m_width,
           this.m_height, this.m_depth, 0, transferFmt.format,
           transferFmt.dataType, access.getDataPtr()
       );

       // Fill data with grid.
       var rowLength = this.m_rowLength > 0 ? this.m_rowLength : this.m_subW;
       rowPitch = deMath.deAlign32(
           rowLength * pixelSize, this.m_alignment
       );
       var imageHeight = this.m_imageHeight > 0 ?
           this.m_imageHeight : this.m_subH;
       slicePitch = imageHeight * rowPitch;
       var cScale = deMath.subtract(this.m_texFormatInfo.valueMax, this.m_texFormatInfo.valueMin);
       var cBias = this.m_texFormatInfo.valueMin;
       var colorA = deMath.add(
           deMath.multiply([1.0, 0.0, 0.0, 1.0], cScale), cBias
       );
       var colorB = deMath.add(
           deMath.multiply([0.0, 1.0, 0.0, 1.0], cScale), cBias
       );

       data = new ArrayBuffer(slicePitch * (this.m_subD + this.m_skipImages) +
                              rowPitch * this.m_skipRows + pixelSize * this.m_skipPixels + this.m_offset);
       var accessSub = new tcuTexture.PixelBufferAccess({
                       format: this.m_texFormat,
                       width: this.m_subW,
                       height: this.m_subH,
                       depth: this.m_subD,
                       rowPitch: rowPitch,
                       slicePitch: slicePitch,
                       data: data,
                       offset: this.m_skipImages * slicePitch +
                               this.m_skipRows * rowPitch +
                               this.m_skipPixels * pixelSize +
                               this.m_offset
                   });
       tcuTextureUtil.fillWithGrid(accessSub, 4, colorA, colorB
       );

       buf = this.m_context.createBuffer();
       this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf);
       this.m_context.bufferData(
           gl.PIXEL_UNPACK_BUFFER, data, gl.STATIC_DRAW
       );

       this.m_context.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, this.m_imageHeight);
       this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, this.m_rowLength);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_IMAGES, this.m_skipImages);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, this.m_skipRows);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, this.m_skipPixels);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, this.m_alignment);
       this.m_context.texSubImage3D(
           gl.TEXTURE_3D, 0, this.m_subX, this.m_subY, this.m_subZ,
           this.m_subW, this.m_subH, this.m_subD, transferFmt.format,
           transferFmt.dataType, this.m_offset
       );
   };

   // TexImage2D() depth case.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} imageWidth
    * @param {number} imageHeight
    */
   es3fTextureSpecificationTests.TexImage2DDepthCase = function(
       name, desc, internalFormat, imageWidth, imageHeight
   ) {
       es3fTextureSpecificationTests.Texture2DSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), imageWidth, imageHeight,
           es3fTextureSpecificationTests.maxLevelCount(
               imageWidth, imageHeight
           )
       );

       this.m_internalFormat = internalFormat;
       // we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
       this.m_texFormatInfo.lookupBias = [0.25, 0.0, 0.0, 1.0];
       this.m_texFormatInfo.lookupScale = [0.5, 1.0, 1.0, 0.0];
   };

   es3fTextureSpecificationTests.TexImage2DDepthCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture2DSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexImage2DDepthCase.prototype.constructor =
       es3fTextureSpecificationTests.TexImage2DDepthCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.TexImage2DDepthCase.prototype.createTexture =
   function() {
       var fmt = gluTextureUtil.getTransferFormat(this.m_texFormat);
       var tex = null;
       var levelData = new tcuTexture.TextureLevel(
           this.m_texFormat, this.m_width, this.m_height
       );

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);
           var gMin = [-1.5, -2.0, 1.7, -1.5];
           var gMax = [2.0, 1.5, -1.0, 2.0];

           levelData.setSize(levelW, levelH);
           tcuTextureUtil.fillWithComponentGradients(
               levelData.getAccess(), gMin, gMax
           );

           this.m_context.texImage2D(
               gl.TEXTURE_2D, ndx, this.m_internalFormat, levelW, levelH, 0,
               fmt.format, fmt.dataType, levelData.getAccess().getDataPtr()
           );
       }
   };

   // TexImage3D() depth case.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DArraySpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} imageWidth
    * @param {number} imageHeight
    * @param {number} numLayers
    */
   es3fTextureSpecificationTests.TexImage2DArrayDepthCase = function(
       name, desc, internalFormat, imageWidth, imageHeight, numLayers
   ) {
       es3fTextureSpecificationTests.Texture2DArraySpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), imageWidth, imageHeight, numLayers,
           es3fTextureSpecificationTests.maxLevelCount(
               imageWidth, imageHeight
           )
       );

       this.m_internalFormat = internalFormat;
       // we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
       this.m_texFormatInfo.lookupBias = [0.25, 0.0, 0.0, 1.0];
       this.m_texFormatInfo.lookupScale = [0.5, 1.0, 1.0, 0.0];
   };

   es3fTextureSpecificationTests.TexImage2DArrayDepthCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexImage2DArrayDepthCase.prototype.constructor =
       es3fTextureSpecificationTests.TexImage2DArrayDepthCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexImage2DArrayDepthCase.prototype.createTexture = function() {
       var fmt = gluTextureUtil.getTransferFormat(this.m_texFormat);
       var tex = null;
       var levelData = new tcuTexture.TextureLevel(
           this.m_texFormat, this.m_width, this.m_height
       );

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D_ARRAY, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);
           var gMin = [-1.5, -2.0, 1.7, -1.5];
           var gMax = [2.0, 1.5, -1.0, 2.0];

           levelData.setSize(levelW, levelH, this.m_numLayers);
           tcuTextureUtil.fillWithComponentGradients(
               levelData.getAccess(), gMin, gMax
           );

           this.m_context.texImage3D(
               gl.TEXTURE_2D_ARRAY, ndx, this.m_internalFormat, levelW, levelH,
               this.m_numLayers, 0, fmt.format, fmt.dataType,
               levelData.getAccess().getDataPtr()
           );
       }
   };

   // TexSubImage2D() depth case.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} imageWidth
    * @param {number} imageHeight
    */
   es3fTextureSpecificationTests.TexSubImage2DDepthCase = function(
       name, desc, internalFormat, imageWidth, imageHeight
   ) {
       es3fTextureSpecificationTests.Texture2DSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), imageWidth, imageHeight,
           es3fTextureSpecificationTests.maxLevelCount(
               imageWidth, imageHeight
           )
       );

       this.m_internalFormat = internalFormat;
       // we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
       this.m_texFormatInfo.lookupBias = [0.25, 0.0, 0.0, 1.0];
       this.m_texFormatInfo.lookupScale = [0.5, 1.0, 1.0, 0.0];
   };

   es3fTextureSpecificationTests.TexSubImage2DDepthCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture2DSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexSubImage2DDepthCase.prototype.constructor =
       es3fTextureSpecificationTests.TexSubImage2DDepthCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexSubImage2DDepthCase.prototype.createTexture = function() {
       var fmt = gluTextureUtil.getTransferFormat(this.m_texFormat);
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));
       var tex = null;
       var levelData = new tcuTexture.TextureLevel(
           this.m_texFormat, this.m_width, this.m_height
       );

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       // First specify full texture.
       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);
           var gMin = [-1.5, -2.0, 1.7, -1.5];
           var gMax = [2.0, 1.5, -1.0, 2.0];

           levelData.setSize(levelW, levelH);
           tcuTextureUtil.fillWithComponentGradients(
               levelData.getAccess(), gMin, gMax
           );

           this.m_context.texImage2D(
               gl.TEXTURE_2D, ndx, this.m_internalFormat, levelW, levelH, 0,
               fmt.format, fmt.dataType, levelData.getAccess().getDataPtr()
           );
       }

       // Re-specify parts of each level.
       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);

           var w = rnd.getInt(1, levelW);
           var h = rnd.getInt(1, levelH);
           var x = rnd.getInt(0, levelW - w);
           var y = rnd.getInt(0, levelH - h);

            var colorA = [2.0, 1.5, -1.0, 2.0];
            var colorB = [-1.5, -2.0, 1.7, -1.5];
            var cellSize = rnd.getInt(2, 16);

           levelData.setSize(w, h);
           tcuTextureUtil.fillWithGrid(
               levelData.getAccess(), cellSize, colorA, colorB
           );

           this.m_context.texSubImage2D(
               gl.TEXTURE_2D, ndx, x, y, w, h, fmt.format, fmt.dataType,
               levelData.getAccess().getDataPtr()
           );
       }
   };

   // TexSubImage3D() depth case.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DArraySpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} imageWidth
    * @param {number} imageHeight
    * @param {number} numLayers
    */
   es3fTextureSpecificationTests.TexSubImage2DArrayDepthCase = function(
       name, desc, internalFormat, imageWidth, imageHeight, numLayers
   ) {
       es3fTextureSpecificationTests.Texture2DArraySpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), imageWidth, imageHeight, numLayers,
           es3fTextureSpecificationTests.maxLevelCount(
               imageWidth, imageHeight
           )
       );

       this.m_internalFormat = internalFormat;
       // we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
       this.m_texFormatInfo.lookupBias = [0.25, 0.0, 0.0, 1.0];
       this.m_texFormatInfo.lookupScale = [0.5, 1.0, 1.0, 0.0];
   };

   es3fTextureSpecificationTests.TexSubImage2DArrayDepthCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexSubImage2DArrayDepthCase.prototype.constructor =
       es3fTextureSpecificationTests.TexSubImage2DArrayDepthCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexSubImage2DArrayDepthCase.prototype.createTexture = function() {
       var fmt = gluTextureUtil.getTransferFormat(this.m_texFormat);
       var rnd = new deRandom.Random(deString.deStringHash(this.fullName()));
       var tex = null;
       var levelData = new tcuTexture.TextureLevel(
           this.m_texFormat, this.m_width, this.m_height
       );

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D_ARRAY, tex);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, 1);

       // First specify full texture.
       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);
           var gMin = [-1.5, -2.0, 1.7, -1.5];
           var gMax = [2.0, 1.5, -1.0, 2.0];

           levelData.setSize(levelW, levelH, this.m_numLayers);
           tcuTextureUtil.fillWithComponentGradients(
               levelData.getAccess(), gMin, gMax
           );
           this.m_context.texImage3D(
               gl.TEXTURE_2D_ARRAY, ndx, this.m_internalFormat, levelW, levelH,
               this.m_numLayers, 0, fmt.format, fmt.dataType,
               levelData.getAccess().getDataPtr()
           );
       }

       // Re-specify parts of each level.
       for (var ndx = 0; ndx < this.m_numLevels; ndx++) {
           var levelW = Math.max(1, this.m_width >> ndx);
           var levelH = Math.max(1, this.m_height >> ndx);

           var w = rnd.getInt(1, levelW);
           var h = rnd.getInt(1, levelH);
           var d = rnd.getInt(1, this.m_numLayers);
           var x = rnd.getInt(0, levelW - w);
           var y = rnd.getInt(0, levelH - h);
           var z = rnd.getInt(0, this.m_numLayers - d);

            var colorA = [2.0, 1.5, -1.0, 2.0];
            var colorB = [-1.5, -2.0, 1.7, -1.5];
            var cellSize = rnd.getInt(2, 16);

           levelData.setSize(w, h, d);
           tcuTextureUtil.fillWithGrid(
               levelData.getAccess(), cellSize, colorA, colorB
           );

           this.m_context.texSubImage3D(
               gl.TEXTURE_2D_ARRAY, ndx, x, y, z, w, h, d, fmt.format,
               fmt.dataType, levelData.getAccess().getDataPtr()
           );
       }
   };

   // TexImage2D() depth case with pbo.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DSpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} imageWidth
    * @param {number} imageHeight
    */
   es3fTextureSpecificationTests.TexImage2DDepthBufferCase = function(
       name, desc, internalFormat, imageWidth, imageHeight
   ) {
       es3fTextureSpecificationTests.Texture2DSpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), imageWidth, imageHeight, 1
       );

       this.m_internalFormat = internalFormat;
       // we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
       this.m_texFormatInfo.lookupBias = [0.25, 0.0, 0.0, 1.0];
       this.m_texFormatInfo.lookupScale = [0.5, 1.0, 1.0, 0.0];
   };

   es3fTextureSpecificationTests.TexImage2DDepthBufferCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture2DSpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexImage2DDepthBufferCase.prototype.constructor =
       es3fTextureSpecificationTests.TexImage2DDepthBufferCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexImage2DDepthBufferCase.prototype.createTexture = function() {
       var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat);
       var pixelSize = this.m_texFormat.getPixelSize();
       var rowLength = this.m_width;
       var alignment = 4;
       var rowPitch = deMath.deAlign32(rowLength * pixelSize, alignment);
       var height = this.m_height;
       var buf = null;
       var tex = null;
       var data = new ArrayBuffer(rowPitch * height);

       assertMsgOptions(
           this.m_numLevels == 1, 'Number of levels is different than 1',
           false, true
       );

       // Fill data with gradient
       var gMin = [-1.5, -2.0, 1.7, -1.5];
       var gMax = [2.0, 1.5, -1.0, 2.0];

       var access = new tcuTexture.PixelBufferAccess({
                       format: this.m_texFormat,
                       width: this.m_width,
                       height: this.m_height,
                       rowPitch: rowPitch,
                       data: data
                   });
       tcuTextureUtil.fillWithComponentGradients(access, gMin, gMax);

       // Create buffer and upload.
       buf = this.m_context.createBuffer();
       this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf);
       this.m_context.bufferData(
           gl.PIXEL_UNPACK_BUFFER, access.getBuffer(), gl.STATIC_DRAW
       );

       this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, rowLength);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, 0);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, 0);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, alignment);

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D, tex);
       this.m_context.texImage2D(
           gl.TEXTURE_2D, 0, this.m_internalFormat, this.m_width,
           this.m_height, 0, transferFmt.format, transferFmt.dataType, 0
       );
       this.m_context.deleteBuffer(buf);
   };

   // TexImage3D() depth case with pbo.
   /**
    * @constructor
    * @extends {es3fTextureSpecificationTests.Texture2DArraySpecCase}
    * @param {string} name
    * @param {string} desc
    * @param {number} internalFormat
    * @param {number} imageWidth
    * @param {number} imageHeight
    */
   es3fTextureSpecificationTests.TexImage2DArrayDepthBufferCase = function(
       name, desc, internalFormat, imageWidth, imageHeight, numLayers
   ) {
       es3fTextureSpecificationTests.Texture2DArraySpecCase.call(
           this, name, desc, gluTextureUtil.mapGLInternalFormat(
               internalFormat
           ), imageWidth, imageHeight, numLayers, 1
       );

       this.m_internalFormat = internalFormat;
       // we are interested in the behavior near [-2, 2], map it to visible range [0, 1]
       this.m_texFormatInfo.lookupBias = [0.25, 0.0, 0.0, 1.0];
       this.m_texFormatInfo.lookupScale = [0.5, 1.0, 1.0, 0.0];
   };

   es3fTextureSpecificationTests.TexImage2DArrayDepthBufferCase.prototype =
       Object.create(
           es3fTextureSpecificationTests.Texture2DArraySpecCase.prototype
       );

   es3fTextureSpecificationTests.
   TexImage2DArrayDepthBufferCase.prototype.constructor =
       es3fTextureSpecificationTests.TexImage2DArrayDepthBufferCase;

   /**
    * createTexture
    */
   es3fTextureSpecificationTests.
   TexImage2DArrayDepthBufferCase.prototype.createTexture = function() {
       var transferFmt = gluTextureUtil.getTransferFormat(this.m_texFormat);
       var pixelSize = this.m_texFormat.getPixelSize();
       var rowLength = this.m_width;
       var alignment = 4;
       var rowPitch = deMath.deAlign32(rowLength * pixelSize, alignment);
       var imageHeight = this.m_height;
       var slicePitch = imageHeight * rowPitch;
       var tex = null;
       var buf = null;
       var data = new ArrayBuffer(slicePitch * this.m_numLayers);

       assertMsgOptions(
           this.m_numLevels == 1, 'Number of levels is different than 1',
           false, true
       );

       // Fill data with gradient
       var gMin = [-1.5, -2.0, 1.7, -1.5];
       var gMax = [2.0, 1.5, -1.0, 2.0];

       var access = new tcuTexture.PixelBufferAccess({
                       format: this.m_texFormat,
                       width: this.m_width,
                       height: this.m_height,
                       depth: this.m_numLayers,
                       rowPitch: rowPitch,
                       slicePitch: slicePitch,
                       data: data
                   });
       tcuTextureUtil.fillWithComponentGradients(access, gMin, gMax);

       buf = this.m_context.createBuffer();
       this.m_context.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buf);
       this.m_context.bufferData(
           gl.PIXEL_UNPACK_BUFFER, access.getBuffer(), gl.STATIC_DRAW
       );

       this.m_context.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, rowLength);
       this.m_context.pixelStorei(gl.UNPACK_ROW_LENGTH, rowLength);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_IMAGES, 0);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_ROWS, 0);
       this.m_context.pixelStorei(gl.UNPACK_SKIP_PIXELS, 0);
       this.m_context.pixelStorei(gl.UNPACK_ALIGNMENT, alignment);

       tex = this.m_context.createTexture();
       this.m_context.bindTexture(gl.TEXTURE_2D_ARRAY, tex);
       this.m_context.texImage3D(
           gl.TEXTURE_2D_ARRAY, 0, this.m_internalFormat, this.m_width,
           this.m_height, this.m_numLayers, 0, transferFmt.format,
           transferFmt.dataType, 0
       );
       this.m_context.deleteBuffer(buf);
   };

   /**
    * @constructor
    * @extends {tcuTestCase.DeqpTest}
    */
   es3fTextureSpecificationTests.TextureSpecificationTests = function() {
       tcuTestCase.DeqpTest.call(
           this, 'specification', 'Texture Specification Tests'
       );
   };

   es3fTextureSpecificationTests.TextureSpecificationTests.prototype =
       Object.create(tcuTestCase.DeqpTest.prototype);
   es3fTextureSpecificationTests.TextureSpecificationTests.prototype.constructor =
       es3fTextureSpecificationTests.TextureSpecificationTests;

   es3fTextureSpecificationTests.TextureSpecificationTests.prototype.init = function() {
       /**
        * @type {Array<number>}
        */
       es3fTextureSpecificationTests.s_cubeMapFaces = [
           gl.TEXTURE_CUBE_MAP_NEGATIVE_X,
           gl.TEXTURE_CUBE_MAP_POSITIVE_X,
           gl.TEXTURE_CUBE_MAP_NEGATIVE_Y,
           gl.TEXTURE_CUBE_MAP_POSITIVE_Y,
           gl.TEXTURE_CUBE_MAP_NEGATIVE_Z,
           gl.TEXTURE_CUBE_MAP_POSITIVE_Z
       ];

       /** @type {Array<{name: string, format: number, dataType: number}>} */
       var unsizedFormats = [{
               name: 'alpha_unsigned_byte',
               format: gl.ALPHA,
               dataType: gl.UNSIGNED_BYTE
           }, {
               name: 'luminance_unsigned_byte',
               format: gl.LUMINANCE,
               dataType: gl.UNSIGNED_BYTE
           }, {
               name: 'luminance_alpha_unsigned_byte',
               format: gl.LUMINANCE_ALPHA,
               dataType: gl.UNSIGNED_BYTE
           }, {
               name: 'rgb_unsigned_short_5_6_5',
               format: gl.RGB,
               dataType: gl.UNSIGNED_SHORT_5_6_5
           }, {
               name: 'rgb_unsigned_byte',
               format: gl.RGB,
               dataType: gl.UNSIGNED_BYTE
           }, {
               name: 'rgba_unsigned_short_4_4_4_4',
               format: gl.RGBA,
               dataType: gl.UNSIGNED_SHORT_4_4_4_4
           }, {
               name: 'rgba_unsigned_short_5_5_5_1',
               format: gl.RGBA,
               dataType: gl.UNSIGNED_SHORT_5_5_5_1
           }, {
               name: 'rgba_unsigned_byte',
               format: gl.RGBA,
               dataType: gl.UNSIGNED_BYTE
           }
       ];

       /** @type {Array<{name: string, internalFormat: number}>} */
       var colorFormats = [{
               name: 'rgba32f', internalFormat: gl.RGBA32F
           }, {
               name: 'rgba32i', internalFormat: gl.RGBA32I
           }, {
               name: 'rgba32ui', internalFormat: gl.RGBA32UI
           }, {
               name: 'rgba16f', internalFormat: gl.RGBA16F
           }, {
               name: 'rgba16i', internalFormat: gl.RGBA16I
           }, {
               name: 'rgba16ui', internalFormat: gl.RGBA16UI
           }, {
               name: 'rgba8', internalFormat: gl.RGBA8
           }, {
               name: 'rgba8i', internalFormat: gl.RGBA8I
           }, {
               name: 'rgba8ui', internalFormat: gl.RGBA8UI
           }, {
               name: 'srgb8_alpha8', internalFormat: gl.SRGB8_ALPHA8
           }, {
               name: 'rgb10_a2', internalFormat: gl.RGB10_A2
           }, {
               name: 'rgb10_a2ui', internalFormat: gl.RGB10_A2UI
           }, {
               name: 'rgba4', internalFormat: gl.RGBA4
           }, {
               name: 'rgb5_a1', internalFormat: gl.RGB5_A1
           }, {
               name: 'rgba8_snorm', internalFormat: gl.RGBA8_SNORM
           }, {
               name: 'rgb8', internalFormat: gl.RGB8
           }, {
               name: 'rgb565', internalFormat: gl.RGB565
           }, {
               name: 'r11f_g11f_b10f', internalFormat: gl.R11F_G11F_B10F
           }, {
               name: 'rgb32f', internalFormat: gl.RGB32F
           }, {
               name: 'rgb32i', internalFormat: gl.RGB32I
           }, {
               name: 'rgb32ui', internalFormat: gl.RGB32UI
           }, {
               name: 'rgb16f', internalFormat: gl.RGB16F
           }, {
               name: 'rgb16i', internalFormat: gl.RGB16I
           }, {
               name: 'rgb16ui', internalFormat: gl.RGB16UI
           }, {
               name: 'rgb8_snorm', internalFormat: gl.RGB8_SNORM
           }, {
               name: 'rgb8i', internalFormat: gl.RGB8I
           }, {
               name: 'rgb8ui', internalFormat: gl.RGB8UI
           }, {
               name: 'srgb8', internalFormat: gl.SRGB8
           }, {
               name: 'rgb9_e5', internalFormat: gl.RGB9_E5
           }, {
               name: 'rg32f', internalFormat: gl.RG32F
           }, {
               name: 'rg32i', internalFormat: gl.RG32I
           }, {
               name: 'rg32ui', internalFormat: gl.RG32UI
           }, {
               name: 'rg16f', internalFormat: gl.RG16F
           }, {
               name: 'rg16i', internalFormat: gl.RG16I
           }, {
               name: 'rg16ui', internalFormat: gl.RG16UI
           }, {
               name: 'rg8', internalFormat: gl.RG8
           }, {
               name: 'rg8i', internalFormat: gl.RG8I
           }, {
               name: 'rg8ui', internalFormat: gl.RG8UI
           }, {
               name: 'rg8_snorm', internalFormat: gl.RG8_SNORM
           }, {
               name: 'r32f', internalFormat: gl.R32F
           }, {
               name: 'r32i', internalFormat: gl.R32I
           }, {
               name: 'r32ui', internalFormat: gl.R32UI
           }, {
               name: 'r16f', internalFormat: gl.R16F
           }, {
               name: 'r16i', internalFormat: gl.R16I
           }, {
               name: 'r16ui', internalFormat: gl.R16UI
           }, {
               name: 'r8', internalFormat: gl.R8
           }, {
               name: 'r8i', internalFormat: gl.R8I
           }, {
               name: 'r8ui', internalFormat: gl.R8UI
           }, {
               name: 'r8_snorm', internalFormat: gl.R8_SNORM
           }
       ];

       // Depth and stencil formats
       /** @type {Array<{name: string, internalFormat: number}>} */
       var depthStencilFormats = [{
               name: 'depth_component32f',
               internalFormat: gl.DEPTH_COMPONENT32F
           }, {
               name: 'depth_component24',
               internalFormat: gl.DEPTH_COMPONENT24
           }, {
               name: 'depth_component16',
               internalFormat: gl.DEPTH_COMPONENT16
           }, {
               name: 'depth32f_stencil8',
               internalFormat: gl.DEPTH32F_STENCIL8
           }, {
               name: 'depth24_stencil8',
               internalFormat: gl.DEPTH24_STENCIL8
           }
       ];

       // Basic TexImage2D usage.
       var splitBasicTex2D = 2, splitBasicTexCube = 5;
       /** @type {Array<{tcuTestCase.DeqpTest}>} */
       var basicTexImageGroup2D = [];
       for (var ii = 0; ii < splitBasicTex2D; ++ii) {
           basicTexImageGroup2D.push(
               new tcuTestCase.DeqpTest('basic_teximage2d', 'Basic glTexImage2D() usage')
           );
           this.addChild(basicTexImageGroup2D[ii]);
       }
       /** @type {Array<{tcuTestCase.DeqpTest}>} */
       var basicTexImageGroupCube = [];
       for (var ii = 0; ii < splitBasicTexCube; ++ii) {
           basicTexImageGroupCube.push(
               new tcuTestCase.DeqpTest('basic_teximage2d', 'Basic glTexImage2D() usage')
           );
           this.addChild(basicTexImageGroupCube[ii]);
       }
       for (var formatNdx = 0; formatNdx < colorFormats.length; formatNdx++) {
           /** @type {string} */
           var fmtName = colorFormats[formatNdx].name;
           /** @type {number} */
           var format = colorFormats[formatNdx].internalFormat;
           /** @type {number} */
           var tex2DWidth = 64;
           /** @type {number} */
           var tex2DHeight = 128;
           /** @type {number} */
           var texCubeSize = 64;

           basicTexImageGroup2D[formatNdx % splitBasicTex2D].addChild(
               es3fTextureSpecificationTests.newBasicTexImage2DCaseInternal(
                   fmtName + '_2d', '', format, tex2DWidth, tex2DHeight
               )
           );
           basicTexImageGroupCube[formatNdx % splitBasicTexCube].addChild(
               es3fTextureSpecificationTests.newBasicTexImageCubeCaseInternal(
                   fmtName + '_cube', '', format, texCubeSize
               )
           );
       }

       // Randomized TexImage2D order.
       /** @type {tcuTestCase.DeqpTest} */
       var randomTexImageGroup = new tcuTestCase.DeqpTest(
           'random_teximage2d', 'Randomized glTexImage2D() usage'
       );
       this.addChild(randomTexImageGroup);
       var rnd = new deRandom.Random(9);

       // 2D cases.
       for (var ndx = 0; ndx < 10; ndx++) {
           var formatNdx = rnd.getInt(0, colorFormats.length - 1);
           var width = 1 << rnd.getInt(2, 8);
           var height = 1 << rnd.getInt(2, 8);

           randomTexImageGroup.addChild(
               es3fTextureSpecificationTests.newRandomOrderTexImage2DCaseInternal(
                   '2d.' + colorFormats[formatNdx].name, '',
                   colorFormats[formatNdx].internalFormat, width, height
               )
           );
       }

       // Cubemap cases.
       randomTexImageGroup = new tcuTestCase.DeqpTest(
           'random_teximage2d', 'Randomized glTexImage2D() usage'
       );
       this.addChild(randomTexImageGroup);

       for (var ndx = 0; ndx < 10; ndx++) {
           formatNdx = rnd.getInt(0, colorFormats.length - 1);
           /** @type {number} */ var size = 1 << rnd.getInt(2, 8);

           randomTexImageGroup.addChild(
               es3fTextureSpecificationTests.newRandomOrderTexImageCubeCaseInternal(
                   'cube.' + colorFormats[formatNdx].name, '',
                   colorFormats[formatNdx].internalFormat, size
               )
           );
       }

       // TexImage2D unpack alignment.
       /** @type {tcuTestCase.DeqpTest} */
       var alignGroup = new tcuTestCase.DeqpTest(
           'teximage2d_align', 'glTexImage2D() unpack alignment tests'
       );
       this.addChild(alignGroup);

       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal(
               '2d_r8_4_8', '', gl.R8, 4, 8, 4, 8
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal(
               '2d_r8_63_1', '', gl.R8, 63, 30, 1, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal(
               '2d_r8_63_2', '', gl.R8, 63, 30, 1, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal(
               '2d_r8_63_4', '', gl.R8, 63, 30, 1, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal(
               '2d_r8_63_8', '', gl.R8, 63, 30, 1, 8
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal(
               '2d_rgba4_51_1', '', gl.RGBA4, 51, 30, 1, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal(
               '2d_rgba4_51_2', '', gl.RGBA4, 51, 30, 1, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal(
               '2d_rgba4_51_4', '', gl.RGBA4, 51, 30, 1, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal(
               '2d_rgba4_51_8', '', gl.RGBA4, 51, 30, 1, 8
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal(
               '2d_rgb8_39_1', '', gl.RGB8, 39, 43, 1, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal(
               '2d_rgb8_39_2', '', gl.RGB8, 39, 43, 1, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal(
               '2d_rgb8_39_4', '', gl.RGB8, 39, 43, 1, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal(
               '2d_rgb8_39_8', '', gl.RGB8, 39, 43, 1, 8
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal(
               '2d_rgba8_47_1', '', gl.RGBA8, 47, 27, 1, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal(
               '2d_rgba8_47_2', '', gl.RGBA8, 47, 27, 1, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal(
               '2d_rgba8_47_4', '', gl.RGBA8, 47, 27, 1, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImage2DAlignCaseInternal(
               '2d_rgba8_47_8', '', gl.RGBA8, 47, 27, 1, 8
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal(
               'cube_r8_4_8', '', gl.R8, 4, 3, 8
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal(
               'cube_r8_63_1', '', gl.R8, 63, 1, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal(
               'cube_r8_63_2', '', gl.R8, 63, 1, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal(
               'cube_r8_63_4', '', gl.R8, 63, 1, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal(
               'cube_r8_63_8', '', gl.R8, 63, 1, 8
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal(
               'cube_rgba4_51_1', '', gl.RGBA4, 51, 1, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal(
               'cube_rgba4_51_2', '', gl.RGBA4, 51, 1, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal(
               'cube_rgba4_51_4', '', gl.RGBA4, 51, 1, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal(
               'cube_rgba4_51_8', '', gl.RGBA4, 51, 1, 8
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal(
               'cube_rgb8_39_1', '', gl.RGB8, 39, 1, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal(
               'cube_rgb8_39_2', '', gl.RGB8, 39, 1, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal(
               'cube_rgb8_39_4', '', gl.RGB8, 39, 1, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal(
               'cube_rgb8_39_8', '', gl.RGB8, 39, 1, 8
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal(
               'cube_rgba8_47_1', '', gl.RGBA8, 47, 1, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal(
               'cube_rgba8_47_2', '', gl.RGBA8, 47, 1, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal(
               'cube_rgba8_47_4', '', gl.RGBA8, 47, 1, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexImageCubeAlignCaseInternal(
               'cube_rgba8_47_8', '', gl.RGBA8, 47, 1, 8
           )
       );

       // glTexImage2D() unpack parameter cases.
       /** @type {tcuTestCase.DeqpTest} */
       var paramGroup = new tcuTestCase.DeqpTest(
           'teximage2d_unpack_params',
           'glTexImage2D() pixel transfer mode cases'
       );
       this.addChild(paramGroup);

       var cases = [{
               name: 'rgb8_alignment', format: gl.RGB8, width: 31,
               height: 30, rowLength: 0, skipRows: 0, skipPixels: 0,
               alignment: 2
           }, {
               name: 'rgb8_row_length', format: gl.RGB8, width: 31,
               height: 30, rowLength: 50, skipRows: 0, skipPixels: 0,
               alignment: 4
           }, {
               name: 'rgb8_skip_rows', format: gl.RGB8, width: 31,
               height: 30, rowLength: 0, skipRows: 3, skipPixels: 0,
               alignment: 4
           }, {
               name: 'rgb8_skip_pixels', format: gl.RGB8, width: 31,
               height: 30, rowLength: 36, skipRows: 0, skipPixels: 5,
               alignment: 4
           }, {
               name: 'r8_complex1', format: gl.R8, width: 31,
               height: 30, rowLength: 64, skipRows: 1, skipPixels: 3,
               alignment: 1
           }, {
               name: 'r8_complex2', format: gl.R8, width: 31,
               height: 30, rowLength: 64, skipRows: 1, skipPixels: 3,
               alignment: 2
           }, {
               name: 'r8_complex3', format: gl.R8, width: 31,
               height: 30, rowLength: 64, skipRows: 1, skipPixels: 3,
               alignment: 4
           }, {
               name: 'r8_complex4', format: gl.R8, width: 31,
               height: 30, rowLength: 64, skipRows: 1, skipPixels: 3,
               alignment: 8
           }, {
               name: 'rgba8_complex1', format: gl.RGBA8, width: 56,
               height: 61, rowLength: 69, skipRows: 0, skipPixels: 0,
               alignment: 8
           }, {
               name: 'rgba8_complex2', format: gl.RGBA8, width: 56,
               height: 61, rowLength: 69, skipRows: 0, skipPixels: 7,
               alignment: 8
           }, {
               name: 'rgba8_complex3', format: gl.RGBA8, width: 56,
               height: 61, rowLength: 69, skipRows: 3, skipPixels: 0,
               alignment: 8
           }, {
               name: 'rgba8_complex4', format: gl.RGBA8, width: 56,
               height: 61, rowLength: 69, skipRows: 3, skipPixels: 7,
               alignment: 8
           }, {
               name: 'rgba32f_complex', format: gl.RGBA32F, width: 19,
               height: 10, rowLength: 27, skipRows: 1, skipPixels: 7,
               alignment: 8
           }
       ];

       for (var ndx = 0; ndx < cases.length; ndx++)
           paramGroup.addChild(
               new es3fTextureSpecificationTests.TexImage2DParamsCase(
                   cases[ndx].name, '', cases[ndx].format, cases[ndx].width,
                   cases[ndx].height, cases[ndx].rowLength,
                   cases[ndx].skipRows, cases[ndx].skipPixels,
                   cases[ndx].alignment
               )
           );

       // glTexImage2D() pbo cases.
       var splitPboTex2D = 2, splitPboTexCube = 5;
       /** @type {Array<{tcuTestCase.DeqpTest}>} */ var pboGroup2D = [];
       for (var ii = 0; ii < splitPboTex2D; ++ii) {
           pboGroup2D.push(new tcuTestCase.DeqpTest('teximage2d_pbo', 'glTexImage2D() from PBO'));
           this.addChild(pboGroup2D[ii]);
       }
       /** @type {Array<{tcuTestCase.DeqpTest}>} */ var pboGroupCube = [];
       for (var ii = 0; ii < splitPboTexCube; ++ii) {
           pboGroupCube.push(new tcuTestCase.DeqpTest('teximage2d_pbo', 'glTexImage2D() from PBO'));
          this.addChild(pboGroupCube[ii]);
       }
       for (var formatNdx = 0; formatNdx < colorFormats.length; formatNdx++) {
           fmtName = colorFormats[formatNdx].name;
           format = colorFormats[formatNdx].internalFormat;
           tex2DWidth = 65;
           tex2DHeight = 37;
           texCubeSize = 64;

           pboGroup2D[formatNdx % splitPboTex2D].addChild(
               new es3fTextureSpecificationTests.TexImage2DBufferCase(
                   fmtName + '_2d', '', format,
                   tex2DWidth, tex2DHeight, 0, 0, 0, 4, 0
               )
           );
           pboGroupCube[formatNdx % splitPboTexCube].addChild(
               new es3fTextureSpecificationTests.TexImageCubeBufferCase(
                   fmtName + '_cube', '', format,
                   texCubeSize, 0, 0, 0, 4, 0
               )
           );
       }

       // Parameter cases
       var pboGroupParams = new tcuTestCase.DeqpTest(
           'teximage2d_pbo', 'glTexImage2D() from PBO'
       );
       this.addChild(pboGroupParams);
       /**
        * @type {Array<{name: string, format: number, width: number,
        * height: number, rowLength: number, skipRows: number,
        * skipPixels: number, alignment: number, offset: number}>}
        */
       var parameterCases = [{
               name: 'rgb8_offset', format: gl.RGB8, width: 31,
               height: 30, rowLength: 0, skipRows: 0, skipPixels: 0,
               alignment: 4, offset: 67
           }, {
               name: 'rgb8_alignment', format: gl.RGB8, width: 31,
               height: 30, rowLength: 0, skipRows: 0, skipPixels: 0,
               alignment: 2, offset: 0
           }, {
               name: 'rgb8_row_length', format: gl.RGB8, width: 31,
               height: 30, rowLength: 50, skipRows: 0, skipPixels: 0,
               alignment: 4, offset: 0
           }, {
               name: 'rgb8_skip_rows', format: gl.RGB8, width: 31,
               height: 30, rowLength: 0, skipRows: 3, skipPixels: 0,
               alignment: 4, offset: 0
           }, {
               name: 'rgb8_skip_pixels', format: gl.RGB8, width: 31,
               height: 30, rowLength: 36, skipRows: 0, skipPixels: 5,
               alignment: 4, offset: 0
           }
       ];
       for (var ndx = 0; ndx < parameterCases.length; ndx++) {
           pboGroupParams.addChild(
               new es3fTextureSpecificationTests.TexImage2DBufferCase(
                   parameterCases[ndx].name + '_2d', '',
                   parameterCases[ndx].format, parameterCases[ndx].width,
                   parameterCases[ndx].height, parameterCases[ndx].rowLength,
                   parameterCases[ndx].skipRows,
                   parameterCases[ndx].skipPixels,
                   parameterCases[ndx].alignment,
                   parameterCases[ndx].offset
               )
           );
           pboGroupParams.addChild(
               new es3fTextureSpecificationTests.TexImageCubeBufferCase(
                   parameterCases[ndx].name + '_cube', '',
                   parameterCases[ndx].format, parameterCases[ndx].width,
                   parameterCases[ndx].rowLength, parameterCases[ndx].skipRows,
                   parameterCases[ndx].skipPixels,
                   parameterCases[ndx].alignment, parameterCases[ndx].offset
               )
           );
       }

       // glTexImage2D() depth cases.
       /** @type {tcuTestCase.DeqpTest} */
       var shadow2dGroup = new tcuTestCase.DeqpTest(
           'teximage2d_depth',
           'glTexImage2D() with depth or depth/stencil format'
       );
       this.addChild(shadow2dGroup);

       for (var ndx = 0; ndx < depthStencilFormats.length; ndx++) {
           // WebGL 2 specific constraint.
           if (depthStencilFormats[ndx].internalFormat == gl.DEPTH32F_STENCIL8)
               continue;
           var tex2DWidth = 64;
           var tex2DHeight = 128;

           shadow2dGroup.addChild(
               new es3fTextureSpecificationTests.TexImage2DDepthCase(
                   depthStencilFormats[ndx].name, '',
                   depthStencilFormats[ndx].internalFormat,
                   tex2DWidth, tex2DHeight
               )
           );
       }

       // glTexImage2D() depth cases with pbo.
       shadow2dGroup = new tcuTestCase.DeqpTest(
           'teximage2d_depth_pbo',
           'glTexImage2D() with depth or depth/stencil format with pbo'
       );
       this.addChild(shadow2dGroup);

       for (var ndx = 0; ndx < depthStencilFormats.length; ndx++) {
           tex2DWidth = 64;
           tex2DHeight = 128;

           shadow2dGroup.addChild(
               new es3fTextureSpecificationTests.TexImage2DDepthBufferCase(
                   depthStencilFormats[ndx].name, '',
                   depthStencilFormats[ndx].internalFormat,
                   tex2DWidth, tex2DHeight
               )
           );
       }

       // Basic TexSubImage2D usage.
       splitBasicTex2D = 3;
       splitBasicTexCube = 5;
       /** @type {Array<{tcuTestCase.DeqpTest}>} */
       var basicTexSubImageGroup2D = [];
       for (var ii = 0; ii < splitBasicTex2D; ++ii) {
           basicTexSubImageGroup2D.push(
               new tcuTestCase.DeqpTest('basic_texsubimage2d', 'Basic glTexSubImage2D() usage')
           );
           this.addChild(basicTexSubImageGroup2D[ii]);
       }
       /** @type {Array<{tcuTestCase.DeqpTest}>} */
       var basicTexSubImageGroupCube = [];
       for (var ii = 0; ii < splitBasicTexCube; ++ii) {
           basicTexSubImageGroupCube.push(
               new tcuTestCase.DeqpTest('basic_texsubimage2d', 'Basic glTexSubImage2D() usage')
           );
           this.addChild(basicTexSubImageGroupCube[ii]);
       }
       for (var formatNdx = 0; formatNdx < colorFormats.length; formatNdx++) {
           fmtName = colorFormats[formatNdx].name;
           format = colorFormats[formatNdx].internalFormat;
           tex2DWidth = 64;
           tex2DHeight = 128;
           texCubeSize = 64;

           basicTexSubImageGroup2D[formatNdx % splitBasicTex2D].addChild(
               es3fTextureSpecificationTests.newBasicTexSubImage2DCaseInternal(
                   fmtName + '_2d', '', format, tex2DWidth, tex2DHeight
               )
           );
           basicTexSubImageGroupCube[formatNdx % splitBasicTexCube].addChild(
               es3fTextureSpecificationTests.newBasicTexImageCubeCaseInternal(
                   fmtName + '_cube', '', format, texCubeSize
               )
           );
       }

       // TexSubImage2D to empty texture.
       /** @type {tcuTestCase.DeqpTest} */
       var texSubImageEmptyTexGroup = new tcuTestCase.DeqpTest(
           'texsubimage2d_empty_tex',
           'glTexSubImage2D() to texture that has storage but no data'
       );
       this.addChild(texSubImageEmptyTexGroup);
       for (var formatNdx = 0; formatNdx < unsizedFormats.length; formatNdx++) {
           fmtName = unsizedFormats[formatNdx].name;
           format = unsizedFormats[formatNdx].format;
           /** @type {number} */
           var dataType = unsizedFormats[formatNdx].dataType;
           tex2DWidth = 64;
           tex2DHeight = 32;
           texCubeSize = 32;

           texSubImageEmptyTexGroup.addChild(
               new es3fTextureSpecificationTests.TexSubImage2DEmptyTexCase(
                   fmtName + '_2d', '', format, dataType, tex2DWidth, tex2DHeight
               )
           );
           texSubImageEmptyTexGroup.addChild(
               new es3fTextureSpecificationTests.TexSubImageCubeEmptyTexCase(
                   fmtName + '_cube', '', format, dataType, texCubeSize
               )
           );
       }

       // TexSubImage2D alignment cases.
       alignGroup = new tcuTestCase.DeqpTest(
           'texsubimage2d_align', 'glTexSubImage2D() unpack alignment tests'
       );
       this.addChild(alignGroup);

       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_r8_1_1', '', gl.R8, 64, 64, 13, 17, 1, 6, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_r8_1_2', '', gl.R8, 64, 64, 13, 17, 1, 6, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_r8_1_4', '', gl.R8, 64, 64, 13, 17, 1, 6, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_r8_1_8', '', gl.R8, 64, 64, 13, 17, 1, 6, 8
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_r8_63_1', '', gl.R8, 64, 64, 1, 9, 63, 30, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_r8_63_2', '', gl.R8, 64, 64, 1, 9, 63, 30, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_r8_63_4', '', gl.R8, 64, 64, 1, 9, 63, 30, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_r8_63_8', '', gl.R8, 64, 64, 1, 9, 63, 30, 8
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_rgba4_51_1', '', gl.RGBA4, 64, 64, 7, 29, 51, 30, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_rgba4_51_2', '', gl.RGBA4, 64, 64, 7, 29, 51, 30, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_rgba4_51_4', '', gl.RGBA4, 64, 64, 7, 29, 51, 30, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_rgba4_51_8', '', gl.RGBA4, 64, 64, 7, 29, 51, 30, 8
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_rgb8_39_1', '', gl.RGB8, 64, 64, 11, 8, 39, 43, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_rgb8_39_2', '', gl.RGB8, 64, 64, 11, 8, 39, 43, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_rgb8_39_4', '', gl.RGB8, 64, 64, 11, 8, 39, 43, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_rgb8_39_8', '', gl.RGB8, 64, 64, 11, 8, 39, 43, 8
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_rgba8_47_1', '', gl.RGBA8, 64, 64, 10, 1, 47, 27, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_rgba8_47_2', '', gl.RGBA8, 64, 64, 10, 1, 47, 27, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_rgba8_47_4', '', gl.RGBA8, 64, 64, 10, 1, 47, 27, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImage2DAlignCaseInternal(
               '2d_rgba8_47_8', '', gl.RGBA8, 64, 64, 10, 1, 47, 27, 8
           )
       );

       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_r8_1_1', '', gl.R8, 64, 13, 17, 1, 6, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_r8_1_2', '', gl.R8, 64, 13, 17, 1, 6, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_r8_1_4', '', gl.R8, 64, 13, 17, 1, 6, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_r8_1_8', '', gl.R8, 64, 13, 17, 1, 6, 8
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_r8_63_1', '', gl.R8, 64, 1, 9, 63, 30, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_r8_63_2', '', gl.R8, 64, 1, 9, 63, 30, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_r8_63_4', '', gl.R8, 64, 1, 9, 63, 30, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_r8_63_8', '', gl.R8, 64, 1, 9, 63, 30, 8
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_rgba4_51_1', '', gl.RGBA4, 64, 7, 29, 51, 30, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_rgba4_51_2', '', gl.RGBA4, 64, 7, 29, 51, 30, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_rgba4_51_4', '', gl.RGBA4, 64, 7, 29, 51, 30, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_rgba4_51_8', '', gl.RGBA4, 64, 7, 29, 51, 30, 8
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_rgb8_39_1', '', gl.RGB8, 64, 11, 8, 39, 43, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_rgb8_39_2', '', gl.RGB8, 64, 11, 8, 39, 43, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_rgb8_39_4', '', gl.RGB8, 64, 11, 8, 39, 43, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_rgb8_39_8', '', gl.RGB8, 64, 11, 8, 39, 43, 8
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_rgba8_47_1', '', gl.RGBA8, 64, 10, 1, 47, 27, 1
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_rgba8_47_2', '', gl.RGBA8, 64, 10, 1, 47, 27, 2
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_rgba8_47_4', '', gl.RGBA8, 64, 10, 1, 47, 27, 4
           )
       );
       alignGroup.addChild(
           es3fTextureSpecificationTests.newTexSubImageCubeAlignCaseInternal(
               'cube_rgba8_47_8', '', gl.RGBA8, 64, 10, 1, 47, 27, 8
           )
       );

       // glTexSubImage2D() pixel transfer mode cases.
       paramGroup = new tcuTestCase.DeqpTest(
           'texsubimage2d_unpack_params',
           'glTexSubImage2D() pixel transfer mode cases'
       );
       this.addChild(paramGroup);

       cases = [{
               name: 'rgb8_alignment', format: gl.RGB8, width: 54,
               height: 60, subX: 11, subY: 7, subW: 31, subH: 30,
               rowLength: 0, skipRows: 0, skipPixels: 0, alignment: 2
           }, {
               name: 'rgb8_row_length', format: gl.RGB8, width: 54,
               height: 60, subX: 11, subY: 7, subW: 31, subH: 30,
               rowLength: 50, skipRows: 0, skipPixels: 0, alignment: 4
           }, {
               name: 'rgb8_skip_rows', format: gl.RGB8, width: 54,
               height: 60, subX: 11, subY: 7, subW: 31, subH: 30,
               rowLength: 0, skipRows: 3, skipPixels: 0, alignment: 4
           }, {
               name: 'rgb8_skip_pixels', format: gl.RGB8, width: 54,
               height: 60, subX: 11, subY: 7, subW: 31, subH: 30,
               rowLength: 36, skipRows: 0, skipPixels: 5, alignment: 4
           }, {
               name: 'r8_complex1', format: gl.R8, width: 54,
               height: 60, subX: 11, subY: 7, subW: 31, subH: 30,
               rowLength: 64, skipRows: 1, skipPixels: 3, alignment: 1
           }, {
               name: 'r8_complex2', format: gl.R8, width: 54,
               height: 60, subX: 11, subY: 7, subW: 31, subH: 30,
               rowLength: 64, skipRows: 1, skipPixels: 3, alignment: 2
           }, {
               name: 'r8_complex3', format: gl.R8, width: 54,
               height: 60, subX: 11, subY: 7, subW: 31, subH: 30,
               rowLength: 64, skipRows: 1, skipPixels: 3, alignment: 4
           }, {
               name: 'r8_complex4', format: gl.R8, width: 54,
               height: 60, subX: 11, subY: 7, subW: 31, subH: 30,
               rowLength: 64, skipRows: 1, skipPixels: 3, alignment: 8
           }, {
               name: 'rgba8_complex1', format: gl.RGBA8, width: 92,
               height: 84, subX: 13, subY: 19, subW: 56, subH: 61,
               rowLength: 69, skipRows: 0, skipPixels: 0, alignment: 8
           }, {
               name: 'rgba8_complex2', format: gl.RGBA8, width: 92,
               height: 84, subX: 13, subY: 19, subW: 56, subH: 61,
               rowLength: 69, skipRows: 0, skipPixels: 7, alignment: 8
           }, {
               name: 'rgba8_complex3', format: gl.RGBA8, width: 92,
               height: 84, subX: 13, subY: 19, subW: 56, subH: 61,
               rowLength: 69, skipRows: 3, skipPixels: 0, alignment: 8
           }, {
               name: 'rgba8_complex4', format: gl.RGBA8, width: 92,
               height: 84, subX: 13, subY: 19, subW: 56, subH: 61,
               rowLength: 69, skipRows: 3, skipPixels: 7, alignment: 8
           }, {
               name: 'rgba32f_complex', format: gl.RGBA32F, width: 92,
               height: 84, subX: 13, subY: 19, subW: 56, subH: 61,
               rowLength: 69, skipRows: 3, skipPixels: 7, alignment: 8
           }
       ];

       for (var ndx = 0; ndx < cases.length; ndx++)
           paramGroup.addChild(
               new es3fTextureSpecificationTests.TexSubImage2DParamsCase(
                   cases[ndx].name, '', cases[ndx].format, cases[ndx].width,
                   cases[ndx].height, cases[ndx].subX, cases[ndx].subY,
                   cases[ndx].subW, cases[ndx].subH, cases[ndx].rowLength,
                   cases[ndx].skipRows, cases[ndx].skipPixels,
                   cases[ndx].alignment
               )
           );

       // glTexSubImage2D() PBO cases.
       splitPboTex2D = 2;
       splitPboTexCube = 5;
       pboGroup2D = [];
       for (var ii = 0; ii < splitPboTex2D; ++ii) {
           pboGroup2D.push(new tcuTestCase.DeqpTest(
               'texsubimage2d_pbo',
               'glTexSubImage2D() pixel buffer object tests'
           ));
           this.addChild(pboGroup2D[ii]);
       }
       pboGroupCube = [];
       for (var ii = 0; ii < splitPboTexCube; ++ii) {
           pboGroupCube.push(new tcuTestCase.DeqpTest(
               'texsubimage2d_pbo',
               'glTexSubImage2D() pixel buffer object tests'
           ));
           this.addChild(pboGroupCube[ii]);
       }

       for (var ndx = 0; ndx < colorFormats.length; ndx++) {
           pboGroup2D[ndx % splitPboTex2D].addChild(
               new es3fTextureSpecificationTests.TexSubImage2DBufferCase(
                   colorFormats[ndx].name + '_2d', '',
                   colorFormats[ndx].internalFormat,
                   54, // Width
                   60, // Height
                   11, // Sub X
                   7, // Sub Y
                   31, // Sub W
                   30, // Sub H
                   0, // Row len
                   0, // Skip rows
                   0, // Skip pixels
                   4, // Alignment
                   0 /* offset */
               )
           );
           pboGroupCube[ndx % splitPboTexCube].addChild(
               new es3fTextureSpecificationTests.TexSubImageCubeBufferCase(
                   colorFormats[ndx].name + '_cube', '',
                   colorFormats[ndx].internalFormat,
                   64, // Size
                   11, // Sub X
                   7, // Sub Y
                   31, // Sub W
                   30, // Sub H
                   0, // Row len
                   0, // Skip rows
                   0, // Skip pixels
                   4, // Alignment
                   0 /* offset */
               )
           );
       }

       pboGroupParams = new tcuTestCase.DeqpTest(
           'texsubimage2d_pbo',
           'glTexSubImage2D() pixel buffer object tests'
       );
       this.addChild(pboGroupParams);
       /** @type {Array<{name: string, format: number, width: number,
        * height: number, subX: number, subY: number,
        * subW: number, subH: number, rowLength: number, skipRows: number,
        * skipPixels: number, alignment: number, offset: number}>}
        */
       var paramCases = [{
               name: 'rgb8_offset', format: gl.RGB8, width: 54,
               height: 60, subX: 11, subY: 7, subW: 31, subH: 30,
               rowLength: 0, skipRows: 0, skipPixels: 0,
               alignment: 4, offset: 67
           }, {
               name: 'rgb8_alignment', format: gl.RGB8, width: 54,
               height: 60, subX: 11, subY: 7, subW: 31, subH: 30,
               rowLength: 0, skipRows: 0, skipPixels: 0,
               alignment: 2, offset: 0
           }, {
               name: 'rgb8_row_length', format: gl.RGB8, width: 54,
               height: 60, subX: 11, subY: 7, subW: 31, subH: 30,
               rowLength: 50, skipRows: 0, skipPixels: 0,
               alignment: 4, offset: 0
           }, {
               name: 'rgb8_skip_rows', format: gl.RGB8, width: 54,
               height: 60, subX: 11, subY: 7, subW: 31, subH: 30,
               rowLength: 0, skipRows: 3, skipPixels: 0,
               alignment: 4, offset: 0
           }, {
               name: 'rgb8_skip_pixels', format: gl.RGB8, width: 54,
               height: 60, subX: 11, subY: 7, subW: 31, subH: 30,
               rowLength: 36, skipRows: 0, skipPixels: 5,
               alignment: 4, offset: 0
           }
       ];

       for (var ndx = 0; ndx < paramCases.length; ndx++) {
           pboGroupParams.addChild(
               new es3fTextureSpecificationTests.TexSubImage2DBufferCase(
                   paramCases[ndx].name + '_2d', '',
                   paramCases[ndx].format,
                   paramCases[ndx].width,
                   paramCases[ndx].height,
                   paramCases[ndx].subX,
                   paramCases[ndx].subY,
                   paramCases[ndx].subW,
                   paramCases[ndx].subH,
                   paramCases[ndx].rowLength,
                   paramCases[ndx].skipRows,
                   paramCases[ndx].skipPixels,
                   paramCases[ndx].alignment,
                   paramCases[ndx].offset));
           pboGroupParams.addChild(
               new es3fTextureSpecificationTests.TexSubImageCubeBufferCase(
                   paramCases[ndx].name + '_cube', '',
                   paramCases[ndx].format,
                   paramCases[ndx].width,
                   paramCases[ndx].subX,
                   paramCases[ndx].subY,
                   paramCases[ndx].subW,
                   paramCases[ndx].subH,
                   paramCases[ndx].rowLength,
                   paramCases[ndx].skipRows,
                   paramCases[ndx].skipPixels,
                   paramCases[ndx].alignment,
                   paramCases[ndx].offset
               )
           );
       }

       // glTexSubImage2D() depth cases.
       shadow2dGroup = new tcuTestCase.DeqpTest(
           'texsubimage2d_depth',
           'glTexSubImage2D() with depth or depth/stencil format'
       );
       this.addChild(shadow2dGroup);

       for (var ndx = 0; ndx < depthStencilFormats.length; ndx++) {
           // WebGL 2 specific constraint.
           if (depthStencilFormats[ndx].internalFormat == gl.DEPTH32F_STENCIL8)
               continue;
           tex2DWidth = 64;
           tex2DHeight = 32;

           shadow2dGroup.addChild(
               new es3fTextureSpecificationTests.TexSubImage2DDepthCase(
                   depthStencilFormats[ndx].name, '',
                   depthStencilFormats[ndx].internalFormat,
                   tex2DWidth, tex2DHeight
               )
           );
       }

       // Basic glCopyTexImage2D() cases
       /** @type {tcuTestCase.DeqpTest} */
       var copyTexImageGroup = new tcuTestCase.DeqpTest(
           'basic_copyteximage2d', 'Basic glCopyTexImage2D() usage'
       );
       this.addChild(copyTexImageGroup);

       copyTexImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexImage2DCase(
               '2d_alpha', '', gl.ALPHA, 128, 64
           )
       );
       copyTexImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexImage2DCase(
               '2d_luminance', '', gl.LUMINANCE, 128, 64
           )
       );
       copyTexImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexImage2DCase(
               '2d_luminance_alpha', '', gl.LUMINANCE_ALPHA, 128, 64
           )
       );
       copyTexImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexImage2DCase(
               '2d_rgb', '', gl.RGB, 128, 64
           )
       );
       copyTexImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexImage2DCase(
               '2d_rgba', '', gl.RGBA, 128, 64
           )
       );

       copyTexImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexImageCubeCase(
               'cube_alpha', '', gl.ALPHA, 64
           )
       );
       copyTexImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexImageCubeCase(
               'cube_luminance', '', gl.LUMINANCE, 64
           )
       );
       copyTexImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexImageCubeCase(
               'cube_luminance_alpha', '', gl.LUMINANCE_ALPHA, 64
           )
       );
       copyTexImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexImageCubeCase(
               'cube_rgb', '', gl.RGB, 64
           )
       );
       copyTexImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexImageCubeCase(
               'cube_rgba', '', gl.RGBA, 64
           )
       );

       // Basic glCopyTexSubImage2D() cases
       /** @type {tcuTestCase.DeqpTest} */
       var copyTexSubImageGroup = new tcuTestCase.DeqpTest(
           'basic_copytexsubimage2d', 'Basic glCopyTexSubImage2D() usage'
       );
       this.addChild(copyTexSubImageGroup);

       copyTexSubImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexSubImage2DCase(
               '2d_alpha', '', gl.ALPHA, gl.UNSIGNED_BYTE, 128, 64
           )
       );
       copyTexSubImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexSubImage2DCase(
               '2d_luminance', '', gl.LUMINANCE, gl.UNSIGNED_BYTE, 128, 64
           )
       );
       copyTexSubImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexSubImage2DCase(
               '2d_luminance_alpha', '', gl.LUMINANCE_ALPHA, gl.UNSIGNED_BYTE, 128, 64
           )
       );
       copyTexSubImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexSubImage2DCase(
               '2d_rgb', '', gl.RGB, gl.UNSIGNED_BYTE, 128, 64
           )
       );
       copyTexSubImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexSubImage2DCase(
               '2d_rgba', '', gl.RGBA, gl.UNSIGNED_BYTE, 128, 64
           )
       );

       copyTexSubImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexSubImageCubeCase(
               'cube_alpha', '', gl.ALPHA, gl.UNSIGNED_BYTE, 64
           )
       );
       copyTexSubImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexSubImageCubeCase(
               'cube_luminance', '', gl.LUMINANCE, gl.UNSIGNED_BYTE, 64
           )
       );
       copyTexSubImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexSubImageCubeCase(
               'cube_luminance_alpha', '', gl.LUMINANCE_ALPHA, gl.UNSIGNED_BYTE, 64
           )
       );
       copyTexSubImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexSubImageCubeCase(
               'cube_rgb', '', gl.RGB, gl.UNSIGNED_BYTE, 64
           )
       );
       copyTexSubImageGroup.addChild(
           new es3fTextureSpecificationTests.BasicCopyTexSubImageCubeCase(
               'cube_rgba', '', gl.RGBA, gl.UNSIGNED_BYTE, 64
           )
       );

       // Basic TexImage3D usage.
       var splitBasicTex2DArray = 3, splitBasicTex3D = 5;
       /** @type {Array<{tcuTestCase.DeqpTest}>} */
       var basicTexImageGroup2DArray = [];
       for (var ii = 0; ii < splitBasicTex2DArray; ++ii) {
           basicTexImageGroup2DArray.push(
               new tcuTestCase.DeqpTest('basic_teximage3d', 'Basic glTexImage3D() usage')
           );
           this.addChild(basicTexImageGroup2DArray[ii]);
       }
       /** @type {Array<{tcuTestCase.DeqpTest}>} */
       var basicTexImageGroup3D = [];
       for (var ii = 0; ii < splitBasicTex3D; ++ii) {
           basicTexImageGroup3D.push(
               new tcuTestCase.DeqpTest('basic_teximage3d', 'Basic glTexImage3D() usage')
           );
           this.addChild(basicTexImageGroup3D[ii]);
       }
       for (var formatNdx = 0; formatNdx < colorFormats.length; formatNdx++) {
           fmtName = colorFormats[formatNdx].name;
           format = colorFormats[formatNdx].internalFormat;
           /** @type {number} */ var tex2DArrayWidth = 57;
           /** @type {number} */ var tex2DArrayHeight = 44;
           /** @type {number} */ var tex2DArrayLevels = 5;
           /** @type {number} */ var tex3DWidth = 63;
           /** @type {number} */ var tex3DHeight = 29;
           /** @type {number} */ var tex3DDepth = 11;

           basicTexImageGroup2DArray[formatNdx % splitBasicTex2DArray].addChild(
               new es3fTextureSpecificationTests.BasicTexImage2DArrayCase(
                   fmtName + '_2d_array', '', format,
                   tex2DArrayWidth, tex2DArrayHeight, tex2DArrayLevels
               )
           );
           basicTexImageGroup3D[formatNdx % splitBasicTex3D].addChild(
               new es3fTextureSpecificationTests.BasicTexImage3DCase(
                   fmtName + '_3d', '', format,
                   tex3DWidth, tex3DHeight, tex3DDepth
               )
           );
       }

       // glTexImage3D() unpack params cases.
       paramGroup = new tcuTestCase.DeqpTest(
           'teximage3d_unpack_params', 'glTexImage3D() unpack parameters'
       );
       this.addChild(paramGroup);

       cases = [{
               name: 'rgb8_image_height', format: gl.RGB8, width: 23,
               height: 19, depth: 8, imageHeight: 26, rowLength: 0,
               skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 4
           }, {
               name: 'rgb8_row_length', format: gl.RGB8, width: 23,
               height: 19, depth: 8, imageHeight: 0, rowLength: 27,
               skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 4
           }, {
               name: 'rgb8_skip_images', format: gl.RGB8, width: 23,
               height: 19, depth: 8, imageHeight: 0, rowLength: 0,
               skipImages: 3, skipRows: 0, skipPixels: 0, alignment: 4
           }, {
               name: 'rgb8_skip_rows', format: gl.RGB8, width: 23,
               height: 19, depth: 8, imageHeight: 22, rowLength: 0,
               skipImages: 0, skipRows: 3, skipPixels: 0, alignment: 4
           }, {
               name: 'rgb8_skip_pixels', format: gl.RGB8, width: 23,
               height: 19, depth: 8, imageHeight: 0, rowLength: 25,
               skipImages: 0, skipRows: 0, skipPixels: 2, alignment: 4
           }, {
               name: 'r8_complex1', format: gl.R8, width: 13,
               height: 17, depth: 11, imageHeight: 23, rowLength: 15,
               skipImages: 2, skipRows: 3, skipPixels: 1, alignment: 1
           }, {
               name: 'r8_complex2', format: gl.R8, width: 13,
               height: 17, depth: 11, imageHeight: 23, rowLength: 15,
               skipImages: 2, skipRows: 3, skipPixels: 1, alignment: 2
           }, {
               name: 'r8_complex3', format: gl.R8, width: 13,
               height: 17, depth: 11, imageHeight: 23, rowLength: 15,
               skipImages: 2, skipRows: 3, skipPixels: 1, alignment: 4
           }, {
               name: 'r8_complex4', format: gl.R8, width: 13,
               height: 17, depth: 11, imageHeight: 23, rowLength: 15,
               skipImages: 2, skipRows: 3, skipPixels: 1, alignment: 8
           }, {
               name: 'rgba8_complex1', format: gl.RGBA8, width: 11,
               height: 20, depth: 8, imageHeight: 25, rowLength: 14,
               skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 8
           }, {
               name: 'rgba8_complex2', format: gl.RGBA8, width: 11,
               height: 20, depth: 8, imageHeight: 25, rowLength: 14,
               skipImages: 0, skipRows: 2, skipPixels: 0, alignment: 8
           }, {
               name: 'rgba8_complex3', format: gl.RGBA8, width: 11,
               height: 20, depth: 8, imageHeight: 25, rowLength: 14,
               skipImages: 0, skipRows: 0, skipPixels: 3, alignment: 8
           }, {
               name: 'rgba8_complex4', format: gl.RGBA8, width: 11,
               height: 20, depth: 8, imageHeight: 25, rowLength: 14,
               skipImages: 0, skipRows: 2, skipPixels: 3, alignment: 8
           }, {
               name: 'rgba32f_complex', format: gl.RGBA32F, width: 11,
               height: 20, depth: 8, imageHeight: 25, rowLength: 14,
               skipImages: 0, skipRows: 2, skipPixels: 3, alignment: 8
            }
       ];

       for (var ndx = 0; ndx < cases.length; ndx++)
           paramGroup.addChild(
               new es3fTextureSpecificationTests.TexImage3DParamsCase(
                   cases[ndx].name, '', cases[ndx].format, cases[ndx].width,
                   cases[ndx].height, cases[ndx].depth, cases[ndx].imageHeight,
                   cases[ndx].rowLength, cases[ndx].skipImages,
                   cases[ndx].skipRows, cases[ndx].skipPixels,
                   cases[ndx].alignment
               )
           );

       // glTexImage3D() pbo cases.
       var splitTex2DArray = 2, splitTex3D = 2;
       /** @type {Array<{tcuTestCase.DeqpTest}>} */ var pboGroup2DArray = [];
       for (var ii = 0; ii < splitTex2DArray; ++ii) {
           pboGroup2DArray.push(
               new tcuTestCase.DeqpTest('teximage3d_pbo', 'glTexImage3D() from PBO')
           );
           this.addChild(pboGroup2DArray[ii]);
       }
       /** @type {Array<{tcuTestCase.DeqpTest}>} */ var pboGroup3D = [];
       for (var ii = 0; ii < splitTex3D; ++ii) {
           pboGroup3D.push(
               new tcuTestCase.DeqpTest('teximage3d_pbo', 'glTexImage3D() from PBO')
           );
           this.addChild(pboGroup3D[ii]);
       }

       for (var formatNdx = 0; formatNdx < colorFormats.length; formatNdx++) {
           fmtName = colorFormats[formatNdx].name;
           format = colorFormats[formatNdx].internalFormat;
           tex3DWidth = 11;
           tex3DHeight = 20;
           tex3DDepth = 8;

           pboGroup2DArray[formatNdx % splitTex2DArray].addChild(
               new es3fTextureSpecificationTests.TexImage2DArrayBufferCase(
                   fmtName + '_2d_array', '', format, tex3DWidth, tex3DHeight,
                   tex3DDepth, 0, 0, 0, 0, 0, 4, 0
               )
           );
           pboGroup3D[formatNdx % splitTex3D].addChild(
               new es3fTextureSpecificationTests.TexImage3DBufferCase(
                   fmtName + '_3d', '', format, tex3DWidth, tex3DHeight,
                   tex3DDepth, 0, 0, 0, 0, 0, 4, 0
               )
           );
       }

       // Parameter cases
       parameterCases = [{
               name: 'rgb8_offset', format: gl.RGB8, width: 23,
               height: 19, depth: 8, imageHeight: 0, rowLength: 0,
               skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 1,
               offset: 67
           }, {
               name: 'rgb8_alignment', format: gl.RGB8, width: 23,
               height: 19, depth: 8, imageHeight: 0, rowLength: 0,
               skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 2,
               offset: 0
           }, {
               name: 'rgb8_image_height', format: gl.RGB8, width: 23,
               height: 19, depth: 8, imageHeight: 26, rowLength: 0,
               skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 4,
               offset: 0
           }, {
               name: 'rgb8_row_length', format: gl.RGB8, width: 23,
               height: 19, depth: 8, imageHeight: 0, rowLength: 27,
               skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 4,
               offset: 0
           }, {
               name: 'rgb8_skip_images', format: gl.RGB8, width: 23,
               height: 19, depth: 8, imageHeight: 0, rowLength: 0,
               skipImages: 3, skipRows: 0, skipPixels: 0, alignment: 4,
               offset: 0
           }, {
               name: 'rgb8_skip_rows', format: gl.RGB8, width: 23,
               height: 19, depth: 8, imageHeight: 22, rowLength: 0,
               skipImages: 0, skipRows: 3, skipPixels: 0, alignment: 4,
               offset: 0
           }, {
               name: 'rgb8_skip_pixels', format: gl.RGB8, width: 23,
               height: 19, depth: 8, imageHeight: 0, rowLength: 25,
               skipImages: 0, skipRows: 0, skipPixels: 2, alignment: 4,
               offset: 0
           }
       ];

       pboGroupParams = new tcuTestCase.DeqpTest('teximage3d_pbo', 'glTexImage3D() from PBO');
       this.addChild(pboGroupParams);
       for (var ndx = 0; ndx < parameterCases.length; ndx++) {
           pboGroupParams.addChild(
               new es3fTextureSpecificationTests.TexImage2DArrayBufferCase(
                   parameterCases[ndx].name + '_2d_array', '',
                   parameterCases[ndx].format, parameterCases[ndx].width,
                   parameterCases[ndx].height, parameterCases[ndx].depth,
                   parameterCases[ndx].imageHeight,
                   parameterCases[ndx].rowLength,
                   parameterCases[ndx].skipImages,
                   parameterCases[ndx].skipRows,
                   parameterCases[ndx].skipPixels,
                   parameterCases[ndx].alignment, parameterCases[ndx].offset
               )
           );
           pboGroupParams.addChild(
               new es3fTextureSpecificationTests.TexImage3DBufferCase(
                   parameterCases[ndx].name + '_3d', '',
                   parameterCases[ndx].format, parameterCases[ndx].width,
                   parameterCases[ndx].height, parameterCases[ndx].depth,
                   parameterCases[ndx].imageHeight,
                   parameterCases[ndx].rowLength,
                   parameterCases[ndx].skipImages,
                   parameterCases[ndx].skipRows,
                   parameterCases[ndx].skipPixels,
                   parameterCases[ndx].alignment, parameterCases[ndx].offset
               )
           );
       }

       // glTexImage3D() depth cases.
       /** @type {tcuTestCase.DeqpTest} */
       var shadow3dGroup = new tcuTestCase.DeqpTest(
           'teximage3d_depth',
           'glTexImage3D() with depth or depth/stencil format'
       );
       this.addChild(shadow3dGroup);

       for (var ndx = 0; ndx < depthStencilFormats.length; ndx++) {
           // WebGL 2 specific constraint.
           if (depthStencilFormats[ndx].internalFormat == gl.DEPTH32F_STENCIL8)
               continue;
           tex3DWidth = 32;
           tex3DHeight = 64;
           tex3DDepth = 8;

           shadow3dGroup.addChild(
               new es3fTextureSpecificationTests.TexImage2DArrayDepthCase(
                   depthStencilFormats[ndx].name + '_2d_array', '',
                   depthStencilFormats[ndx].internalFormat,
                   tex3DWidth, tex3DHeight, tex3DDepth
               )
           );
       }

       // glTexImage3D() depth cases with pbo.
       shadow3dGroup = new tcuTestCase.DeqpTest(
           'teximage3d_depth_pbo',
           'glTexImage3D() with depth or depth/stencil format with pbo'
       );
       this.addChild(shadow3dGroup);

       for (var ndx = 0; ndx < depthStencilFormats.length; ndx++) {
           tex3DWidth = 32;
           tex3DHeight = 64;
           tex3DDepth = 8;

           shadow3dGroup.addChild(
               new es3fTextureSpecificationTests.TexImage2DArrayDepthBufferCase(
                   depthStencilFormats[ndx].name + '_2d_array', '',
                   depthStencilFormats[ndx].internalFormat,
                   tex3DWidth, tex3DHeight, tex3DDepth
               )
           );
       }

       // Basic TexSubImage3D usage.
       splitTex3D = 5;
       /** @type {Array<{tcuTestCase.DeqpTest}>} */ var basicTexSubImageGroup = [];
       for (var ii = 0; ii < splitTex3D; ++ii) {
           basicTexSubImageGroup.push(
               new tcuTestCase.DeqpTest('basic_texsubimage3d', 'Basic glTexSubImage3D() usage')
           );
           this.addChild(basicTexSubImageGroup[ii]);
       }

       for (var formatNdx = 0; formatNdx < colorFormats.length; formatNdx++) {
           fmtName = colorFormats[formatNdx].name;
           format = colorFormats[formatNdx].internalFormat;
           tex3DWidth = 32;
           tex3DHeight = 64;
           tex3DDepth = 8;

           basicTexSubImageGroup[formatNdx % splitTex3D].addChild(
               new es3fTextureSpecificationTests.BasicTexSubImage3DCase(
                   fmtName + '_3d', '', format,
                   tex3DWidth, tex3DHeight, tex3DDepth
               )
           );
       }

       // glTexSubImage3D() unpack params cases.
       paramGroup = new tcuTestCase.DeqpTest(
           'texsubimage3d_unpack_params', 'glTexSubImage3D() unpack parameters'
       );
       this.addChild(paramGroup);

       /** @type {Array<{name: string, format: number, width: number,
        * height: number, depth: number, subX: number, subY: number,
        * subZ: number, subW: number, subH: number, subD: number,
        * imageHeight: number, rowLength: number, skipImages: number,
        * skipRows: number, skipPixels: number, alignment: number}>}
        */
       var casesSubImage3D = [{
               name: 'rgb8_image_height', format: gl.RGB8, width: 26,
               height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23,
               subH: 19, subD: 8, imageHeight: 26, rowLength: 0,
               skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 4
           }, {
               name: 'rgb8_row_length', format: gl.RGB8, width: 26,
               height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23,
               subH: 19, subD: 8, imageHeight: 0, rowLength: 27,
               skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 4
           }, {
               name: 'rgb8_skip_images', format: gl.RGB8, width: 26,
               height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23,
               subH: 19, subD: 8, imageHeight: 0, rowLength: 0,
               skipImages: 3, skipRows: 0, skipPixels: 0, alignment: 4
           }, {
               name: 'rgb8_skip_rows', format: gl.RGB8, width: 26,
               height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23,
               subH: 19, subD: 8, imageHeight: 22, rowLength: 0,
               skipImages: 0, skipRows: 3, skipPixels: 0, alignment: 4
           }, {
               name: 'rgb8_skip_pixels', format: gl.RGB8, width: 26,
               height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23,
               subH: 19, subD: 8, imageHeight: 0, rowLength: 25,
               skipImages: 0, skipRows: 0, skipPixels: 2, alignment: 4
           }, {
               name: 'r8_complex1', format: gl.R8, width: 15,
               height: 20, depth: 11, subX: 1, subY: 1, subZ: 0, subW: 13,
               subH: 17, subD: 11, imageHeight: 23, rowLength: 15,
               skipImages: 2, skipRows: 3, skipPixels: 1, alignment: 1
           }, {
               name: 'r8_complex2', format: gl.R8, width: 15,
               height: 20, depth: 11, subX: 1, subY: 1, subZ: 0, subW: 13,
               subH: 17, subD: 11, imageHeight: 23, rowLength: 15,
               skipImages: 2, skipRows: 3, skipPixels: 1, alignment: 2
           }, {
               name: 'r8_complex3', format: gl.R8, width: 15,
               height: 20, depth: 11, subX: 1, subY: 1, subZ: 0, subW: 13,
               subH: 17, subD: 11, imageHeight: 23, rowLength: 15,
               skipImages: 2, skipRows: 3, skipPixels: 1, alignment: 4
           }, {
               name: 'r8_complex4', format: gl.R8, width: 15,
               height: 20, depth: 11, subX: 1, subY: 1, subZ: 0, subW: 13,
               subH: 17, subD: 11, imageHeight: 23, rowLength: 15,
               skipImages: 2, skipRows: 3, skipPixels: 1, alignment: 8
           }, {
               name: 'rgba8_complex1', format: gl.RGBA8, width: 15,
               height: 25, depth: 10, subX: 0, subY: 5, subZ: 1, subW: 11,
               subH: 20, subD: 8, imageHeight: 25, rowLength: 14,
               skipImages: 0, skipRows: 0, skipPixels: 0, alignment: 8
           }, {
               name: 'rgba8_complex2', format: gl.RGBA8, width: 15,
               height: 25, depth: 10, subX: 0, subY: 5, subZ: 1, subW: 11,
               subH: 20, subD: 8, imageHeight: 25, rowLength: 14,
               skipImages: 0, skipRows: 2, skipPixels: 0, alignment: 8
           }, {
               name: 'rgba8_complex3', format: gl.RGBA8, width: 15,
               height: 25, depth: 10, subX: 0, subY: 5, subZ: 1, subW: 11,
               subH: 20, subD: 8, imageHeight: 25, rowLength: 14,
               skipImages: 0, skipRows: 0, skipPixels: 3, alignment: 8
           }, {
               name: 'rgba8_complex4', format: gl.RGBA8, width: 15,
               height: 25, depth: 10, subX: 0, subY: 5, subZ: 1, subW: 11,
               subH: 20, subD: 8, imageHeight: 25, rowLength: 14,
               skipImages: 0, skipRows: 2, skipPixels: 3, alignment: 8
           }, {
               name: 'rgba32f_complex', format: gl.RGBA32F, width: 15,
               height: 25, depth: 10, subX: 0, subY: 5, subZ: 1, subW: 11,
               subH: 20, subD: 8, imageHeight: 25, rowLength: 14,
               skipImages: 0, skipRows: 2, skipPixels: 3, alignment: 8
           }
       ];

       for (var ndx = 0; ndx < casesSubImage3D.length; ndx++)
           paramGroup.addChild(
               new es3fTextureSpecificationTests.TexSubImage3DParamsCase(
                   casesSubImage3D[ndx].name, '', casesSubImage3D[ndx].format,
                   casesSubImage3D[ndx].width, casesSubImage3D[ndx].height, casesSubImage3D[ndx].depth,
                   casesSubImage3D[ndx].subX, casesSubImage3D[ndx].subY, casesSubImage3D[ndx].subZ,
                   casesSubImage3D[ndx].subW, casesSubImage3D[ndx].subH, casesSubImage3D[ndx].subD,
                   casesSubImage3D[ndx].imageHeight, casesSubImage3D[ndx].rowLength,
                   casesSubImage3D[ndx].skipImages, casesSubImage3D[ndx].skipRows,
                   casesSubImage3D[ndx].skipPixels, casesSubImage3D[ndx].alignment
               )
           );

       // glTexSubImage3D() PBO cases.
       splitTex2DArray = 2;
       pboGroup2DArray = [];
       for (var ii = 0; ii < splitTex2DArray; ++ii) {
           pboGroup2DArray.push(
               new tcuTestCase.DeqpTest('texsubimage3d_pbo', 'glTexSubImage3D() pixel buffer object tests')
           );
           this.addChild(pboGroup2DArray[ii]);
       }

       splitTex3D = 2;
       pboGroup3D = [];
       for (var ii = 0; ii < splitTex3D; ++ii) {
           pboGroup3D.push(
               new tcuTestCase.DeqpTest('texsubimage3d_pbo', 'glTexSubImage3D() pixel buffer object tests')
           );
           this.addChild(pboGroup3D[ii]);
       }

       for (var ndx = 0; ndx < colorFormats.length; ndx++) {
           pboGroup2DArray[ndx % splitTex2DArray].addChild(
               new es3fTextureSpecificationTests.TexSubImage2DArrayBufferCase(
                   colorFormats[ndx].name + '_2d_array', '',
                   colorFormats[ndx].internalFormat,
                   26, // Width
                   25, // Height
                   10, // Depth
                   1, // Sub X
                   2, // Sub Y
                   0, // Sub Z
                   23, // Sub W
                   19, // Sub H
                   8, // Sub D
                   0, // Image height
                   0, // Row length
                   0, // Skip images
                   0, // Skip rows
                   0, // Skip pixels
                   4, // Alignment
                   0 // offset
               )
           );
           pboGroup3D[ndx % splitTex3D].addChild(
               new es3fTextureSpecificationTests.TexSubImage3DBufferCase(
                   colorFormats[ndx].name + '_3d', '',
                   colorFormats[ndx].internalFormat,
                   26, // Width
                   25, // Height
                   10, // Depth
                   1, // Sub X
                   2, // Sub Y
                   0, // Sub Z
                   23, // Sub W
                   19, // Sub H
                   8, // Sub D
                   0, // Image height
                   0, // Row length
                   0, // Skip images
                   0, // Skip rows
                   0, // Skip pixels
                   4, // Alignment
                   0 // offset
               )
           );
       }

       paramCases = [{
               name: 'rgb8_offset', format: gl.RGB8, width: 26,
               height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23,
               subH: 19, subD: 8, imageHeight: 0, rowLength: 0, skipImages: 0,
               skipRows: 0, skipPixels: 0, alignment: 4, offset: 67
           }, {
               name: 'rgb8_image_height', format: gl.RGB8, width: 26,
               height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23,
               subH: 19, subD: 8, imageHeight: 26, rowLength: 0, skipImages: 0,
               skipRows: 0, skipPixels: 0, alignment: 4, offset: 0
           }, {
               name: 'rgb8_row_length', format: gl.RGB8, width: 26,
               height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23,
               subH: 19, subD: 8, imageHeight: 0, rowLength: 27, skipImages: 0,
               skipRows: 0, skipPixels: 0, alignment: 4, offset: 0
           }, {
               name: 'rgb8_skip_images', format: gl.RGB8, width: 26,
               height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23,
               subH: 19, subD: 8, imageHeight: 0, rowLength: 0, skipImages: 3,
               skipRows: 0, skipPixels: 0, alignment: 4, offset: 0
           }, {
               name: 'rgb8_skip_rows', format: gl.RGB8, width: 26,
               height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23,
               subH: 19, subD: 8, imageHeight: 22, rowLength: 0, skipImages: 0,
               skipRows: 3, skipPixels: 0, alignment: 4, offset: 0
           }, {
               name: 'rgb8_skip_pixels', format: gl.RGB8, width: 26,
               height: 25, depth: 10, subX: 1, subY: 2, subZ: 1, subW: 23,
               subH: 19, subD: 8, imageHeight: 0, rowLength: 25, skipImages: 0,
               skipRows: 0, skipPixels: 2, alignment: 4, offset: 0
           }
       ];

       pboGroupParams = new tcuTestCase.DeqpTest(
           'texsubimage3d_pbo', 'glTexSubImage3D() pixel buffer object tests'
       );
       this.addChild(pboGroupParams);

       for (var ndx = 0; ndx < paramCases.length; ndx++) {
           pboGroupParams.addChild(
               new es3fTextureSpecificationTests.TexSubImage2DArrayBufferCase(
                   paramCases[ndx].name + '_2d_array', '',
                   paramCases[ndx].format, paramCases[ndx].width,
                   paramCases[ndx].height, paramCases[ndx].depth,
                   paramCases[ndx].subX, paramCases[ndx].subY,
                   paramCases[ndx].subZ, paramCases[ndx].subW,
                   paramCases[ndx].subH, paramCases[ndx].subD,
                   paramCases[ndx].imageHeight, paramCases[ndx].rowLength,
                   paramCases[ndx].skipImages, paramCases[ndx].skipRows,
                   paramCases[ndx].skipPixels, paramCases[ndx].alignment,
                   paramCases[ndx].offset
               )
           );
           pboGroupParams.addChild(
               new es3fTextureSpecificationTests.TexSubImage3DBufferCase(
                   paramCases[ndx].name + '_3d', '',
                   paramCases[ndx].format, paramCases[ndx].width,
                   paramCases[ndx].height, paramCases[ndx].depth,
                   paramCases[ndx].subX, paramCases[ndx].subY,
                   paramCases[ndx].subZ, paramCases[ndx].subW,
                   paramCases[ndx].subH, paramCases[ndx].subD,
                   paramCases[ndx].imageHeight, paramCases[ndx].rowLength,
                   paramCases[ndx].skipImages, paramCases[ndx].skipRows,
                   paramCases[ndx].skipPixels, paramCases[ndx].alignment,
                   paramCases[ndx].offset
               )
           );
       }

       // glTexSubImage3D() depth cases.
       shadow3dGroup = new tcuTestCase.DeqpTest(
           'texsubimage3d_depth',
           'glTexSubImage3D() with depth or depth/stencil format'
       );
       this.addChild(shadow3dGroup);

       for (var ndx = 0; ndx < depthStencilFormats.length; ndx++) {
           // WebGL 2 specific constraint.
           if (depthStencilFormats[ndx].internalFormat == gl.DEPTH32F_STENCIL8)
               continue;
           tex2DArrayWidth = 57;
           tex2DArrayHeight = 44;
           tex2DArrayLevels = 5;

           shadow3dGroup.addChild(
               new es3fTextureSpecificationTests.TexSubImage2DArrayDepthCase(
                   depthStencilFormats[ndx].name + '_2d_array', '',
                   depthStencilFormats[ndx].internalFormat, tex2DArrayWidth,
                   tex2DArrayHeight, tex2DArrayLevels
               )
           );
       }

       // glTexStorage2D() cases.

       // Color formats
       var splitStorage2D = 3, splitStorageCube = 5;
       /** @type {Array<{tcuTestCase.DeqpTest}>} */ var colorFormatGroup2D = [];
       for (var ii = 0; ii < splitStorage2D; ++ii) {
           colorFormatGroup2D.push(
               new tcuTestCase.DeqpTest('texstorage2d.format', 'glTexStorage2D() with all formats')
           );
           this.addChild(colorFormatGroup2D[ii]);
       }
       /** @type {Array<{tcuTestCase.DeqpTest}>} */ var colorFormatGroupCube = [];
       for (var ii = 0; ii < splitStorageCube; ++ii) {
           colorFormatGroupCube.push(
               new tcuTestCase.DeqpTest('texstorage2d.format', 'glTexStorage2D() with all formats')
           );
           this.addChild(colorFormatGroupCube[ii]);
       }

       for (var formatNdx = 0; formatNdx < colorFormats.length; formatNdx++) {
           fmtName = colorFormats[formatNdx].name;
           /** @type {number} */ var internalFormat = colorFormats[formatNdx].internalFormat;
           var tex2DWidth = 117;
           var tex2DHeight = 97;
           var tex2DLevels = es3fTextureSpecificationTests.maxLevelCount(tex2DWidth, tex2DHeight);
           /** @type {number} */ var cubeSize = 57;
           /** @type {number} */
           var cubeLevels = es3fTextureSpecificationTests.maxLevelCount(
               cubeSize, cubeSize
           );

           colorFormatGroup2D[formatNdx % splitStorage2D].addChild(
               new es3fTextureSpecificationTests.BasicTexStorage2DCase(
                   fmtName + '_2d', '', internalFormat,
                   tex2DWidth, tex2DHeight, tex2DLevels
               )
           );
           colorFormatGroupCube[formatNdx % splitStorageCube].addChild(
               new es3fTextureSpecificationTests.BasicTexStorageCubeCase(
                   fmtName + '_cube', '', internalFormat, cubeSize, cubeLevels
               )
           );
       }

       // Depth / stencil formats.
       /** @type {tcuTestCase.DeqpTest} */
       var storageGroup = new tcuTestCase.DeqpTest(
           'texstorage2d.format',
           'glTexStorage2D() with all formats'
       );
       this.addChild(storageGroup);

       for (var formatNdx = 0; formatNdx < depthStencilFormats.length; formatNdx++) {
           fmtName = depthStencilFormats[formatNdx].name;
           internalFormat = depthStencilFormats[formatNdx].internalFormat;
           // WebGL 2 specific constraint.
           if (internalFormat == gl.DEPTH32F_STENCIL8)
               continue;

           tex2DWidth = 117;
           tex2DHeight = 97;
           tex2DLevels = es3fTextureSpecificationTests.maxLevelCount(
               tex2DWidth, tex2DHeight
           );
           cubeSize = 57;
           cubeLevels = es3fTextureSpecificationTests.maxLevelCount(
               cubeSize, cubeSize
           );

           storageGroup.addChild(
               new es3fTextureSpecificationTests.BasicTexStorage2DCase(
                   fmtName + '_2d', '', internalFormat,
                   tex2DWidth, tex2DHeight, tex2DLevels
               )
           );
           storageGroup.addChild(
               new es3fTextureSpecificationTests.BasicTexStorageCubeCase(
                   fmtName + '_cube', '', internalFormat, cubeSize, cubeLevels
               )
           );
       }

       // Sizes.
       storageGroup = new tcuTestCase.DeqpTest(
           'texstorage2d.size',
           'glTexStorage2D() with various sizes'
       );
       this.addChild(storageGroup);

       //    W H L
       /** @type {Array<{width: number, height: number, levels: number}>} */
       var tex2DSizes = [{
               width: 1, height: 1, levels: 1
           }, {
               width: 2, height: 2, levels: 2
           }, {
               width: 64, height: 32, levels: 7
           }, {
               width: 32, height: 64, levels: 4
           }, {
               width: 57, height: 63, levels: 1
           }, {
               width: 57, height: 63, levels: 2
           }, {
               width: 57, height: 63, levels: 6
           }
       ];

       //    S L
       /** @type {Array<{sizes: number, levels: number}>} */
       var cubeSizes = [{
               sizes: 1, levels: 1
           }, {
               sizes: 2, levels: 2
           }, {
               sizes: 57, levels: 1
           }, {
               sizes: 57, levels: 2
           }, {
               sizes: 57, levels: 6
           }, {
               sizes: 64, levels: 4
           }, {
               sizes: 64, levels: 7
           }
       ];

       for (var ndx = 0; ndx < tex2DSizes.length; ndx++) {
           format = gl.RGBA8;
           /** @type {number} */ var width = tex2DSizes[ndx].width;
           /** @type {number} */ var height = tex2DSizes[ndx].height;
           /** @type {number} */ var levels = tex2DSizes[ndx].levels;
           /** @type {string} */
           var name = '2d_' + width + 'x' + height + '_' + levels + '_levels';

           storageGroup.addChild(
               new es3fTextureSpecificationTests.BasicTexStorage2DCase(
                   name, '', format, width, height, levels
               )
           );
       }

       for (var ndx = 0; ndx < cubeSizes.length; ndx++) {
           format = gl.RGBA8;
           size = cubeSizes[ndx].sizes;
           levels = cubeSizes[ndx].levels;
           name = 'cube_' + size + 'x' + size + '_' + levels + '_levels';

           storageGroup.addChild(
               new es3fTextureSpecificationTests.BasicTexStorageCubeCase(
                   name, '', format, size, levels
               )
           );
       }

       // glTexStorage3D() cases.

       // Color formats.
       var splitStorage2DArray = 3, splitStorage3D = 4;
       /** @type {Array<{tcuTestCase.DeqpTest}>} */ var colorFormatGroup2DArray = [];
       for (var ii = 0; ii < splitStorage2DArray; ++ii) {
           colorFormatGroup2DArray.push(
               new tcuTestCase.DeqpTest('texstorage3d.format', 'glTexStorage3D() with all formats')
           );
           this.addChild(colorFormatGroup2DArray[ii]);
       }
       /** @type {Array<{tcuTestCase.DeqpTest}>} */ var colorFormatGroup3D = [];
       for (var ii = 0; ii < splitStorage3D; ++ii) {
           colorFormatGroup3D.push(
               new tcuTestCase.DeqpTest('texstorage3d.format', 'glTexStorage3D() with all formats')
           );
           this.addChild(colorFormatGroup3D[ii]);
       }

       // Color formats.
       for (var formatNdx = 0; formatNdx < colorFormats.length; formatNdx++) {
           fmtName = colorFormats[formatNdx].name;
           internalFormat = colorFormats[formatNdx].internalFormat;
           tex2DArrayWidth = 57;
           tex2DArrayHeight = 13;
           var tex2DArrayLayers = 7;
           tex2DArrayLevels = es3fTextureSpecificationTests.maxLevelCount(
               tex2DArrayWidth, tex2DArrayHeight
           );
           tex3DWidth = 59;
           tex3DHeight = 37;
           tex3DDepth = 11;
           var tex3DLevels = es3fTextureSpecificationTests.maxLevelCount(
               tex3DWidth, tex3DHeight, tex3DDepth
           );

           colorFormatGroup2DArray[formatNdx % splitStorage2DArray].addChild(
               new es3fTextureSpecificationTests.BasicTexStorage2DArrayCase(
                   fmtName + '_2d_array', '', internalFormat, tex2DArrayWidth,
                   tex2DArrayHeight, tex2DArrayLayers, tex2DArrayLevels
               )
           );
           colorFormatGroup3D[formatNdx % splitStorage3D].addChild(
               new es3fTextureSpecificationTests.BasicTexStorage3DCase(
                   fmtName + '_3d', '', internalFormat, tex3DWidth,
                   tex3DHeight, tex3DDepth, tex3DLevels
               )
           );
       }

       storageGroup = new tcuTestCase.DeqpTest(
           'texstorage3d.format',
           'glTexStorage3D() with all formats'
       );
       this.addChild(storageGroup);

       // Depth/stencil formats (only 2D texture array is supported).
       for (var formatNdx = 0;
           formatNdx < depthStencilFormats.length;
           formatNdx++) {
           fmtName = depthStencilFormats[formatNdx].name;
           internalFormat = depthStencilFormats[formatNdx].internalFormat;
           // WebGL 2 specific constraint.
           if (internalFormat == gl.DEPTH32F_STENCIL8)
               continue;

           tex2DArrayWidth = 57;
           tex2DArrayHeight = 13;
           tex2DArrayLayers = 7;
           tex2DArrayLevels = es3fTextureSpecificationTests.maxLevelCount(
               tex2DArrayWidth, tex2DArrayHeight
           );

           storageGroup.addChild(
               new es3fTextureSpecificationTests.BasicTexStorage2DArrayCase(
                   fmtName + '_2d_array', '', internalFormat, tex2DArrayWidth,
                   tex2DArrayHeight, tex2DArrayLayers, tex2DArrayLevels
               )
           );
       }

       // Sizes.
       //    W H La Le
       /**
        * @type {Array<{width: number, height: number,
        * layers: number, levels: number}>}
        */
       var tex2DArraySizes = [{
               width: 1, height: 1, layers: 1, levels: 1
           }, {
               width: 2, height: 2, layers: 2, levels: 2
           }, {
               width: 64, height: 32, layers: 3, levels: 7
           }, {
               width: 32, height: 64, layers: 3, levels: 4
           }, {
               width: 57, height: 63, layers: 5, levels: 1
           }, {
               width: 57, height: 63, layers: 5, levels: 2
           }, {
               width: 57, height: 63, layers: 5, levels: 6
           }
       ];

       //    W H D L
       /**
        * @type {Array<{width: number, height: number,
        * depth: number, levels: number}>}
        */
       var tex3DSizes = [{
               width: 1, height: 1, depth: 1, levels: 1
           }, {
               width: 2, height: 2, depth: 2, levels: 2
           }, {
               width: 64, height: 32, depth: 16, levels: 7
           }, {
               width: 32, height: 64, depth: 16, levels: 4
           }, {
               width: 32, height: 16, depth: 64, levels: 4
           }, {
               width: 57, height: 63, depth: 11, levels: 1
           }, {
               width: 57, height: 63, depth: 11, levels: 2
           }, {
               width: 57, height: 63, depth: 11, levels: 6
           }
       ];

       storageGroup = new tcuTestCase.DeqpTest(
           'texstorage3d.size', 'glTexStorage3D() with various sizes'
       );
       this.addChild(storageGroup);

       for (var ndx = 0; ndx < tex2DArraySizes.length; ndx++) {
           format = gl.RGBA8;
           width = tex2DArraySizes[ndx].width;
           height = tex2DArraySizes[ndx].height;
           /** @type {number} */ var layers = tex2DArraySizes[ndx].layers;
           levels = tex2DArraySizes[ndx].levels;
           name = '2d_array_' + width + 'x' + height + 'x' +
               layers + '_' + levels + '_levels';

           storageGroup.addChild(
               new es3fTextureSpecificationTests.BasicTexStorage2DArrayCase(
                   name, '', format, width, height, layers, levels
               )
           );
       }

       for (var ndx = 0; ndx < tex3DSizes.length; ndx++) {
           format = gl.RGBA8;
           width = tex3DSizes[ndx].width;
           height = tex3DSizes[ndx].height;
           var depth = tex3DSizes[ndx].depth;
           levels = tex3DSizes[ndx].levels;
           name = '3d_' + width + 'x' + height + 'x' +
               depth + '_' + levels + '_levels';

           storageGroup.addChild(
               new es3fTextureSpecificationTests.BasicTexStorage3DCase(
                   name, '', format, width, height, depth, levels
               )
           );
       }
   };

   /**
   * Run test
   * @param {WebGL2RenderingContext} context
   * @param {Array<number>=} range Test range
   */
   es3fTextureSpecificationTests.run = function(context, range) {
       gl = context;
       //Set up Test Root parameters
       var state = tcuTestCase.runner;
       state.setRoot(new es3fTextureSpecificationTests.TextureSpecificationTests());
       if (range)
           state.setRange(range);

       //Set up name and description of this test series.
       setCurrentTestName(state.testCases.fullName());
       description(state.testCases.getDescription());

       try {
           //Run test cases
           tcuTestCase.runTestCases();
       }
       catch (err) {
           testFailedOptions('Failed to es3fTextureSpecificationTests.run tests', false);
           tcuTestCase.runner.terminate();
       }
   };

});