Add webgl conformance tests r15841.

conformance/resources/glsl-conformance-test.js

+GLSLConformanceTester = (function(){
+
+var wtu = WebGLTestUtils;
+var defaultVertexShader = [
+  "attribute vec4 vPosition;",
+  "void main()",
+  "{",
+  "    gl_Position = vPosition;",
+  "}"
+].join('\n');
+
+var defaultFragmentShader = [
+  "precision mediump float;",
+  "void main()",
+  "{",
+  "    gl_FragColor = vec4(1.0,0.0,0.0,1.0);",
+  "}"
+].join('\n');
+
+function log(msg) {
+  if (window.console && window.console.log) {
+    window.console.log(msg);
+  }
+}
+
+var vShaderDB = {};
+var fShaderDB = {};
+
+/**
+ * vShaderSource: the source code for vertex shader
+ * vShaderSuccess: true if vertex shader compiliation should
+ *   succeed.
+ * fShaderSource: the source code for fragment shader
+ * fShaderSuccess: true if fragment shader compiliation should
+ *   succeed.
+ * linkSuccess: true of link should succeed
+ * passMsg: msg to describe success condition.
+ *
+ */
+function runOneTest(gl, info) {
+  var passMsg = info.passMsg
+  log(passMsg);
+
+  if (info.vShaderSource === undefined) {
+    if (info.vShaderId) {
+      info.vShaderSource = document.getElementById(info.vShaderId).text;
+    } else {
+      info.vShader = 'defaultVertexShader';
+      info.vShaderSource = defaultVertexShader;
+    }
+  }
+  if (info.fShaderSource === undefined) {
+    if (info.fShaderId) {
+      info.fShaderSource = document.getElementById(info.fShaderId).text;
+    } else {
+      info.fShader = 'defaultFragmentShader';
+      info.fShaderSource = defaultFragmentShader;
+    }
+  }
+
+  var vSource = info.vShaderPrep ? info.vShaderPrep(info.vShaderSource) :
+    info.vShaderSource;
+
+  // Reuse identical shaders so we test shared shader.
+  var vShader = vShaderDB[vSource];
+  if (!vShader) {
+    vShader = wtu.loadShader(gl, vSource, gl.VERTEX_SHADER);
+    if (info.vShaderTest) {
+      if (!info.vShaderTest(vShader)) {
+        testFailed("[vertex shader test] " + passMsg);
+        return;
+      }
+    }
+    if ((vShader != null) != info.vShaderSuccess) {
+      testFailed("[unexpected vertex shader compile status] (expected: " +
+                info.vShaderSuccess + ") " + passMsg);
+      return;
+    }
+    // Save the shaders so we test shared shader.
+    if (vShader) {
+      vShaderDB[vSource] = vShader;
+    }
+  }
+
+  var fSource = info.fShaderPrep ? info.fShaderPrep(info.fShaderSource) :
+    info.fShaderSource;
+
+  // Reuse identical shaders so we test shared shader.
+  var fShader = fShaderDB[fSource];
+  if (!fShader) {
+    fShader = wtu.loadShader(gl, fSource, gl.FRAGMENT_SHADER);
+    if (info.fShaderTest) {
+      if (!info.fShaderTest(fShader)) {
+        testFailed("[fragment shdaer test] " + passMsg);
+        return;
+      }
+    }
+    //debug(fShader == null ? "fail" : "succeed");
+    if ((fShader != null) != info.fShaderSuccess) {
+      testFailed("[unexpected fragment shader compile status] (expected: " +
+                info.fShaderSuccess + ") " + passMsg);
+      return;
+    }
+    // Safe the shaders so we test shared shader.
+    if (fShader) {
+      fShaderDB[fSource] = fShader;
+    }
+  }
+
+  if (vShader && fShader) {
+    var program = gl.createProgram();
+    gl.attachShader(program, vShader);
+    gl.attachShader(program, fShader);
+    gl.linkProgram(program);
+    var linked = (gl.getProgramParameter(program, gl.LINK_STATUS) != 0);
+    if (!linked) {
+      var error = gl.getProgramInfoLog(program);
+      log("*** Error linking program '"+program+"':"+error);
+    }
+    if (linked != info.linkSuccess) {
+      testFailed("[unexpected link status] " + passMsg);
+      return;
+    }
+  } else {
+    if (info.linkSuccess) {
+      testFailed("[link failed] " + passMsg);
+      return;
+    }
+  }
+  testPassed(passMsg);
+}
+
+function runTests(shaderInfos) {
+  var wtu = WebGLTestUtils;
+  var canvas = document.createElement('canvas');
+  var gl = wtu.create3DContext();
+  if (!gl) {
+    testFailed("context does not exist");
+    finishTest();
+    return;
+  }
+
+  for (var ii = 0; ii < shaderInfos.length; ++ii) {
+    runOneTest(gl, shaderInfos[ii]);
+  }
+
+  finishTest();
+};
+
+function loadExternalShaders(filename, passMsg) {
+  var shaderInfos = [];
+  var lines = wtu.readFileList(filename);
+  for (var ii = 0; ii < lines.length; ++ii) {
+    var info = {
+      vShaderSource:  defaultVertexShader,
+      vShaderSuccess: true,
+      fShaderSource:  defaultFragmentShader,
+      fShaderSuccess: true,
+      linkSuccess:    true,
+    };
+
+    var line = lines[ii];
+    var files = line.split(/ +/);
+    var passMsg = "";
+    for (var jj = 0; jj < files.length; ++jj) {
+      var file = files[jj];
+      var shaderSource = wtu.readFile(file);
+      var firstLine = shaderSource.split("\n")[0];
+      var success = undefined;
+      if (firstLine.indexOf("fail") >= 0) {
+        success = false;
+      } else if (firstLine.indexOf("succeed") >= 0) {
+        success = true;
+      }
+      if (success === undefined) {
+        testFailed("bad first line in " + file + ":" + firstLine);
+        continue;
+      }
+      if (!wtu.startsWith(firstLine, "// ")) {
+        testFailed("bad first line in " + file + ":" + firstLine);
+        continue;
+      }
+      passMsg = passMsg + (passMsg.length ? ", " : "") + firstLine.substr(3);
+      if (wtu.endsWith(file, ".vert")) {
+        info.vShaderSource = shaderSource;
+        info.vShaderSuccess = success;
+      } else if (wtu.endsWith(file, ".frag")) {
+        info.fShaderSource = shaderSource;
+        info.fShaderSuccess = success;
+      }
+    }
+    info.linkSuccess = info.vShaderSuccess && info.fShaderSuccess;
+    info.passMsg = passMsg;
+    shaderInfos.push(info);
+  }
+  return shaderInfos;
+}
+
+function getSource(elem) {
+  var str = elem.text;
+  return str.replace(/^\s*/, '').replace(/\s*$/, '');
+}
+
+function getPassMessage(source) {
+  var lines = source.split('\n');
+  return lines[0].substring(3);
+}
+
+function getSuccess(msg) {
+  if (msg.indexOf("fail") >= 0) {
+    return false;
+  }
+  if (msg.indexOf("succeed") >= 0) {
+    return true;
+  }
+  testFailed("bad test description. Must have 'fail' or 'success'");
+}
+
+function runTest() {
+  var vShaderElem = document.getElementById('vertexShader');
+  var vShaderSource = defaultVertexShader;
+  var vShaderSuccess = true;
+
+  var fShaderElem = document.getElementById('fragmentShader');
+  var fShaderSource = defaultFragmentShader;
+  var fShaderSuccess = true;
+
+  var passMsg = undefined;
+
+  if (vShaderElem) {
+    vShaderSource = getSource(vShaderElem);
+    passMsg = getPassMessage(vShaderSource);
+    vShaderSuccess = getSuccess(passMsg);
+  }
+
+  if (fShaderElem) {
+    fShaderSource = getSource(fShaderElem);
+    passMsg = getPassMessage(fShaderSource);
+    fShaderSuccess = getSuccess(passMsg);
+  }
+
+  var linkSuccess = vShaderSuccess && fShaderSuccess;
+
+  if (passMsg === undefined) {
+    testFailed("no test shader found.");
+    finishTest();
+    return;
+  }
+
+  var info = {
+    vShaderSource: vShaderSource,
+    vShaderSuccess: vShaderSuccess,
+    fShaderSource: fShaderSource,
+    fShaderSuccess: fShaderSuccess,
+    linkSuccess: linkSuccess,
+    passMsg: passMsg
+  };
+  description(passMsg);
+  runTests([info]);
+}
+
+return {
+  runTest: runTest,
+  runTests: runTests,
+  loadExternalShaders: loadExternalShaders,
+
+  none: false,
+};
+}());