Source code
Revision control
Copy as Markdown
Other Tools
/*-------------------------------------------------------------------------
* 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
*
*
* 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.es3fBufferCopyTests');
goog.require('framework.common.tcuTestCase');
goog.require('framework.delibs.debase.deMath');
goog.require('framework.delibs.debase.deRandom');
goog.require('framework.delibs.debase.deString');
goog.require('modules.shared.glsBufferTestUtil');
goog.scope(function() {
var es3fBufferCopyTests = functional.gles3.es3fBufferCopyTests;
var glsBufferTestUtil = modules.shared.glsBufferTestUtil;
var tcuTestCase = framework.common.tcuTestCase;
var deMath = framework.delibs.debase.deMath;
var deString = framework.delibs.debase.deString;
var deRandom = framework.delibs.debase.deRandom;
/** @type {WebGL2RenderingContext} */ var gl;
/**
* @constructor
* @extends {glsBufferTestUtil.BufferCase}
* @param {string} name
* @param {string} desc
* @param {number} srcTarget
* @param {number} srcSize
* @param {number} srcHint
* @param {number} dstTarget
* @param {number} dstSize
* @param {number} dstHint
* @param {number} copySrcOffset
* @param {number} copyDstOffset
* @param {number} copySize
* @param {glsBufferTestUtil.VerifyType} verifyType
*/
es3fBufferCopyTests.BasicBufferCopyCase = function(name, desc, srcTarget, srcSize, srcHint, dstTarget, dstSize, dstHint, copySrcOffset, copyDstOffset, copySize, verifyType) {
glsBufferTestUtil.BufferCase.call(this, name, desc);
this.m_srcTarget = srcTarget;
this.m_srcSize = srcSize;
this.m_srcHint = srcHint;
this.m_dstTarget = dstTarget;
this.m_dstSize = dstSize;
this.m_dstHint = dstHint;
this.m_copySrcOffset = copySrcOffset;
this.m_copyDstOffset = copyDstOffset;
this.m_copySize = copySize;
this.m_verifyType = verifyType;
assertMsgOptions(deMath.deInBounds32(this.m_copySrcOffset, 0, this.m_srcSize) && deMath.deInRange32(this.m_copySrcOffset + this.m_copySize, this.m_copySrcOffset, this.m_srcSize), 'Copy parameters are out of buffer\'s range', false, true);
assertMsgOptions(deMath.deInBounds32(this.m_copyDstOffset, 0, this.m_dstSize) && deMath.deInRange32(this.m_copyDstOffset + this.m_copySize, this.m_copyDstOffset, this.m_dstSize), 'Copy parameters are out of buffer\'s range', false, true);
};
es3fBufferCopyTests.BasicBufferCopyCase.prototype = Object.create(glsBufferTestUtil.BufferCase.prototype);
es3fBufferCopyTests.BasicBufferCopyCase.prototype.constructor = es3fBufferCopyTests.BasicBufferCopyCase;
/**
* @return {tcuTestCase.IterateResult}
*/
es3fBufferCopyTests.BasicBufferCopyCase.prototype.iterate = function() {
/** @type {glsBufferTestUtil.BufferVerifier} */ var verifier = new glsBufferTestUtil.BufferVerifier(this.m_verifyType);
var srcRef = new glsBufferTestUtil.ReferenceBuffer();
var dstRef = new glsBufferTestUtil.ReferenceBuffer();
var srcBuf = 0;
var dstBuf = 0;
var srcSeed = deMath.binaryOp(deString.deStringHash(this.fullName()), 0xabcd, deMath.BinaryOp.XOR);
var dstSeed = deMath.binaryOp(deString.deStringHash(this.fullName()), 0xef01, deMath.BinaryOp.XOR);
var isOk = true;
srcRef.setSize(this.m_srcSize);
glsBufferTestUtil.fillWithRandomBytes(srcRef.getPtr(), this.m_srcSize, srcSeed);
dstRef.setSize(this.m_dstSize);
glsBufferTestUtil.fillWithRandomBytes(dstRef.getPtr(), this.m_dstSize, dstSeed);
// Create source buffer and fill with data.
srcBuf = this.genBuffer();
gl.bindBuffer(this.m_srcTarget, srcBuf);
gl.bufferData(this.m_srcTarget, srcRef.getPtr(), this.m_srcHint);
// Create destination buffer and fill with data.
dstBuf = this.genBuffer();
gl.bindBuffer(this.m_dstTarget, dstBuf);
gl.bufferData(this.m_dstTarget, dstRef.getPtr(), this.m_dstHint);
// Verify both buffers before executing copy.
isOk = verifier.verify(srcBuf, srcRef.getPtr(), 0, this.m_srcSize, this.m_srcTarget) && isOk;
isOk = verifier.verify(dstBuf, dstRef.getPtr(), 0, this.m_dstSize, this.m_dstTarget) && isOk;
// Execute copy.
dstRef.getPtr().set(srcRef.getPtr().subarray(this.m_copySrcOffset, this.m_copySrcOffset + this.m_copySize), this.m_copyDstOffset);
gl.bindBuffer(this.m_srcTarget, srcBuf);
gl.bindBuffer(this.m_dstTarget, dstBuf);
gl.copyBufferSubData(this.m_srcTarget, this.m_dstTarget, this.m_copySrcOffset, this.m_copyDstOffset, this.m_copySize);
// Verify both buffers after copy.
isOk = verifier.verify(srcBuf, srcRef.getPtr(), 0, this.m_srcSize, this.m_srcTarget) && isOk;
isOk = verifier.verify(dstBuf, dstRef.getPtr(), 0, this.m_dstSize, this.m_dstTarget) && isOk;
if (isOk)
testPassed('');
else
testFailed('Buffer verification failed');
return tcuTestCase.IterateResult.STOP;
};
// Case B: same buffer, take range as parameter
/**
* @constructor
* @extends {glsBufferTestUtil.BufferCase}
* @param {string} name
* @param {string} desc
* @param {number} srcTarget
* @param {number} dstTarget
* @param {number} hint
* @param {glsBufferTestUtil.VerifyType} verifyType
*/
es3fBufferCopyTests.SingleBufferCopyCase = function(name, desc, srcTarget, dstTarget, hint, verifyType) {
glsBufferTestUtil.BufferCase.call(this, name, desc);
this.m_srcTarget = srcTarget;
this.m_dstTarget = dstTarget;
this.m_hint = hint;
this.m_verifyType = verifyType;
};
es3fBufferCopyTests.SingleBufferCopyCase.prototype = Object.create(glsBufferTestUtil.BufferCase.prototype);
es3fBufferCopyTests.SingleBufferCopyCase.prototype.constructor = es3fBufferCopyTests.SingleBufferCopyCase;
/**
* @return {tcuTestCase.IterateResult}
*/
es3fBufferCopyTests.SingleBufferCopyCase.prototype.iterate = function() {
var size = 1000;
/** @type {glsBufferTestUtil.BufferVerifier} */ var verifier = new glsBufferTestUtil.BufferVerifier(this.m_verifyType);
var ref = new glsBufferTestUtil.ReferenceBuffer();
var baseSeed = deString.deStringHash(this.fullName());
var isOk = true;
ref.setSize(size);
// Create buffer.
var buf = this.genBuffer();
gl.bindBuffer(this.m_srcTarget, buf);
/** @type {Array<{srcOffset: number, dstOffset: number, copySize: number}>} */
var copyRanges = [{
srcOffset: 57, dstOffset: 701, copySize: 101 // Non-adjecent, from low to high.
},{
srcOffset: 640, dstOffset: 101, copySize: 101 // Non-adjecent, from high to low.
},{
srcOffset: 0, dstOffset: 500, copySize: 500 // Lower half to upper half.
},{
srcOffset: 500, dstOffset: 0, copySize: 500 // Upper half to lower half.
}];
for (var ndx = 0; ndx < copyRanges.length && isOk; ndx++) {
var srcOffset = copyRanges[ndx].srcOffset;
var dstOffset = copyRanges[ndx].dstOffset;
var copySize = copyRanges[ndx].copySize;
glsBufferTestUtil.fillWithRandomBytes(ref.getPtr(), size, deMath.binaryOp(baseSeed, deMath.deMathHash(ndx), deMath.BinaryOp.XOR));
// Fill with data.
gl.bindBuffer(this.m_srcTarget, buf);
gl.bufferData(this.m_srcTarget, ref.getPtr(), this.m_hint);
// Execute copy.
ref.getPtr().set(ref.getPtr().subarray(srcOffset, srcOffset + copySize), dstOffset);
gl.bindBuffer(this.m_dstTarget, buf);
gl.copyBufferSubData(this.m_srcTarget, this.m_dstTarget, srcOffset, dstOffset, copySize);
// Verify buffer after copy.
isOk = verifier.verify(buf, ref.getPtr(), 0, size, this.m_dstTarget) && isOk;
}
if (isOk)
testPassed('');
else
testFailed('Buffer verification failed');
return tcuTestCase.IterateResult.STOP;
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
*/
es3fBufferCopyTests.BufferCopyTests = function() {
tcuTestCase.DeqpTest.call(this, 'copy', 'Buffer copy tests');
this.makeExecutable();
};
es3fBufferCopyTests.BufferCopyTests.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
es3fBufferCopyTests.BufferCopyTests.prototype.constructor = es3fBufferCopyTests.BufferCopyTests;
es3fBufferCopyTests.BufferCopyTests.prototype.init = function() {
/** @type {glsBufferTestUtil.VerifyType} */ var verify;
var bufferTargets = [
gl.ARRAY_BUFFER,
gl.COPY_READ_BUFFER,
gl.COPY_WRITE_BUFFER,
gl.ELEMENT_ARRAY_BUFFER,
gl.PIXEL_PACK_BUFFER,
gl.PIXEL_UNPACK_BUFFER,
gl.TRANSFORM_FEEDBACK_BUFFER,
gl.UNIFORM_BUFFER
];
// .basic
var basicGroup = new tcuTestCase.DeqpTest('basic', 'Basic buffer copy cases');
this.addChild(basicGroup);
for (var srcTargetNdx = 0; srcTargetNdx < bufferTargets.length; srcTargetNdx++) {
for (var dstTargetNdx = 0; dstTargetNdx < bufferTargets.length; dstTargetNdx++) {
if (srcTargetNdx == dstTargetNdx)
continue;
// In WebGL 2, a copy between an ELEMENT_ARRAY_BUFFER and other data buffer
// (not COPY_WRITE_BUFFER nor COPY_READ_BUFFER nor ELEMENT_ARRAY_BUFFER)
// cannot be made, so let's skip those cases.
if (bufferTargets[srcTargetNdx] == gl.ELEMENT_ARRAY_BUFFER ||
bufferTargets[dstTargetNdx] == gl.ELEMENT_ARRAY_BUFFER)
continue;
var srcTarget = bufferTargets[srcTargetNdx];
var dstTarget = bufferTargets[dstTargetNdx];
var size = 1017;
var hint = gl.STATIC_DRAW;
verify = glsBufferTestUtil.VerifyType.AS_VERTEX_ARRAY;
var name = glsBufferTestUtil.getBufferTargetName(srcTarget) + '_' + glsBufferTestUtil.getBufferTargetName(dstTarget);
basicGroup.addChild(new es3fBufferCopyTests.BasicBufferCopyCase(name, '', srcTarget, size, hint, dstTarget, size, hint, 0, 0, size, verify));
}
}
// .subrange
var subrangeGroup = new tcuTestCase.DeqpTest('subrange', 'Buffer subrange copy tests');
this.addChild(subrangeGroup);
/**
* @type {Array<{name: string, srcSize: number, dstSize: number, srcOffset: number, dstOffset: number, copySize: number}>}
*/
var cases = [{
name: 'middle', srcSize: 1000, dstSize: 1000, srcOffset: 250, dstOffset: 250, copySize: 500
},{
name: 'small_to_large', srcSize: 100, dstSize: 1000, srcOffset: 0, dstOffset: 409, copySize: 100
},{
name: 'large_to_small', srcSize: 1000, dstSize: 100, srcOffset: 409, dstOffset: 0, copySize: 100
},{
name: 'low_to_high_1', srcSize: 1000, dstSize: 1000, srcOffset: 0, dstOffset: 500, copySize: 500
},{
name: 'low_to_high_2', srcSize: 997, dstSize: 1027, srcOffset: 0, dstOffset: 701, copySize: 111
},{
name: 'high_to_low_1', srcSize: 1000, dstSize: 1000, srcOffset: 500, dstOffset: 0, copySize: 500
},{
name: 'high_to_low_2', srcSize: 1027, dstSize: 997, srcOffset: 701, dstOffset: 17, copySize: 111
}];
for (var ndx = 0; ndx < cases.length; ndx++) {
var srcTarget = gl.COPY_READ_BUFFER;
var dstTarget = gl.COPY_WRITE_BUFFER;
var hint = gl.STATIC_DRAW;
verify = glsBufferTestUtil.VerifyType.AS_VERTEX_ARRAY;
subrangeGroup.addChild(
new es3fBufferCopyTests.BasicBufferCopyCase(
cases[ndx].name, '',
srcTarget, cases[ndx].srcSize, hint,
dstTarget, cases[ndx].dstSize, hint,
cases[ndx].srcOffset, cases[ndx].dstOffset, cases[ndx].copySize,
verify
)
);
}
// .single_buffer
var singleBufGroup = new tcuTestCase.DeqpTest('single_buffer', 'Copies within single buffer');
this.addChild(singleBufGroup);
for (var srcTargetNdx = 0; srcTargetNdx < bufferTargets.length; srcTargetNdx++) {
for (var dstTargetNdx = 0; dstTargetNdx < bufferTargets.length; dstTargetNdx++) {
if (srcTargetNdx == dstTargetNdx)
continue;
// In WebGL 2, we can't rebind an ELEMENT_ARRAY_BUFFER or TRANSFORM_FEEDBACK_BUFFER as a
// different type of buffer, so we skip those cases.
if (bufferTargets[srcTargetNdx] == gl.ELEMENT_ARRAY_BUFFER || bufferTargets[srcTargetNdx] == gl.TRANSFORM_FEEDBACK_BUFFER ||
bufferTargets[dstTargetNdx] == gl.ELEMENT_ARRAY_BUFFER || bufferTargets[dstTargetNdx] == gl.TRANSFORM_FEEDBACK_BUFFER)
continue;
var srcTarget = bufferTargets[srcTargetNdx];
var dstTarget = bufferTargets[dstTargetNdx];
var hint = gl.STATIC_DRAW;
verify = glsBufferTestUtil.VerifyType.AS_VERTEX_ARRAY;
var name = glsBufferTestUtil.getBufferTargetName(srcTarget) + '_' + glsBufferTestUtil.getBufferTargetName(dstTarget);
singleBufGroup.addChild(new es3fBufferCopyTests.SingleBufferCopyCase(name, '', srcTarget, dstTarget, hint, verify));
}
}
};
/**
* Create and execute the test cases
* @param {WebGL2RenderingContext} context
*/
es3fBufferCopyTests.run = function(context) {
gl = context;
//Set up Test Root parameters
var state = tcuTestCase.runner;
state.setRoot(new es3fBufferCopyTests.BufferCopyTests());
//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 run tests', false);
tcuTestCase.runner.terminate();
}
};
});