mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
8eeed3c374
The 1.0.1 release is really close, and upgrading now allows us to give feedback and make sure that all tests are passable. The canonical URL for this test suite is https://cvs.khronos.org/svn/repos/registry/trunk/public/webgl/sdk/tests/webgl-conformance-tests.html --HG-- rename : content/canvas/test/webgl/conformance/include.vs => content/canvas/test/webgl/conformance/glsl/misc/include.vs
386 lines
11 KiB
JavaScript
386 lines
11 KiB
JavaScript
/*
|
|
Copyright (C) 2009 Apple Computer, Inc. All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
1. Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
|
|
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
|
|
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
|
OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
// WebKit Specfic code. Add your own here.
|
|
function initNonKhronosFramework(waitUntilDone) {
|
|
if (window.layoutTestController) {
|
|
layoutTestController.overridePreference("WebKitWebGLEnabled", "1");
|
|
layoutTestController.dumpAsText();
|
|
if (waitUntilDone) {
|
|
layoutTestController.waitUntilDone();
|
|
}
|
|
}
|
|
}
|
|
|
|
function nonKhronosFrameworkNotifyDone() {
|
|
if (window.layoutTestController) {
|
|
layoutTestController.notifyDone();
|
|
}
|
|
}
|
|
|
|
function reportTestResultsToHarness(success, msg) {
|
|
if (window.parent.webglTestHarness) {
|
|
window.parent.webglTestHarness.reportResults(success, msg);
|
|
}
|
|
}
|
|
|
|
function notifyFinishedToHarness() {
|
|
if (window.parent.webglTestHarness) {
|
|
window.parent.webglTestHarness.notifyFinished();
|
|
}
|
|
}
|
|
|
|
function description(msg)
|
|
{
|
|
// For MSIE 6 compatibility
|
|
var span = document.createElement("span");
|
|
span.innerHTML = '<p>' + msg + '</p><p>On success, you will see a series of "<span class="pass">PASS</span>" messages, followed by "<span class="pass">TEST COMPLETE</span>".</p>';
|
|
var description = document.getElementById("description");
|
|
if (description.firstChild)
|
|
description.replaceChild(span, description.firstChild);
|
|
else
|
|
description.appendChild(span);
|
|
}
|
|
|
|
function debug(msg)
|
|
{
|
|
var span = document.createElement("span");
|
|
document.getElementById("console").appendChild(span); // insert it first so XHTML knows the namespace
|
|
span.innerHTML = msg + '<br />';
|
|
}
|
|
|
|
function escapeHTML(text)
|
|
{
|
|
return text.replace(/&/g, "&").replace(/</g, "<");
|
|
}
|
|
|
|
function testPassed(msg)
|
|
{
|
|
reportTestResultsToHarness(true, msg);
|
|
debug('<span><span class="pass">PASS</span> ' + escapeHTML(msg) + '</span>');
|
|
}
|
|
|
|
function testFailed(msg)
|
|
{
|
|
reportTestResultsToHarness(false, msg);
|
|
debug('<span><span class="fail">FAIL</span> ' + escapeHTML(msg) + '</span>');
|
|
}
|
|
|
|
function areArraysEqual(_a, _b)
|
|
{
|
|
try {
|
|
if (_a.length !== _b.length)
|
|
return false;
|
|
for (var i = 0; i < _a.length; i++)
|
|
if (_a[i] !== _b[i])
|
|
return false;
|
|
} catch (ex) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function isMinusZero(n)
|
|
{
|
|
// the only way to tell 0 from -0 in JS is the fact that 1/-0 is
|
|
// -Infinity instead of Infinity
|
|
return n === 0 && 1/n < 0;
|
|
}
|
|
|
|
function isResultCorrect(_actual, _expected)
|
|
{
|
|
if (_expected === 0)
|
|
return _actual === _expected && (1/_actual) === (1/_expected);
|
|
if (_actual === _expected)
|
|
return true;
|
|
if (typeof(_expected) == "number" && isNaN(_expected))
|
|
return typeof(_actual) == "number" && isNaN(_actual);
|
|
if (Object.prototype.toString.call(_expected) == Object.prototype.toString.call([]))
|
|
return areArraysEqual(_actual, _expected);
|
|
return false;
|
|
}
|
|
|
|
function stringify(v)
|
|
{
|
|
if (v === 0 && 1/v < 0)
|
|
return "-0";
|
|
else return "" + v;
|
|
}
|
|
|
|
function evalAndLog(_a)
|
|
{
|
|
if (typeof _a != "string")
|
|
debug("WARN: tryAndLog() expects a string argument");
|
|
|
|
// Log first in case things go horribly wrong or this causes a sync event.
|
|
debug(_a);
|
|
|
|
var _av;
|
|
try {
|
|
_av = eval(_a);
|
|
} catch (e) {
|
|
testFailed(_a + " threw exception " + e);
|
|
}
|
|
return _av;
|
|
}
|
|
|
|
function shouldBe(_a, _b)
|
|
{
|
|
if (typeof _a != "string" || typeof _b != "string")
|
|
debug("WARN: shouldBe() expects string arguments");
|
|
var exception;
|
|
var _av;
|
|
try {
|
|
_av = eval(_a);
|
|
} catch (e) {
|
|
exception = e;
|
|
}
|
|
var _bv = eval(_b);
|
|
|
|
if (exception)
|
|
testFailed(_a + " should be " + _bv + ". Threw exception " + exception);
|
|
else if (isResultCorrect(_av, _bv))
|
|
testPassed(_a + " is " + _b);
|
|
else if (typeof(_av) == typeof(_bv))
|
|
testFailed(_a + " should be " + _bv + ". Was " + stringify(_av) + ".");
|
|
else
|
|
testFailed(_a + " should be " + _bv + " (of type " + typeof _bv + "). Was " + _av + " (of type " + typeof _av + ").");
|
|
}
|
|
|
|
function shouldBeTrue(_a) { shouldBe(_a, "true"); }
|
|
function shouldBeFalse(_a) { shouldBe(_a, "false"); }
|
|
function shouldBeNaN(_a) { shouldBe(_a, "NaN"); }
|
|
function shouldBeNull(_a) { shouldBe(_a, "null"); }
|
|
|
|
function shouldBeEqualToString(a, b)
|
|
{
|
|
var unevaledString = '"' + b.replace(/"/g, "\"") + '"';
|
|
shouldBe(a, unevaledString);
|
|
}
|
|
|
|
function shouldEvaluateTo(actual, expected) {
|
|
// A general-purpose comparator. 'actual' should be a string to be
|
|
// evaluated, as for shouldBe(). 'expected' may be any type and will be
|
|
// used without being eval'ed.
|
|
if (expected == null) {
|
|
// Do this before the object test, since null is of type 'object'.
|
|
shouldBeNull(actual);
|
|
} else if (typeof expected == "undefined") {
|
|
shouldBeUndefined(actual);
|
|
} else if (typeof expected == "function") {
|
|
// All this fuss is to avoid the string-arg warning from shouldBe().
|
|
try {
|
|
actualValue = eval(actual);
|
|
} catch (e) {
|
|
testFailed("Evaluating " + actual + ": Threw exception " + e);
|
|
return;
|
|
}
|
|
shouldBe("'" + actualValue.toString().replace(/\n/g, "") + "'",
|
|
"'" + expected.toString().replace(/\n/g, "") + "'");
|
|
} else if (typeof expected == "object") {
|
|
shouldBeTrue(actual + " == '" + expected + "'");
|
|
} else if (typeof expected == "string") {
|
|
shouldBe(actual, expected);
|
|
} else if (typeof expected == "boolean") {
|
|
shouldBe("typeof " + actual, "'boolean'");
|
|
if (expected)
|
|
shouldBeTrue(actual);
|
|
else
|
|
shouldBeFalse(actual);
|
|
} else if (typeof expected == "number") {
|
|
shouldBe(actual, stringify(expected));
|
|
} else {
|
|
debug(expected + " is unknown type " + typeof expected);
|
|
shouldBeTrue(actual, "'" +expected.toString() + "'");
|
|
}
|
|
}
|
|
|
|
function shouldBeNonZero(_a)
|
|
{
|
|
var exception;
|
|
var _av;
|
|
try {
|
|
_av = eval(_a);
|
|
} catch (e) {
|
|
exception = e;
|
|
}
|
|
|
|
if (exception)
|
|
testFailed(_a + " should be non-zero. Threw exception " + exception);
|
|
else if (_av != 0)
|
|
testPassed(_a + " is non-zero.");
|
|
else
|
|
testFailed(_a + " should be non-zero. Was " + _av);
|
|
}
|
|
|
|
function shouldBeNonNull(_a)
|
|
{
|
|
var exception;
|
|
var _av;
|
|
try {
|
|
_av = eval(_a);
|
|
} catch (e) {
|
|
exception = e;
|
|
}
|
|
|
|
if (exception)
|
|
testFailed(_a + " should be non-null. Threw exception " + exception);
|
|
else if (_av != null)
|
|
testPassed(_a + " is non-null.");
|
|
else
|
|
testFailed(_a + " should be non-null. Was " + _av);
|
|
}
|
|
|
|
function shouldBeUndefined(_a)
|
|
{
|
|
var exception;
|
|
var _av;
|
|
try {
|
|
_av = eval(_a);
|
|
} catch (e) {
|
|
exception = e;
|
|
}
|
|
|
|
if (exception)
|
|
testFailed(_a + " should be undefined. Threw exception " + exception);
|
|
else if (typeof _av == "undefined")
|
|
testPassed(_a + " is undefined.");
|
|
else
|
|
testFailed(_a + " should be undefined. Was " + _av);
|
|
}
|
|
|
|
function shouldBeDefined(_a)
|
|
{
|
|
var exception;
|
|
var _av;
|
|
try {
|
|
_av = eval(_a);
|
|
} catch (e) {
|
|
exception = e;
|
|
}
|
|
|
|
if (exception)
|
|
testFailed(_a + " should be defined. Threw exception " + exception);
|
|
else if (_av !== undefined)
|
|
testPassed(_a + " is defined.");
|
|
else
|
|
testFailed(_a + " should be defined. Was " + _av);
|
|
}
|
|
|
|
function shouldBeGreaterThanOrEqual(_a, _b) {
|
|
if (typeof _a != "string" || typeof _b != "string")
|
|
debug("WARN: shouldBeGreaterThanOrEqual expects string arguments");
|
|
|
|
var exception;
|
|
var _av;
|
|
try {
|
|
_av = eval(_a);
|
|
} catch (e) {
|
|
exception = e;
|
|
}
|
|
var _bv = eval(_b);
|
|
|
|
if (exception)
|
|
testFailed(_a + " should be >= " + _b + ". Threw exception " + exception);
|
|
else if (typeof _av == "undefined" || _av < _bv)
|
|
testFailed(_a + " should be >= " + _b + ". Was " + _av + " (of type " + typeof _av + ").");
|
|
else
|
|
testPassed(_a + " is >= " + _b);
|
|
}
|
|
|
|
function shouldThrow(_a, _e)
|
|
{
|
|
var exception;
|
|
var _av;
|
|
try {
|
|
_av = eval(_a);
|
|
} catch (e) {
|
|
exception = e;
|
|
}
|
|
|
|
var _ev;
|
|
if (_e)
|
|
_ev = eval(_e);
|
|
|
|
if (exception) {
|
|
if (typeof _e == "undefined" || exception == _ev)
|
|
testPassed(_a + " threw exception " + exception + ".");
|
|
else
|
|
testFailed(_a + " should throw " + (typeof _e == "undefined" ? "an exception" : _ev) + ". Threw exception " + exception + ".");
|
|
} else if (typeof _av == "undefined")
|
|
testFailed(_a + " should throw " + (typeof _e == "undefined" ? "an exception" : _ev) + ". Was undefined.");
|
|
else
|
|
testFailed(_a + " should throw " + (typeof _e == "undefined" ? "an exception" : _ev) + ". Was " + _av + ".");
|
|
}
|
|
|
|
function assertMsg(assertion, msg) {
|
|
if (assertion) {
|
|
testPassed(msg);
|
|
} else {
|
|
testFailed(msg);
|
|
}
|
|
}
|
|
|
|
function gc() {
|
|
if (typeof GCController !== "undefined")
|
|
GCController.collect();
|
|
else {
|
|
function gcRec(n) {
|
|
if (n < 1)
|
|
return {};
|
|
var temp = {i: "ab" + i + (i / 100000)};
|
|
temp += "foo";
|
|
gcRec(n-1);
|
|
}
|
|
for (var i = 0; i < 1000; i++)
|
|
gcRec(10)
|
|
}
|
|
}
|
|
|
|
function finishTest() {
|
|
successfullyParsed = true;
|
|
var epilogue = document.createElement("script");
|
|
epilogue.onload = function() {
|
|
if (window.nonKhronosFrameworkNotifyDone) {
|
|
window.nonKhronosFrameworkNotifyDone();
|
|
}
|
|
};
|
|
|
|
var basePath = "";
|
|
var expectedBase = "js-test-pre.js";
|
|
var scripts = document.getElementsByTagName('script');
|
|
for (var script, i = 0; script = scripts[i]; i++) {
|
|
var src = script.src;
|
|
var l = src.length;
|
|
if (src.substr(l - expectedBase.length) == expectedBase) {
|
|
basePath = src.substr(0, l - expectedBase.length);
|
|
break;
|
|
}
|
|
}
|
|
epilogue.src = basePath + "js-test-post.js";
|
|
document.body.appendChild(epilogue);
|
|
}
|
|
|