summaryrefslogtreecommitdiffstats
path: root/dom/canvas/test/webgl-conf/checkout/webgl-conformance-tests.html
diff options
context:
space:
mode:
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/webgl-conformance-tests.html')
-rw-r--r--dom/canvas/test/webgl-conf/checkout/webgl-conformance-tests.html1305
1 files changed, 1305 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/webgl-conformance-tests.html b/dom/canvas/test/webgl-conf/checkout/webgl-conformance-tests.html
new file mode 100644
index 0000000000..462659227e
--- /dev/null
+++ b/dom/canvas/test/webgl-conf/checkout/webgl-conformance-tests.html
@@ -0,0 +1,1305 @@
+<!--
+Copyright (c) 2019 The Khronos Group Inc.
+Use of this source code is governed by an MIT-style license that can be
+found in the LICENSE.txt file.
+-->
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<!-- Prevents Chrome from offering to translate tests which generate
+ random characters for things like attribute names -->
+<meta name="google" value="notranslate">
+<meta name="viewport" content="width=device-width">
+<title>WebGL Conformance Tests</title>
+<style>
+ * {
+ box-sizing: border-box;
+ }
+
+ body {
+ border: 0;
+ margin: 0;
+ padding: 0;
+ height: 100%;
+ max-height:100%;
+ font-family: Verdana, Arial, sans-serif;
+ font-size: 0.8em;
+ }
+
+ input[type=button], select {
+ padding: 2px 6px 2px 6px;
+ margin: 0;
+ border: 1px solid #888;
+ border-radius: 2px;
+ background: #f4f4f4;
+ }
+
+ a {
+ color: #88F;
+ text-decoration: none;
+ }
+
+ a:hover {
+ border-bottom: 1px solid #66D;
+ }
+
+ label {
+ white-space: nowrap;
+ }
+
+ #testlist {
+ position:fixed;
+ top:180px;
+ left:0;
+ right: calc(10% + 50px);
+ bottom:0px;
+ overflow:auto;
+ min-height: 200px;
+ }
+
+ @media screen and (max-width: 500px) {
+ #testlist {
+ font-size: 80%;
+ }
+ }
+
+ #header {
+ position:absolute;
+ top:0;
+ left:0;
+ width:100%;
+ height: 160px;
+ overflow: scroll;
+ border-bottom: 1px solid #CCC;
+ }
+
+ #info {
+ margin: 0 auto;
+ max-width: 280px;
+ }
+ #logo {
+ width: 68px;
+ height: 40px;
+ }
+
+ #iframe-container {
+ color: white;
+ display: block;
+ position: fixed;
+ width: 90%;
+ height: calc(100% - 170px);
+ bottom: 0px;
+ left: calc(90% - 50px);
+ transition: left 0.15s;
+ }
+ #iframe-container.iframe-shown {
+ left: 10%;
+ }
+ #iframe-toggle {
+ display: inline-block;
+ vertical-align: middle;
+ width: 20px;
+ height: 100%;
+ padding: 0;
+ -webkit-appearance: none;
+ }
+ #test-iframe {
+ display: inline-block;
+ vertical-align: middle;
+ background: white;
+ width: calc(100% - 20px);
+ height: 100%;
+ border: 1px solid black;
+ }
+
+ .folder {
+ margin-bottom: 1.5em;
+ }
+
+ .folderHeader {
+ white-space: nowrap;
+ position: sticky;
+ top: 0;
+ }
+ .folderHeaderInner {
+ background: white;
+ /* to hide checkboxes from parent headers */
+ position: relative;
+ left: -2em;
+ padding-left: 2em;
+ }
+
+ .folderName {
+ font-weight: bold;
+ }
+
+ .folderMessage {
+ margin-left: 1em;
+ font-size: 0.9em;
+ }
+
+ .pageHeader {
+ white-space: nowrap;
+ }
+
+ .testpage {
+ border-style: solid;
+ border-color: #CCC;
+ border-width: 0px 0 1px 0;
+ background-color: #FFF;
+ padding: 4px 0 4px 0;
+
+ -webkit-transition: background-color 0.25s;
+ -moz-transition: background-color 0.25s;
+ transition: background-color 0.25s;
+ }
+
+ .testpage:first-child {
+ border-width: 1px 0 1px 0;
+ }
+
+ .timeout { }
+ .success { }
+ .fail { }
+ .testpagesuccess { background-color: #8F8; }
+ .testpagefail { background-color: #F88; }
+ .testpageskipped { background-color: #888; }
+ .testpagetimeout { background-color: #FC8; }
+ .nowebgl { font-weight: bold; color: red; }
+ #error-wrap {
+ float: left;
+ position: relative;
+ left: 50%;
+ }
+ #error {
+ color: red;
+ float: left;
+ position: relative;
+ left: -50%;
+ text-align: left;
+ }
+ ul {
+ list-style: none;
+ padding-left: 1em;
+ }
+</style>
+<script type="application/javascript" src="js/webgl-test-harness.js"></script>
+<script>
+"use strict";
+
+window.onbeforeunload = function() {
+ // Prompt user before reloading
+ return false;
+}
+
+var DEFAULT_CONFORMANCE_TEST_VERSION = "2.0.1 (beta)";
+
+var OPTIONS = {
+ version: DEFAULT_CONFORMANCE_TEST_VERSION,
+ frames: 1,
+ allowSkip: 0,
+ root: null,
+ quiet: 0
+};
+
+var testVersions = [
+ "1.0.4 (beta)",
+ "2.0.1 (beta)"
+];
+
+function start() {
+
+ function log(msg) {
+ if (window.console && window.console.log) {
+ window.console.log(msg);
+ }
+ }
+
+ function createStylesheet() {
+ var style = document.createElement("style");
+ style.appendChild(document.createTextNode(""));
+ document.head.appendChild(style);
+ return style.sheet;
+ }
+
+ function create3DContext(canvas, attrs, version) {
+ if (!canvas) {
+ canvas = document.createElement("canvas");
+ }
+ var context = null;
+ var names;
+ switch (version) {
+ case 2:
+ names = ["webgl2"]; break;
+ default:
+ names = ["webgl", "experimental-webgl"]; break;
+ }
+ for (var i = 0; i < names.length; ++i) {
+ try {
+ context = canvas.getContext(names[i], attrs);
+ } catch (e) {
+ }
+ if (context) {
+ break;
+ }
+ }
+ return context;
+ }
+
+ var reportType = WebGLTestHarnessModule.TestHarness.reportType;
+ var pageCount = 0;
+ var folderCount = 0;
+ var autoScrollEnabled = true; // Whether the user prefers to auto scroll
+ var autoScroll = true; // Whether auto scroll is actually performed
+ let quickTestMode = true;
+
+ var Page = function(reporter, folder, testIndex, url) {
+ this.reporter = reporter;
+ this.folder = folder;
+ this.url = url;
+ this.totalTests = 0;
+ this.totalSuccessful = 0;
+ this.totalTimeouts = 0;
+ this.totalSkipped = 0;
+ this.totalFailed = 0;
+ this.testIndex = testIndex;
+ this.startTime = new Date();
+ this.totalTime = 0;
+ var that = this;
+
+ this.elementId = "page" + pageCount++;
+ var li = reporter.localDoc.createElement('li');
+ li.id = this.elementId;
+ var div = reporter.localDoc.createElement('div');
+ div.classList.add('pageHeader');
+ var check = reporter.localDoc.createElement('input');
+ check.type = 'checkbox';
+ check.checked = true;
+ check.onclick = function() {
+ if (this.checked) {
+ that.folder.enableUp_();
+ }
+ else {
+ that.folder.disableUp_();
+ }
+ };
+ div.appendChild(check);
+ var button = reporter.localDoc.createElement('input');
+ button.type = 'button';
+ button.id = this.elementId + "-button";
+ button.value = 'run';
+ button.onclick = function() {
+ autoScroll = false;
+ reporter.runTest(url);
+ };
+ if (reporter.noSelectedWebGLVersion) {
+ button.disabled = true;
+ }
+ div.appendChild(button);
+ var a = reporter.localDoc.createElement('a');
+ a.href = WebGLTestHarnessModule.getURLWithOptions(url, {
+ webglVersion: reporter.selectedWebGLVersion,
+ quiet: OPTIONS.quiet,
+ quick: quickTestMode ? 1 : 0,
+ });
+ a.target = "_blank";
+ const folderName = that.folder.displayName;
+ console.assert(folderName.startsWith("all/"));
+ console.assert(url.startsWith(folderName.substring(4) + "/"));
+ const urlWithoutFolder = url.substring(folderName.length - 4 + 1);
+ var node = reporter.localDoc.createTextNode(urlWithoutFolder);
+ a.appendChild(node);
+ div.appendChild(a);
+ li.setAttribute('class', 'testpage');
+ li.appendChild(div);
+ var ul = reporter.localDoc.createElement('ul');
+ var node = reporter.localDoc.createTextNode('');
+ li.appendChild(ul);
+ div.appendChild(node);
+ this.totalsElem = node;
+ this.resultElem = ul;
+ this.elem = li;
+ this.check = check;
+ };
+
+ Page.prototype.checked = function() {
+ return this.check.checked;
+ }
+
+ Page.prototype.addResult = function(msg, success, skipped) {
+ ++this.totalTests;
+ if (success === undefined) {
+ ++this.totalTimeouts;
+ var result = "timeout";
+ var css = "timeout";
+ } else if (success) {
+ ++this.totalSuccessful;
+ // don't report success.
+ return;
+ } else {
+ ++this.totalFailed;
+ if (skipped) {
+ // Skipped tests are counted as both skips and failures (because we
+ // don't want to accidentally accept a conformance submission with
+ // skipped tests).
+ ++this.totalSkipped;
+ }
+ var result = "failed";
+ var css = "fail";
+ }
+
+ var node = this.reporter.localDoc.createTextNode(result + ': ' + msg);
+ var li = this.reporter.localDoc.createElement('li');
+ li.appendChild(node);
+ li.setAttribute('class', css);
+ this.resultElem.appendChild(li);
+ };
+
+ Page.prototype.startPage = function() {
+ if (autoScroll && this.elem.scrollIntoView) {
+ this.elem.scrollIntoView(false);
+ }
+ this.totalTests = 0;
+ this.totalSuccessful = 0;
+ this.totalSkipped = 0;
+ this.totalFailed = 0;
+ this.totalTimeouts = 0;
+ this.totalTime = 0;
+ // remove previous results.
+ while (this.resultElem.hasChildNodes()) {
+ this.resultElem.removeChild(this.resultElem.childNodes[0]);
+ }
+ this.totalsElem.textContent = '';
+
+ var shouldRun = this.check.checked && this.folder.checked();
+
+ if (shouldRun) {
+ this.elem.classList.remove('testpagetimeout');
+ this.elem.classList.remove('testpageskipped');
+ this.elem.classList.remove('testpagefail');
+ this.elem.classList.remove('testpagesuccess');
+ this.startTime = Date.now();
+ }
+
+ return this.check.checked && this.folder.checked();
+ };
+
+ Page.prototype.firstTestIndex = function() {
+ return this.testIndex;
+ };
+
+ Page.prototype.finishPage = function(success) {
+ var shouldRun = this.check.checked && this.folder.checked();
+ if (shouldRun) {
+ this.totalTime = Date.now() - this.startTime;
+ } else {
+ this.totalTime = 0;
+ }
+
+ var passedMsg = ' (Passed: ' + this.totalSuccessful + '/' + this.totalTests;
+ var skippedMsg = '';
+ if (this.totalSkipped > 0) {
+ skippedMsg = ' Skipped: ' + this.totalSkipped + '/' + this.totalTests;
+ }
+ var failedMsg = '';
+ if (this.totalFailed > 0) {
+ failedMsg = ' Failed: ' + this.totalFailed + '/' + this.totalTests;
+ }
+ var timeoutMsg = '';
+ if (this.totalTimeouts > 0) {
+ timeoutMsg = ' Timeout: ' + this.totalTimeouts + '/' + this.totalTests;
+ }
+ var msg = passedMsg + skippedMsg + failedMsg + timeoutMsg + ' in ' + this.totalTime.toFixed(1) + ' ms)';
+
+ if (success === undefined) {
+ var css = 'testpagetimeout';
+ msg = '(*timeout*)';
+ ++this.totalTests;
+ ++this.totalTimeouts;
+ } else if (this.totalSkipped) {
+ var css = 'testpageskipped';
+ } else if (this.totalSuccessful != this.totalTests) {
+ var css = 'testpagefail';
+ } else {
+ var css = 'testpagesuccess';
+ }
+ this.elem.classList.add(css);
+ this.totalsElem.textContent = msg;
+ this.folder.pageFinished(this, success);
+ };
+
+ Page.prototype.enableTest = function(re) {
+ if (this.url.match(re)) {
+ this.check.checked = true;
+ this.folder.enableUp_();
+ }
+ };
+
+ Page.prototype.disableTest = function(re) {
+ if (this.url.match(re)) {
+ this.check.checked = false;
+ }
+ };
+
+ Page.prototype.toJSON = function() {
+ return {
+ 'subtests': this.totalTests,
+ 'successful': this.totalSuccessful,
+ 'skipped': this.totalSkipped,
+ 'failed': this.totalFailed,
+ 'timedOut': this.totalTimeouts,
+ 'totalTime': this.totalTime,
+ };
+ };
+
+
+ var Folder = function(reporter, folder, depth, opt_name) {
+ this.reporter = reporter;
+ this.depth = depth;
+ this.name = opt_name || "";
+ this.displayName = this.name;
+ if (folder && folder.displayName) {
+ this.displayName = folder.displayName + '/' + this.displayName;
+ }
+ this.subFolders = {};
+ this.pages = [];
+ this.items = [];
+ this.folder = folder;
+ this.cachedTotalTime = 0;
+ this.cachedTotalSuccessful = 0;
+ this.cachedTotalSkipped = 0;
+ this.cachedTotalTimeouts = 0;
+ this.cachedTotalTests = 0;
+ var that = this;
+
+ var doc = reporter.localDoc;
+ this.elementId = "folder" + folderCount++;
+ var li = doc.createElement('li');
+ li.id = this.elementId;
+ li.classList.add("folder");
+ var folderHeader = doc.createElement('div');
+ folderHeader.classList.add('folderHeader');
+ var folderHeaderInner = doc.createElement('div');
+ folderHeaderInner.classList.add('folderHeaderInner');
+ folderHeader.appendChild(folderHeaderInner);
+ var check = doc.createElement('input');
+ check.type = 'checkbox';
+ check.checked = true;
+ check.onclick = function() {
+ if (this.checked) {
+ that.enableTest(".*");
+ }
+ else {
+ that.disableTest(".*", true);
+ }
+ };
+ folderHeaderInner.appendChild(check);
+ var button = doc.createElement('input');
+ button.type = 'button';
+ button.value = 'run';
+ button.onclick = function() {
+ autoScroll = autoScrollEnabled;
+ that.run();
+ };
+ if (reporter.noSelectedWebGLVersion) {
+ button.disabled = true;
+ }
+ folderHeaderInner.appendChild(button);
+ var h = doc.createElement('span');
+ h.classList.add('folderName');
+ h.appendChild(doc.createTextNode(this.displayName));
+ folderHeaderInner.appendChild(h);
+ var m = doc.createElement('span');
+ m.classList.add('folderMessage');
+ this.msgNode = doc.createTextNode('');
+ m.appendChild(this.msgNode);
+ folderHeaderInner.appendChild(m);
+ var ul = doc.createElement('ul');
+ li.appendChild(folderHeader);
+ li.appendChild(ul);
+ this.childUL = ul;
+ this.elem = li;
+ this.check = check;
+ this.folderHeader = folderHeader;
+ };
+
+ Folder.prototype.checked = function() {
+ return this.check.checked &&
+ (this.folder ? this.folder.checked() : true);
+ };
+
+ Folder.prototype.firstTestIndex = function() {
+ return this.items[0].firstTestIndex();
+ };
+
+ Folder.prototype.numChildren = function() {
+ var numChildren = 0;
+ for (var name in this.subFolders) {
+ numChildren += this.subFolders[name].numChildren();
+ }
+ return numChildren + this.pages.length;
+ };
+
+ Folder.prototype.totalTime = function() {
+ // Check to see if the cached total time needs to be recomputed
+ if (this.cachedTotalTime == -1) {
+ this.cachedTotalTime = 0;
+ for (var name in this.subFolders) {
+ this.cachedTotalTime += this.subFolders[name].totalTime();
+ }
+ for (var ii = 0; ii < this.pages.length; ++ii) {
+ this.cachedTotalTime += this.pages[ii].totalTime;
+ }
+ }
+ return this.cachedTotalTime;
+ };
+
+ Folder.prototype.totalSuccessful = function() {
+ if (this.cachedTotalSuccessful == -1) {
+ this.cachedTotalSuccessful = 0;
+ for (var name in this.subFolders) {
+ this.cachedTotalSuccessful += this.subFolders[name].totalSuccessful();
+ }
+ for (var ii = 0; ii < this.pages.length; ++ii) {
+ this.cachedTotalSuccessful += this.pages[ii].totalSuccessful;
+ }
+ }
+ return this.cachedTotalSuccessful;
+ };
+
+ Folder.prototype.totalSkipped = function() {
+ if (this.cachedTotalSkipped == -1) {
+ this.cachedTotalSkipped = 0;
+ for (var name in this.subFolders) {
+ this.cachedTotalSkipped += this.subFolders[name].totalSkipped();
+ }
+ for (var ii = 0; ii < this.pages.length; ++ii) {
+ this.cachedTotalSkipped += this.pages[ii].totalSkipped;
+ }
+ }
+ return this.cachedTotalSkipped;
+ };
+
+ Folder.prototype.totalFailed = function() {
+ if (this.cachedTotalFailed == -1) {
+ this.cachedTotalFailed = 0;
+ for (var name in this.subFolders) {
+ this.cachedTotalFailed += this.subFolders[name].totalFailed();
+ }
+ for (var ii = 0; ii < this.pages.length; ++ii) {
+ this.cachedTotalFailed += this.pages[ii].totalFailed;
+ }
+ }
+ return this.cachedTotalFailed;
+ };
+
+ Folder.prototype.totalTimeouts = function() {
+ if (this.cachedTotalTimeouts == -1) {
+ this.cachedTotalTimeouts = 0;
+ for (var name in this.subFolders) {
+ this.cachedTotalTimeouts += this.subFolders[name].totalTimeouts();
+ }
+ for (var ii = 0; ii < this.pages.length; ++ii) {
+ this.cachedTotalTimeouts += this.pages[ii].totalTimeouts;
+ }
+ }
+ return this.cachedTotalTimeouts;
+ };
+
+ Folder.prototype.totalTests = function() {
+ if (this.cachedTotalTests == -1) {
+ this.cachedTotalTests = 0;
+ for (var name in this.subFolders) {
+ this.cachedTotalTests += this.subFolders[name].totalTests();
+ }
+ for (var ii = 0; ii < this.pages.length; ++ii) {
+ this.cachedTotalTests += this.pages[ii].totalTests;
+ }
+ }
+ return this.cachedTotalTests;
+ };
+
+ Folder.prototype.run = function() {
+ this.msgNode.textContent = '';
+ var firstTestIndex = this.firstTestIndex();
+ var count = this.numChildren();
+ log("run tests: " + firstTestIndex + " to " + (firstTestIndex + count - 1))
+ testHarness.runTests({start: firstTestIndex, count: count});
+ };
+
+ Folder.prototype.pageFinished = function(page, success) {
+ this.cachedTotalTime = -1;
+ this.cachedTotalSuccessful = -1;
+ this.cachedTotalSkipped = -1;
+ this.cachedTotalFailed = -1;
+ this.cachedTotalTimeouts = -1;
+ this.cachedTotalTests = -1;
+ var passedMsg = ' (Passed: ' + this.totalSuccessful() + '/' + this.totalTests();
+ var skippedMsg = '';
+ if (this.totalSkipped() > 0) {
+ skippedMsg = ' Skipped: ' + this.totalSkipped() + '/' + this.totalTests();
+ }
+ var failedMsg = '';
+ if (this.totalFailed() > 0) {
+ failedMsg = ' Failed: ' + this.totalFailed() + '/' + this.totalTests();
+ }
+ var timeoutMsg = '';
+ if (this.totalTimeouts() > 0) {
+ timeoutMsg = ' Timeout: ' + this.totalTimeouts() + '/' + this.totalTests();
+ }
+ this.msgNode.textContent = passedMsg + skippedMsg + failedMsg + timeoutMsg + ' in ' + (this.totalTime() / 1000).toFixed(2) + ' seconds)';
+ if (this.folder) {
+ this.folder.pageFinished(page, success);
+ }
+ };
+
+ Folder.prototype.getSubFolder = function(name) {
+ var subFolder = this.subFolders[name];
+ if (subFolder === undefined) {
+ subFolder = new Folder(this.reporter, this, this.depth + 1, name);
+ this.subFolders[name] = subFolder;
+ this.items.push(subFolder);
+ this.childUL.appendChild(subFolder.elem);
+ }
+ return subFolder;
+ };
+
+ Folder.prototype.getOrCreateFolder = function(url) {
+ var parts = url.split('/');
+ var folder = this;
+ for (var pp = 0; pp < parts.length - 1; ++pp) {
+ folder = folder.getSubFolder(parts[pp]);
+ }
+ return folder;
+ };
+
+ Folder.prototype.addPage = function(page) {
+ this.pages.push(page);
+ this.items.push(page);
+ this.childUL.appendChild(page.elem);
+ this.folderHeader.classList.add('hasPages');
+ };
+
+ Folder.prototype.disableTest = function(re, opt_forceRecurse) {
+ var recurse = true;
+ if (this.name.match(re)) {
+ this.check.checked = false;
+ recurse = opt_forceRecurse;
+ }
+ if (recurse) {
+ for (var name in this.subFolders) {
+ this.subFolders[name].disableTest(re, opt_forceRecurse);
+ }
+ for (var ii = 0; ii < this.pages.length; ++ii) {
+ this.pages[ii].disableTest(re);
+ }
+ }
+ };
+
+ Folder.prototype.enableUp_ = function() {
+ this.check.checked = true;
+ var parent = this.folder;
+ if (parent) {
+ parent.enableUp_();
+ }
+ }
+
+ Folder.prototype.disableUp_ = function() {
+ var checked = false;
+ for (var name in this.subFolders) {
+ checked = this.subFolders[name].checked();
+ if (checked) {
+ break;
+ }
+ }
+ for (var ii = 0; ii < this.pages.length && checked == false; ++ii) {
+ checked = this.pages[ii].checked();
+ }
+ this.check.checked = checked;
+ var parent = this.folder;
+ if (parent) {
+ parent.disableUp_();
+ }
+ }
+
+ Folder.prototype.enableTest = function(re) {
+ if (this.name.match(re)) {
+ this.enableUp_();
+ }
+ for (var name in this.subFolders) {
+ this.subFolders[name].enableTest(re);
+ }
+ for (var ii = 0; ii < this.pages.length; ++ii) {
+ this.pages[ii].enableTest(re);
+ }
+ };
+
+ var Reporter = function(iframes) {
+ this.localDoc = document;
+ this.resultElem = document.getElementById("results");
+ this.fullResultsElem = document.getElementById("fullresults");
+ var node = this.localDoc.createTextNode('');
+ this.fullResultsElem.appendChild(node);
+ this.fullResultsNode = node;
+ this.iframes = iframes;
+ this.currentPageElem = null;
+ this.totalPages = 0;
+ this.pagesByURL = {};
+
+ // Check to see if WebGL is supported
+ var canvas = document.createElement("canvas");
+ var ctx = create3DContext(canvas, null, 1);
+
+ // Check to see if WebGL2 is supported
+ var canvas2 = document.createElement("canvas");
+ var ctx2 = create3DContext(canvas2, null, 2);
+
+ this.noSelectedWebGLVersion = false;
+ this.selectedWebGLVersion = WebGLTestHarnessModule.getMajorVersion(OPTIONS.version);
+ if (this.selectedWebGLVersion == 2 && !ctx2) {
+ this.noSelectedWebGLVersion = true;
+ } else if (this.selectedWebGLVersion == 1 && !ctx) {
+ this.noSelectedWebGLVersion = true;
+ }
+
+ // If the WebGL2 context could be created use it to get context info
+ if (ctx2) {
+ ctx = ctx2;
+ }
+
+ this.noWebGL = !ctx;
+
+ this.contextInfo = {};
+ this.root = new Folder(this, null, 0, "all");
+ this.resultElem.appendChild(this.root.elem);
+ this.callbacks = { };
+ this.startTime = new Date();
+
+ if (ctx) {
+ this.contextInfo["VENDOR"] = ctx.getParameter(ctx.VENDOR);
+ this.contextInfo["VERSION"] = ctx.getParameter(ctx.VERSION);
+ this.contextInfo["RENDERER"] = ctx.getParameter(ctx.RENDERER);
+ this.contextInfo["RED_BITS"] = ctx.getParameter(ctx.RED_BITS);
+ this.contextInfo["GREEN_BITS"] = ctx.getParameter(ctx.GREEN_BITS);
+ this.contextInfo["BLUE_BITS"] = ctx.getParameter(ctx.BLUE_BITS);
+ this.contextInfo["ALPHA_BITS"] = ctx.getParameter(ctx.ALPHA_BITS);
+ this.contextInfo["DEPTH_BITS"] = ctx.getParameter(ctx.DEPTH_BITS);
+ this.contextInfo["STENCIL_BITS"] = ctx.getParameter(ctx.STENCIL_BITS);
+
+ var ext = ctx.getExtension("WEBGL_debug_renderer_info");
+ if (ext) {
+ this.contextInfo["UNMASKED_VENDOR"] = ctx.getParameter(ext.UNMASKED_VENDOR_WEBGL);
+ this.contextInfo["UNMASKED_RENDERER"] = ctx.getParameter(ext.UNMASKED_RENDERER_WEBGL);
+ }
+ }
+ };
+
+ Reporter.prototype.enableTest = function(name) {
+ this.root.enableTest(name);
+ };
+
+ Reporter.prototype.disableTest = function(name) {
+ this.root.disableTest(name);
+ };
+
+ Reporter.prototype.disableAllTests = function() {
+ this.root.disableTest(".*", true);
+ };
+
+ Reporter.prototype.addEventListener = function(type, func) {
+ if (!this.callbacks[type]) {
+ this.callbacks[type] = [];
+ }
+ this.callbacks[type].push(func);
+ };
+
+ Reporter.prototype.executeListenerEvents_ = function(type) {
+ var callbacks = this.callbacks[type].slice(0);
+ for (var ii = 0; ii < callbacks.length; ++ii) {
+ setTimeout(callbacks[ii], 0);
+ }
+ };
+
+ Reporter.prototype.runTest = function(url) {
+ var page = this.pagesByURL[url];
+ testHarness.runTests({start: page.firstTestIndex(), count: 1});
+ };
+
+ Reporter.prototype.getFolder = function(url) {
+ return this.root.getOrCreateFolder(url);
+ };
+
+ Reporter.prototype.addPage = function(url) {
+ var folder = this.getFolder(url);
+ var page = new Page(this, folder, this.totalPages, url);
+ folder.addPage(page);
+ ++this.totalPages;
+ this.pagesByURL[url] = page;
+ };
+
+ Reporter.prototype.startPage = function(url) {
+ var page = this.pagesByURL[url];
+ return page.startPage();
+ };
+
+ Reporter.prototype.addResult = function(url, msg, success, skipped) {
+ var page = this.pagesByURL[url];
+ page.addResult(msg, success, skipped);
+ };
+
+ Reporter.prototype.finishPage = function(url, success) {
+ var page = this.pagesByURL[url];
+ page.finishPage(success);
+ if (OPTIONS.dumpShaders == 1) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('POST', "/finishIndividualTest", true);
+ xhr.send(null);
+ }
+ };
+
+ Reporter.prototype.displayFinalResults = function(msg, success) {
+ if (success) {
+ var totalTests = 0;
+ var testsSucceeded = 0;
+ var testsFailed = 0;
+ var testsSkipped = 0;
+ var testsTimedOut = 0;
+
+ var subtestsHit = 0;
+ var subtestsSucceeded = 0;
+ var subtestsTimedOut = 0;
+ var subtestsSkipped = 0;
+ var subtestsFailed = 0;
+
+ var totalTime = Date.now() - this.startTime;
+
+ for (var url in this.pagesByURL) {
+ var page = this.pagesByURL[url];
+ totalTests += 1;
+ if (page.totalSkipped) {
+ testsSkipped += 1;
+ }
+ if (page.totalFailed) {
+ testsFailed += 1;
+ } else if (page.totalTimeouts) {
+ testsTimedOut += 1;
+ } else if (page.totalSuccessful) {
+ if (page.totalSuccessful != page.totalTests)
+ throw successes_not_equal_total;
+ testsSucceeded += 1;
+ }
+
+ subtestsHit += page.totalTests;
+ subtestsSucceeded += page.totalSuccessful;
+ subtestsTimedOut += page.totalTimeouts;
+ subtestsSkipped += page.totalSkipped;
+ subtestsFailed += page.totalFailed;
+ }
+
+ function ratio_str(x, y, name) {
+ return x + '/' + y + ' ' + name + ' (' + (x / y * 100).toFixed(2) + '%)';
+ }
+ var testsSucceededRatio = ratio_str(testsSucceeded, totalTests, 'tests');
+ var passedMsg = 'Passed ' + testsSucceededRatio + ', ' +
+ ratio_str(subtestsSucceeded, subtestsHit, 'subtests');
+ var skippedMsg = '';
+ if (testsSkipped > 0) {
+ skippedMsg = ' Skipped ' + ratio_str(testsSkipped, totalTests, 'tests');
+ }
+ var failedMsg = '';
+ if (testsFailed > 0) {
+ failedMsg = ' Failed ' + ratio_str(testsFailed, totalTests, 'tests') + ', ' +
+ ratio_str(subtestsFailed, subtestsHit, 'subtests');
+ }
+ var timeoutMsg = '';
+ if (testsTimedOut > 0) {
+ timeoutMsg = ' Timeout ' + ratio_str(testsTimedOut, totalTests, 'tests');
+ }
+ var msg = passedMsg + skippedMsg + failedMsg + timeoutMsg;
+ this.fullResultsNode.textContent = msg;
+
+ // generate a text summary
+ var tx = "";
+ tx += "WebGL Conformance Test Results\n";
+ tx += "Version " + OPTIONS.version + "\n";
+ tx += "Generated on: " + (new Date()).toString() + "\n";
+ tx += "\n";
+ tx += "-------------------\n\n";
+ tx += "User Agent: " + (navigator.userAgent ? navigator.userAgent : "(navigator.userAgent is null)") + "\n";
+ tx += "WebGL VENDOR: " + this.contextInfo["VENDOR"] + "\n";
+ tx += "WebGL VERSION: " + this.contextInfo["VERSION"] + "\n";
+ tx += "WebGL RENDERER: " + this.contextInfo["RENDERER"] + "\n";
+ tx += "Unmasked VENDOR: " + this.contextInfo["UNMASKED_VENDOR"] + "\n";
+ tx += "Unmasked RENDERER: " + this.contextInfo["UNMASKED_RENDERER"] + "\n";
+ tx += "WebGL R/G/B/A/Depth/Stencil bits (default config): " + this.contextInfo["RED_BITS"] + "/" + this.contextInfo["GREEN_BITS"] + "/" + this.contextInfo["BLUE_BITS"] + "/" + this.contextInfo["ALPHA_BITS"] + "/" + this.contextInfo["DEPTH_BITS"] + "/" + this.contextInfo["STENCIL_BITS"] + "\n";
+ tx += "\n-------------------\n\n";
+
+ var result;
+ if (totalTests && testsSucceeded == totalTests) {
+ result = 'PASS';
+ } else {
+ result = 'FAIL';
+ }
+ tx += "Test Summary: " + result + " (" + totalTests + " tests):\n";
+ tx += subtestsHit + " subtests ran in " + (totalTime / 1000.0).toFixed(2) + " seconds\n";
+ function record(what, tests, subtests) {
+ tx += what + ": " + tests + " tests, " + subtests + " subtests\n";
+ }
+ record('PASSED', testsSucceeded, subtestsSucceeded);
+ record('NOT PASSED', totalTests - testsSucceeded, subtestsHit - subtestsSucceeded);
+
+ record('FAILED', testsFailed, subtestsFailed);
+ record('TIMED OUT', testsTimedOut, subtestsTimedOut);
+ record('SKIPPED', testsSkipped, subtestsSkipped);
+
+ tx += "\n-------------------\n\n";
+
+ const failureLines = [];
+ const timeoutLines = [];
+ const resultLines = [];
+
+ for (var url in this.pagesByURL) {
+ var page = this.pagesByURL[url];
+ resultLines.push(' "' + url + '":' + JSON.stringify(page.toJSON()));
+
+ if (page.totalFailed) {
+ failureLines.push(' "' + url + '",');
+ }
+ if (page.totalTimeouts) {
+ timeoutLines.push(' "' + url + '",');
+ }
+ }
+
+ const lines = [].concat(
+ [
+ '{',
+ ' "failures": [',
+ ],
+ failureLines,
+ [
+ ' ],',
+ ' "timeouts": [',
+ ],
+ timeoutLines,
+ [
+ ' ],',
+ ' "results": {',
+ ],
+ resultLines,
+ [
+ ' },',
+ '}',
+ ]
+ );
+
+ tx += lines.join('\n');
+
+ var r = document.getElementById("testResultsAsText");
+ while (r.firstChild) r.removeChild(r.firstChild);
+ r.appendChild(document.createTextNode(tx));
+ document.getElementById("showTextSummary").disabled = false;
+ document.getElementById("dlTextSummary").disabled = false;
+
+ this.postResultsToServer(tx);
+ } else {
+ var e = document.getElementById("error");
+ e.innerHTML = msg;
+ this.postResultsToServer(msg);
+ }
+ };
+
+ Reporter.prototype.postTestStartToServer = function(resultText) {
+ this.startTime = Date.now();
+ if(OPTIONS.postResults == undefined || OPTIONS.postResults == 0) {
+ return;
+ }
+
+ var xhr = new XMLHttpRequest();
+ xhr.open('POST', "/start", true);
+ xhr.send(null);
+ };
+
+ Reporter.prototype.postResultsToServer = function(resultText) {
+ if(OPTIONS.postResults == undefined || OPTIONS.postResults == 0) {
+ return;
+ }
+
+ var xhr = new XMLHttpRequest();
+ xhr.open('POST', "/finish", true);
+ xhr.setRequestHeader("Content-Type", "text/plain");
+ xhr.send(resultText);
+ };
+
+ Reporter.prototype.ready = function() {
+ var loading = document.getElementById("loading");
+ loading.style.display = "none";
+ if (!this.noSelectedWebGLVersion) {
+ var button = document.getElementById("runTestsButton");
+ button.disabled = false;
+ this.executeListenerEvents_("ready");
+ }
+ };
+
+ Reporter.prototype.reportFunc = function(type, url, msg, success, skipped) {
+ switch (type) {
+ case reportType.ADD_PAGE:
+ return this.addPage(msg);
+ case reportType.READY:
+ return this.ready();
+ case reportType.START_PAGE:
+ return this.startPage(url);
+ case reportType.TEST_RESULT:
+ return this.addResult(url, msg, success, skipped);
+ case reportType.FINISH_PAGE:
+ return this.finishPage(url, success);
+ case reportType.FINISHED_ALL_TESTS:
+ return this.displayFinalResults(msg, success);
+ default:
+ throw 'unhandled';
+ break;
+ };
+ };
+
+ var getURLOptions = function(obj) {
+ var s = window.location.href;
+ var q = s.indexOf("?");
+ var e = s.indexOf("#");
+ if (e < 0) {
+ e = s.length;
+ }
+ var query = s.substring(q + 1, e);
+ var pairs = query.split("&");
+ for (var ii = 0; ii < pairs.length; ++ii) {
+ var keyValue = pairs[ii].split("=");
+ var key = keyValue[0];
+ var value = decodeURIComponent(keyValue[1]);
+ obj[key] = value;
+ }
+ };
+
+ getURLOptions(OPTIONS);
+
+ var makeVersionSelect = function(currentVersion) {
+ var versionSelect = document.getElementById("testVersion");
+ var foundCurrentVersion = false;
+ var numericCurrentVersion = currentVersion.replace(/[^\d.]/g, '');
+
+ for (var i in testVersions) {
+ var version = testVersions[i];
+ var numericVersion = version.replace(/[^\d.]/g, '');
+ var option = document.createElement("option");
+ option.setAttribute('value', numericVersion);
+ option.innerHTML = version;
+
+ if (numericVersion == numericCurrentVersion) {
+ foundCurrentVersion = true;
+ option.selected = true;
+ }
+
+ versionSelect.appendChild(option);
+ }
+
+ // If the version requested by the query string isn't in the list add it.
+ if (!foundCurrentVersion) {
+ var option = document.createElement("option");
+ option.setAttribute('value', numericCurrentVersion);
+ option.innerHTML = currentVersion + " (unknown)";
+ option.selected = true;
+
+ versionSelect.appendChild(option);
+ }
+
+ versionSelect.addEventListener('change', function(ev) {
+ window.location.href = "?version=" + versionSelect.value;
+ }, false);
+ }
+
+ makeVersionSelect(OPTIONS.version);
+
+ // Make iframes
+ var iframes = [document.getElementById("test-iframe")];
+
+ var testPath = "00_test_list.txt";
+ if (OPTIONS.root) {
+ testPath = OPTIONS.root + "/" + testPath;
+ }
+
+ var reporter = new Reporter(iframes);
+ var testHarness = new WebGLTestHarnessModule.TestHarness(
+ iframes,
+ testPath,
+ function(type, url, msg, success, skipped) {
+ return reporter.reportFunc(type, url, msg, success, skipped);
+ },
+ OPTIONS);
+ reporter.addEventListener("ready", function() {
+ // Set which tests to include.
+ if (OPTIONS.include) {
+ reporter.disableAllTests();
+ var includes = OPTIONS.include.split(",")
+ for (var ii = 0; ii < includes.length; ++ii) {
+ reporter.enableTest(new RegExp(includes[ii]));
+ }
+ }
+ // Remove tests based on skip=re1,re2 in URL.
+ if (OPTIONS.skip) {
+ var skips = OPTIONS.skip.split(",")
+ for (var ii = 0; ii < skips.length; ++ii) {
+ reporter.disableTest(new RegExp(skips[ii]));
+ }
+ }
+ // Auto run the tests if the run=1 in URL
+ if (OPTIONS.run != undefined && OPTIONS.run != 0) {
+ reporter.postTestStartToServer();
+ testHarness.runTests();
+ }
+ });
+ window.webglTestHarness = testHarness;
+ var button = document.getElementById("runTestsButton");
+ button.disabled = true;
+ button.onclick = function() {
+ autoScroll = autoScrollEnabled;
+ reporter.postTestStartToServer();
+ testHarness.runTests();
+ };
+ var autoScrollCheckbox = document.getElementById("autoScrollCheckbox");
+ autoScrollCheckbox.checked = autoScrollEnabled;
+ autoScrollCheckbox.onclick = function() {
+ autoScrollEnabled = autoScrollCheckbox.checked;
+ autoScroll = autoScrollEnabled;
+ };
+
+ var hidePassedSheet = createStylesheet();
+ var hidePassedCheckbox = document.getElementById("hidePassedCheckbox");
+ hidePassedCheckbox.checked = false;
+ hidePassedCheckbox.onclick = function() {
+ var hidePassedTests = hidePassedCheckbox.checked;
+ if (hidePassedTests) {
+ hidePassedSheet.insertRule(".testpagesuccess { display: none; }", 0);
+ } else {
+ hidePassedSheet.deleteRule(0);
+ }
+ };
+
+ var quickTestModeCheckbox = document.getElementById("quickTestModeCheckbox");
+ quickTestModeCheckbox.checked = quickTestMode;
+ quickTestModeCheckbox.onclick = function() {
+ quickTestMode = quickTestModeCheckbox.checked;
+ };
+
+ var textbutton = document.getElementById("showTextSummary");
+ textbutton.onclick = function() {
+ log("click");
+ var htmldiv = document.getElementById("testResultsHTML");
+ var textdiv = document.getElementById("testResultsText");
+ if (textdiv.style.display == "none") {
+ textdiv.style.display = "block";
+ htmldiv.style.display = "none";
+ textbutton.setAttribute("value", "display html summary");
+ } else {
+ textdiv.style.display = "none";
+ htmldiv.style.display = "block";
+ textbutton.setAttribute("value", "display text summary");
+ }
+ };
+
+ function download(filename, text) {
+ var element = document.createElement("a");
+ element.setAttribute("href", "data:text/plain;charset=utf-8," + encodeURIComponent(text));
+ element.setAttribute("download", filename);
+ element.style.display = "none";
+ document.body.appendChild(element);
+ element.click();
+ document.body.removeChild(element);
+ }
+ var dltextbutton = document.getElementById("dlTextSummary");
+ dltextbutton.onclick = function() {
+ var textdiv = document.getElementById("testResultsText");
+ download("webgl-conformance-" + OPTIONS.version + ".txt", textdiv.innerText.trim());
+ };
+
+ if (reporter.noSelectedWebGLVersion) {
+ button.disabled = true;
+ }
+ if (reporter.noWebGL) {
+ var elem = document.getElementById("nowebgl");
+ elem.style.display = "";
+ reporter.postResultsToServer("Browser does not appear to support WebGL");
+ } else if (reporter.noSelectedWebGLVersion) {
+ var elem = document.getElementById("noselectedwebgl");
+ elem.style.display = "";
+ reporter.postResultsToServer("Browser does not appear to support the selected version of WebGL");
+ }
+
+ const iframeContainer = document.getElementById("iframe-container");
+ const iframeToggle = document.getElementById("iframe-toggle");
+ iframeToggle.value = iframeToggle.getAttribute("data-value-hidden");
+ iframeToggle.onclick = function() {
+ const expanded = iframeToggle.myExpanded = !iframeToggle.myExpanded;
+ if (expanded) {
+ iframeContainer.classList.add("iframe-shown");
+ iframeToggle.value = iframeToggle.getAttribute("data-value-shown");
+ } else {
+ iframeContainer.classList.remove("iframe-shown");
+ iframeToggle.value = iframeToggle.getAttribute("data-value-hidden");
+ }
+ };
+}
+</script>
+</head>
+<body onload="start()">
+
+<div id="testlist">
+ <div id="testResultsHTML">
+ <ul id="results">
+ </ul>
+ </div>
+ <div style="display: none;" id="testResultsText">
+ <pre id="testResultsAsText"></pre>
+ </div>
+</div> <!-- end of container -->
+
+<div id="iframe-container">
+ <input type="button" data-value-hidden="◄" data-value-shown="►" id="iframe-toggle" aria-hidden="true"
+ ><iframe id="test-iframe"></iframe>
+</div>
+
+<div id="header">
+ <div id="info">
+ <div style="text-align:center">
+ <img src="resources/webgl-logo.png" alt="WebGL" id="logo"/>
+ <br/>
+ Conformance Test Runner
+ </div>
+ Version
+ <select id="testVersion">
+ </select>
+ <a href="../../conformance-suites/">(older versions?)</a>
+ <br/>
+ <input type="button" value="run tests" id="runTestsButton"/>
+ <label for="autoScrollCheckbox"><input type="checkbox" id="autoScrollCheckbox"/>auto scroll</label>
+ <label for="hidePassedCheckbox"><input type="checkbox" id="hidePassedCheckbox"/>hide passed</label>
+ <label for="quickTestModeCheckbox"><input type="checkbox" id="quickTestModeCheckbox"/>quick test mode</label>
+ <br/>
+ <input type="button" disabled value="show text summary" id="showTextSummary"/>
+ <input type="button" disabled value="download text" id="dlTextSummary"/>
+ <div id="nowebgl" class="nowebgl" style="display: none;">
+ This browser does not appear to support WebGL
+ </div>
+ <div id="noselectedwebgl" class="nowebgl" style="display: none;">
+ This browser does not appear to support the selected version of WebGL
+ </div>
+ <div id="loading">
+ Loading Tests...
+ </div>
+ <div id="fullresults">
+ </div>
+ </div>
+ <div id="error-wrap">
+ <pre id="error"></pre>
+ </div>
+</div> <!-- end of header -->
+
+</body>
+</html>