Improve error handling for js2gtest C++ generation.

chrome/test/base/js2gtest.js

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview Generator script for creating gtest-style JavaScript
  *     tests for extensions, WebUI and unit tests. Generates C++ gtest wrappers
  *     which will invoke the appropriate JavaScript for each test.
  * @author scr@chromium.org (Sheridan Rawlins)
  * @see WebUI testing: http://goo.gl/ZWFXF
  * @see gtest documentation: http://goo.gl/Ujj3H
  * @see chrome/chrome_tests.gypi
+ * @see chrome/test/base/js2gtest.js
  * @see tools/gypv8sh.py
  */
 
 // Arguments from rules in chrome_tests.gypi are passed in through
 // python script gypv8sh.py.
 if (arguments.length != 6) {
   print('usage: ' +
         arguments[0] +
         ' path-to-testfile.js testfile.js path_to_deps.js output.cc test-type');
   quit(-1);
@@ skipping 69 matching lines @@
  * @type {boolean}
  */
 var needGenHeader = true;
 
 /**
  * Helpful hint pointing back to the source js.
  * @type {string}
  */
 var argHint = '// ' + this['arguments'].join(' ');
 
+/**
+ * @type {Array<string>}
+ */
+var pendingOutput = '';
+
+/**
+ * Adds a string followed by a newline to the pending output.
+ * If present, an initial newline character is stripped from the string.
+ * @param {string=} opt_string
+ */
+function output(opt_string) {
+  opt_string = opt_string || '';
+  if (opt_string[0] == '\n')
+    opt_string = opt_string.substring(1);
+    pendingOutput += opt_string;
+  pendingOutput += '\n';
+}
 
 /**
  * Generates the header of the cc file to stdout.
  * @param {string?} testFixture Name of test fixture.
  */
 function maybeGenHeader(testFixture) {
   if (!needGenHeader)
     return;
   needGenHeader = false;
-  print('// GENERATED FILE');
-  print(argHint);
-  print('// PLEASE DO NOT HAND EDIT!');
-  print();
+  output(`
+// GENERATED FILE'
+${argHint}
+// PLEASE DO NOT HAND EDIT!
+`);
 
   // Output some C++ headers based upon the |testType|.
   //
   // Currently supports:
   // 'extension' - browser_tests harness, js2extension rule,
   //               ExtensionJSBrowserTest superclass.
   // 'unit' - unit_tests harness, js2unit rule, V8UnitTest superclass.
   // 'webui' - browser_tests harness, js2webui rule, WebUIBrowserTest
   // superclass.
   if (testType === 'extension') {
-    print('#include "chrome/test/base/extension_js_browser_test.h"');
+    output('#include "chrome/test/base/extension_js_browser_test.h"');
     testing.Test.prototype.typedefCppFixture = 'ExtensionJSBrowserTest';
     addSetPreloadInfo = false;
     testF = 'IN_PROC_BROWSER_TEST_F';
   } else if (testType === 'unit') {
-    print('#include "chrome/test/base/v8_unit_test.h"');
+    output('#include "chrome/test/base/v8_unit_test.h"');
     testing.Test.prototype.typedefCppFixture = 'V8UnitTest';
     testF = 'TEST_F';
     addSetPreloadInfo = false;
   } else {
-    print('#include "chrome/test/base/web_ui_browser_test.h"');
+    output('#include "chrome/test/base/web_ui_browser_test.h"');
     testing.Test.prototype.typedefCppFixture = 'WebUIBrowserTest';
     testF = 'IN_PROC_BROWSER_TEST_F';
     addSetPreloadInfo = true;
   }
-  print('#include "url/gurl.h"');
-  print('#include "testing/gtest/include/gtest/gtest.h"');
+  output(`
+#include "url/gurl.h"
+#include "testing/gtest/include/gtest/gtest.h"`);
   // Add includes specified by test fixture.
   if (testFixture) {
     if (this[testFixture].prototype.testGenCppIncludes)
       this[testFixture].prototype.testGenCppIncludes();
     if (this[testFixture].prototype.commandLineSwitches)
-      print('#include "base/command_line.h"');
+      output('#include "base/command_line.h"');
   }
-  print();
+  output();
 }
 
 
 /**
  * @type {Array<{path: string, base: string>}
  */
 var pathStack = [];
 
 
 /**
  * Convert the |includeFile| to paths appropriate for immediate
  * inclusion (path) and runtime inclusion (base).
  * @param {string} includeFile The file to include.
  * @return {{path: string, base: string}} Object describing the paths
  *     for |includeFile|. |path| is relative to cwd; |base| is relative to
  *     source root.
  */
 function includeFileToPaths(includeFile) {
   paths = pathStack[pathStack.length - 1];
   return {
     path: paths.path.replace(/[^\/\\]+$/, includeFile),
     base: paths.base.replace(/[^\/\\]+$/, includeFile),
   };
 }
 
+/**
+ * Returns the content of a javascript file with a sourceURL comment
+ * appended to facilitate better stack traces.
+ * @param {string} path Relative path name.
+ * return {string}
+ */
+function readJsFile(path) {
+  return read(path) + '\n//# sourceURL=' + path;
+}
+
 
 /**
  * Maps object names to the path to the file that provides them.
  * Populated from the |depsFile| if any.
  * @type {Object<string>}
  */
 var dependencyProvidesToPaths = {};
 
 /**
  * Maps dependency path names to object names required by the file.
@@ skipping 13 matching lines @@
    */
   goog.addDependency = function(path, provides, requires) {
     provides.forEach(function(provide) {
       dependencyProvidesToPaths[provide] = path;
     });
     dependencyPathsToRequires[path] = requires;
   };
 
   // Read and eval the deps file.  It should only contain goog.addDependency
   // calls.
-  eval(read(depsFile));
+  eval(readJsFile(depsFile));
 }
 
 /**
  * Resolves a list of libraries to an ordered list of paths to load by the
  * generated C++.  The input should contain object names provided
  * by the deps file.  Dependencies will be resolved and included in the
  * correct order, meaning that the returned array may contain more entries
  * than the input.
  * @param {Array<string>} deps List of dependencies.
  * @return {Array<string>} List of paths to load.
@@ skipping 46 matching lines @@
 
   return resultPaths;
 }
 
 /**
  * Output |code| verbatim.
  * @param {string} code The code to output.
  */
 function GEN(code) {
   maybeGenHeader(null);
-  print(code);
+  output(code);
 }
 
 /**
  * Outputs |commentEncodedCode|, converting comment to enclosed C++ code.
  * @param {function} commentEncodedCode A function in the following format (note
  * the space in '/ *' and '* /' should be removed to form a comment delimiter):
  *    function() {/ *! my_cpp_code.DoSomething(); * /
  *    Code between / *! and * / will be extracted and written to stdout.
  */
 function GEN_BLOCK(commentEncodedCode) {
   var code = commentEncodedCode.toString().
       replace(/^[^\/]+\/\*!?/, '').
       replace(/\*\/[^\/]+$/, '').
       replace(/^\n|\n$/, '').
       replace(/\s+$/, '');
   GEN(code);
 }
 
 /**
  * Generate includes for the current |jsFile| by including them
  * immediately and at runtime.
  * The paths must be relative to the directory of the current file.
  * @param {Array<string>} includes Paths to JavaScript files to
  *     include immediately and at runtime.
  */
 function GEN_INCLUDE(includes) {
   for (var i = 0; i < includes.length; i++) {
     var includePaths = includeFileToPaths(includes[i]);
-    var js = read(includePaths.path);
+    var js = readJsFile(includePaths.path);
     pathStack.push(includePaths);
     ('global', eval)(js);
     pathStack.pop();
     genIncludes.push(includePaths.base);
   }
 }
 
 /**
  * Generate gtest-style TEST_F definitions for C++ with a body that
  * will invoke the |testBody| for |testFixture|.|testFunction|.
  * @param {string} testFixture The name of this test's fixture.
  * @param {string} testFunction The name of this test's function.
  * @param {Function} testBody The function body to execute for this test.
  */
 function TEST_F(testFixture, testFunction, testBody) {
   maybeGenHeader(testFixture);
   var browsePreload = this[testFixture].prototype.browsePreload;
   var browsePrintPreload = this[testFixture].prototype.browsePrintPreload;
   var testGenPreamble = this[testFixture].prototype.testGenPreamble;
   var testGenPostamble = this[testFixture].prototype.testGenPostamble;
   var typedefCppFixture = this[testFixture].prototype.typedefCppFixture;
   var isAsyncParam = testType === 'unit' ? '' :
-      this[testFixture].prototype.isAsync + ', ';
+      this[testFixture].prototype.isAsync + ',\n          ';
   var testShouldFail = this[testFixture].prototype.testShouldFail;
   var testPredicate = testShouldFail ? 'ASSERT_FALSE' : 'ASSERT_TRUE';
   var extraLibraries = genIncludes.concat(
       this[testFixture].prototype.extraLibraries.map(
           function(includeFile) {
             return includeFileToPaths(includeFile).base;
           }),
       resolveClosureModuleDeps(this[testFixture].prototype.closureModuleDeps));
 
   if (typedefCppFixture && !(testFixture in typedeffedCppFixtures)) {
     var switches = this[testFixture].prototype.commandLineSwitches;
     if (!switches || !switches.length || typedefCppFixture == 'V8UnitTest') {
-      print('typedef ' + typedefCppFixture + ' ' + testFixture + ';');
+      output(`
+typedef ${typedefCppFixture} ${testFixture};
+`);
     } else {
       // Make the testFixture a class inheriting from the base fixture.
-      print('class ' + testFixture + ' : public ' + typedefCppFixture + ' {');
-      print(' private:');
+      output(`
+class ${testFixture} : public ${typedefCppFixture} {
+ private:`);
       // Override SetUpCommandLine and add each switch.
-      print('  void');
-      print('  SetUpCommandLine(base::CommandLine* command_line) override {');
+      output(`
+  void SetUpCommandLine(base::CommandLine* command_line) override {`);
       for (var i = 0; i < switches.length; i++) {
-        print('    command_line->AppendSwitchASCII(');
-        print('        "' + switches[i].switchName + '",');
-        print('        "' + (switches[i].switchValue || '') + '");');
+        output(`
+    command_line->AppendSwitchASCII(
+        "${switches[i].switchName}",
+        "${(switches[i].switchValue || '')}");`);
       }
-      print('  }');
-      print('};');
+      output(`
+  }
+};
+`);
     }
     typedeffedCppFixtures[testFixture] = typedefCppFixture;
   }
 
-  print(testF + '(' + testFixture + ', ' + testFunction + ') {');
+  output(`${testF}(${testFixture}, ${testFunction}) {`);
   for (var i = 0; i < extraLibraries.length; i++) {
-    print('  AddLibrary(base::FilePath(FILE_PATH_LITERAL("' +
-        extraLibraries[i].replace(/\\/g, '/') + '")));');
+    var libraryName = extraLibraries[i].replace(/\\/g, '/');
+    output(`
+  AddLibrary(base::FilePath(FILE_PATH_LITERAL(
+      "${libraryName}")));`);
   }
-  print('  AddLibrary(base::FilePath(FILE_PATH_LITERAL("' +
-      jsFileBase.replace(/\\/g, '/') + '")));');
+  output(`
+  AddLibrary(base::FilePath(FILE_PATH_LITERAL(
+      "${jsFileBase.replace(/\\/g, '/')}")));`);
   if (addSetPreloadInfo) {
-    print('  set_preload_test_fixture("' + testFixture + '");');
-    print('  set_preload_test_name("' + testFunction + '");');
+    output(`
+  set_preload_test_fixture("${testFixture}");
+  set_preload_test_name("${testFunction}");`);
   }
   if (testGenPreamble)
     testGenPreamble(testFixture, testFunction);
   if (browsePreload)
-    print('  BrowsePreload(GURL("' + browsePreload + '"));');
+    output(`  BrowsePreload(GURL("${browsePreload}"));`);
   if (browsePrintPreload) {
-    print('  BrowsePrintPreload(GURL(WebUITestDataPathToURL(\n' +
-          '      FILE_PATH_LITERAL("' + browsePrintPreload + '"))));');
+    output(`
+  BrowsePrintPreload(GURL(WebUITestDataPathToURL(
+    FILE_PATH_LITERAL("${browsePrintPreload}"))));`);
   }
-  print('  ' + testPredicate + '(RunJavascriptTestF(' + isAsyncParam +
-        '"' + testFixture + '", ' +
-        '"' + testFunction + '"));');
+  output(`
+  ${testPredicate}(
+      RunJavascriptTestF(
+          ${isAsyncParam}"${testFixture}",
+          "${testFunction}"));`);
   if (testGenPostamble)
     testGenPostamble(testFixture, testFunction);
-  print('}');
-  print();
+  output('}\n');
 }
 
 // Now that generation functions are defined, load in |jsFile|.
-var js = read(jsFile);
+var js = readJsFile(jsFile);
 pathStack.push({path: jsFile, base: jsFileBase});
 eval(js);
 pathStack.pop();
+print(pendingOutput);