Bug 1390106 - Stop using versioned scripts in tests. r=jmaher
authorMasatoshi Kimura <VYV03354@nifty.ne.jp>
Mon, 14 Aug 2017 20:46:55 +0900
changeset 374917 92e4bdf39c1fab4afa5da005e24cca36cdebfcc3
parent 374916 e943579bb054fe3fa18ffa468e821ca703ae46c0
child 374918 610617beb53b8f4aa28b77b5e608ae23e76a05f6
push id32343
push usercbook@mozilla.com
push dateWed, 16 Aug 2017 09:20:56 +0000
treeherdermozilla-central@0aa944d3ac94 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjmaher
bugs1390106
milestone57.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1390106 - Stop using versioned scripts in tests. r=jmaher MozReview-Commit-ID: ErqU4M1f7Oj
devtools/shared/heapsnapshot/tests/gtest/DevTools.h
ipc/testshell/XPCShellEnvironment.cpp
testing/xpcshell/selftest.py
toolkit/modules/tests/xpcshell/test_DeferredTask.js
toolkit/modules/tests/xpcshell/test_task.js
xpcom/tests/gtest/TestGCPostBarriers.cpp
--- a/devtools/shared/heapsnapshot/tests/gtest/DevTools.h
+++ b/devtools/shared/heapsnapshot/tests/gtest/DevTools.h
@@ -84,17 +84,17 @@ struct DevTools : public ::testing::Test
     return &globalClass;
   }
 
   JSObject* createGlobal()
   {
     /* Create the global object. */
     JS::RootedObject newGlobal(cx);
     JS::CompartmentOptions options;
-    options.behaviors().setVersion(JSVERSION_LATEST);
+    options.behaviors().setVersion(JSVERSION_DEFAULT);
     newGlobal = JS_NewGlobalObject(cx, getGlobalClass(), nullptr,
                                    JS::FireOnNewGlobalHook, options);
     if (!newGlobal)
       return nullptr;
 
     JSAutoCompartment ac(cx, newGlobal);
 
     /* Populate the global object with the standard globals, like Object and
--- a/ipc/testshell/XPCShellEnvironment.cpp
+++ b/ipc/testshell/XPCShellEnvironment.cpp
@@ -446,17 +446,17 @@ XPCShellEnvironment::Init()
     rv = NS_NewBackstagePass(getter_AddRefs(backstagePass));
     if (NS_FAILED(rv)) {
         NS_ERROR("Failed to create backstage pass!");
         return false;
     }
 
     JS::CompartmentOptions options;
     options.creationOptions().setSystemZone();
-    options.behaviors().setVersion(JSVERSION_LATEST);
+    options.behaviors().setVersion(JSVERSION_DEFAULT);
     if (xpc::SharedMemoryEnabled())
         options.creationOptions().setSharedMemoryAndAtomicsEnabled(true);
 
     nsCOMPtr<nsIXPConnectJSObjectHolder> holder;
     rv = xpc->InitClassesWithNewWrappedGlobal(cx,
                                               static_cast<nsIGlobalObject *>(backstagePass),
                                               principal, 0,
                                               options,
--- a/testing/xpcshell/selftest.py
+++ b/testing/xpcshell/selftest.py
@@ -154,52 +154,52 @@ add_test(function test_unicode_print () 
 });
 '''
 
 ADD_TASK_SINGLE = '''
 Components.utils.import("resource://gre/modules/Promise.jsm");
 
 function run_test() { run_next_test(); }
 
-add_task(function test_task() {
+add_task(function* test_task() {
   yield Promise.resolve(true);
   yield Promise.resolve(false);
 });
 '''
 
 ADD_TASK_MULTIPLE = '''
 Components.utils.import("resource://gre/modules/Promise.jsm");
 
 function run_test() { run_next_test(); }
 
-add_task(function test_task() {
+add_task(function* test_task() {
   yield Promise.resolve(true);
 });
 
-add_task(function test_2() {
+add_task(function* test_2() {
   yield Promise.resolve(true);
 });
 '''
 
 ADD_TASK_REJECTED = '''
 Components.utils.import("resource://gre/modules/Promise.jsm");
 
 function run_test() { run_next_test(); }
 
-add_task(function test_failing() {
+add_task(function* test_failing() {
   yield Promise.reject(new Error("I fail."));
 });
 '''
 
 ADD_TASK_FAILURE_INSIDE = '''
 Components.utils.import("resource://gre/modules/Promise.jsm");
 
 function run_test() { run_next_test(); }
 
-add_task(function test() {
+add_task(function* test() {
   let result = yield Promise.resolve(false);
 
   do_check_true(result);
 });
 '''
 
 ADD_TASK_RUN_NEXT_TEST = '''
 function run_test() { run_next_test(); }
@@ -219,29 +219,16 @@ function run_test() { run_next_test(); }
 add_task(function* this_test_will_fail() {
   for (let i = 0; i < 10; ++i) {
     yield Promise.resolve();
   }
   Assert.ok(false);
 });
 '''
 
-ADD_TASK_STACK_TRACE_WITHOUT_STAR = '''
-Components.utils.import("resource://gre/modules/Promise.jsm", this);
-
-function run_test() { run_next_test(); }
-
-add_task(function this_test_will_fail() {
-  for (let i = 0; i < 10; ++i) {
-    yield Promise.resolve();
-  }
-  Assert.ok(false);
-});
-'''
-
 ADD_TASK_SKIP = '''
 add_task(async function skipMeNot1() {
   Assert.ok(true, "Well well well.");
 });
 
 add_task(async function skipMe1() {
   Assert.ok(false, "Not skipped after all.");
 }).skip();
@@ -325,18 +312,17 @@ function run_test() {
 # A test for failure to load a test due to a syntax error
 LOAD_ERROR_SYNTAX_ERROR = '''
 function run_test(
 '''
 
 # A test for failure to load a test due to an error other than a syntax error
 LOAD_ERROR_OTHER_ERROR = '''
 function run_test() {
-    yield "foo";
-    return "foo"; // can't use return in a generator!
+    1 = "foo"; // invalid assignment left-hand side
 };
 '''
 
 # A test for asynchronous cleanup functions
 ASYNC_CLEANUP = '''
 function run_test() {
   Components.utils.import("resource://gre/modules/Promise.jsm", this);
 
@@ -431,21 +417,21 @@ NO_RUN_TEST_ADD_TASK_FAIL = '''
 add_task(function no_run_test_add_task_fail() {
   do_check_true(false);
 });
 '''
 
 NO_RUN_TEST_ADD_TASK_MULTIPLE = '''
 Components.utils.import("resource://gre/modules/Promise.jsm");
 
-add_task(function test_task() {
+add_task(function* test_task() {
   yield Promise.resolve(true);
 });
 
-add_task(function test_2() {
+add_task(function* test_2() {
   yield Promise.resolve(true);
 });
 '''
 
 LOAD_MOZINFO = '''
 function run_test() {
   do_check_neq(typeof mozinfo, undefined);
   do_check_neq(typeof mozinfo.os, undefined);
@@ -1061,32 +1047,16 @@ add_test({
         self.writeManifest(["test_add_task_stack_trace.js"])
 
         self.assertTestResult(False)
         self.assertInLog("this_test_will_fail")
         self.assertInLog("run_next_test")
         self.assertInLog("run_test")
         self.assertNotInLog("Task.jsm")
 
-    def testAddTaskStackTraceWithoutStar(self):
-        """
-        Ensuring that calling Assert.ok(false) from inside add_task()
-        results in a human-readable stack trace. This variant uses deprecated
-        `function()` syntax instead of now standard `function*()`.
-        """
-        self.writeFile("test_add_task_stack_trace_without_star.js",
-            ADD_TASK_STACK_TRACE)
-        self.writeManifest(["test_add_task_stack_trace_without_star.js"])
-
-        self.assertTestResult(False)
-        self.assertInLog("this_test_will_fail")
-        self.assertInLog("run_next_test")
-        self.assertInLog("run_test")
-        self.assertNotInLog("Task.jsm")
-
     def testAddTaskSkip(self):
         self.writeFile("test_tasks_skip.js", ADD_TASK_SKIP)
         self.writeManifest(["test_tasks_skip.js"])
 
         self.assertTestResult(True)
         self.assertEquals(1, self.x.testCount)
         self.assertEquals(1, self.x.passCount)
         self.assertEquals(0, self.x.failCount)
@@ -1211,18 +1181,18 @@ add_test({
         Check that attempting to load a test file containing an error other
         than a syntax error generates details of the error in the log
         """
         self.writeFile("test_error.js", LOAD_ERROR_OTHER_ERROR)
         self.writeManifest(["test_error.js"])
 
         self.assertTestResult(False)
         self.assertInLog(TEST_FAIL_STRING)
-        self.assertInLog("TypeError: generator function can't return a value at")
-        self.assertInLog("test_error.js:4")
+        self.assertInLog("ReferenceError: invalid assignment left-hand side at")
+        self.assertInLog("test_error.js:3")
         self.assertNotInLog(TEST_PASS_STRING)
 
     def testDoPrintWhenVerboseNotExplicit(self):
         """
         Check that do_print() and similar calls that generate output do
         not have the output when not run verbosely.
         """
         self.writeFile("test_verbose.js", ADD_TEST_VERBOSE)
--- a/toolkit/modules/tests/xpcshell/test_DeferredTask.js
+++ b/toolkit/modules/tests/xpcshell/test_DeferredTask.js
@@ -179,38 +179,35 @@ add_test(function test_arm_async() {
   do_timeout(13 * T, function() {
     do_check_false(deferredTask.isRunning);
     do_check_true(finishedExecutionAgain);
     run_next_test();
   });
 });
 
 /**
- * Checks that "arm" accepts a Task.jsm generator function.
+ * Checks that "arm" accepts a Task.jsm async function.
  */
-add_test(function test_arm_async_generator() {
+add_test(function test_arm_async_function() {
   let deferredTask = new DeferredTask(async function() {
     await Promise.resolve();
     run_next_test();
   }, 50);
 
   deferredTask.arm();
 });
 
 /**
- * Checks that "arm" accepts a Task.jsm legacy generator function.
+ * Checks that "arm" accepts a Task.jsm generator function.
  */
-add_test(function test_arm_async_legacy_generator() {
-  // ESLint cannot parse legacy generator functions, so we need an eval block.
-  /* eslint-disable no-eval */
-  let deferredTask = new DeferredTask(eval(`(function() {
+add_test(function test_arm_async_generator() {
+  let deferredTask = new DeferredTask(function*() {
     yield Promise.resolve();
     run_next_test();
-  })`), 50);
-  /* eslint-enable no-eval */
+  }, 50);
 
   deferredTask.arm();
 });
 
 /**
  * Checks that an armed task can be disarmed.
  */
 add_test(function test_disarm() {
--- a/toolkit/modules/tests/xpcshell/test_task.js
+++ b/toolkit/modules/tests/xpcshell/test_task.js
@@ -33,66 +33,16 @@ function promiseResolvedLater(aValue) {
 ////////////////////////////////////////////////////////////////////////////////
 /// Tests
 
 function run_test()
 {
   run_next_test();
 }
 
-add_test(function test_normal()
-{
-  Task.spawn(function () {
-    let result = yield Promise.resolve("Value");
-    for (let i = 0; i < 3; i++) {
-      result += yield promiseResolvedLater("!");
-    }
-    throw new Task.Result("Task result: " + result);
-  }).then(function (result) {
-    do_check_eq("Task result: Value!!!", result);
-    run_next_test();
-  }, function (ex) {
-    do_throw("Unexpected error: " + ex);
-  });
-});
-
-add_test(function test_exceptions()
-{
-  Task.spawn(function () {
-    try {
-      yield Promise.reject("Rejection result by promise.");
-      do_throw("Exception expected because the promise was rejected.");
-    } catch (ex) {
-      // We catch this exception now, we will throw a different one later.
-      do_check_eq("Rejection result by promise.", ex);
-    }
-    throw new Error("Exception uncaught by task.");
-  }).then(function (result) {
-    do_throw("Unexpected success!");
-  }, function (ex) {
-    do_check_eq("Exception uncaught by task.", ex.message);
-    run_next_test();
-  });
-});
-
-add_test(function test_recursion()
-{
-  function task_fibonacci(n) {
-    throw new Task.Result(n < 2 ? n : (yield task_fibonacci(n - 1)) +
-                                      (yield task_fibonacci(n - 2)));
-  };
-
-  Task.spawn(task_fibonacci(6)).then(function (result) {
-    do_check_eq(8, result);
-    run_next_test();
-  }, function (ex) {
-    do_throw("Unexpected error: " + ex);
-  });
-});
-
 add_test(function test_spawn_primitive()
 {
   function fibonacci(n) {
     return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
   };
 
   // Polymorphism between task and non-task functions (see "test_recursion").
   Task.spawn(fibonacci(6)).then(function (result) {
@@ -178,31 +128,31 @@ add_test(function test_spawn_function_ta
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 
 add_test(function test_yielded_undefined()
 {
-  Task.spawn(function () {
+  Task.spawn(function* () {
     yield;
-    throw new Task.Result("We continued correctly.");
+    return "We continued correctly.";
   }).then(function (result) {
     do_check_eq("We continued correctly.", result);
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 
 add_test(function test_yielded_primitive()
 {
-  Task.spawn(function () {
-    throw new Task.Result("Primitive " + (yield "value."));
+  Task.spawn(function* () {
+    return "Primitive " + (yield "value.");
   }).then(function (result) {
     do_check_eq("Primitive value.", result);
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 
@@ -251,21 +201,21 @@ add_test(function test_star_recursion()
   Task.spawn(task_fibonacci(6)).then(function (result) {
     do_check_eq(8, result);
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 
-add_test(function test_mixed_legacy_and_star()
+add_test(function test_nested_star()
 {
   Task.spawn(function* () {
-    return yield (function() {
-      throw new Task.Result(yield 5);
+    return yield (function* () {
+      return yield 5;
     })();
   }).then(function (result) {
     do_check_eq(5, result);
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
--- a/xpcom/tests/gtest/TestGCPostBarriers.cpp
+++ b/xpcom/tests/gtest/TestGCPostBarriers.cpp
@@ -92,17 +92,17 @@ CreateGlobalAndRunTest(JSContext* cx)
   };
 
   static const JSClass GlobalClass = {
     "global", JSCLASS_GLOBAL_FLAGS,
     &GlobalClassOps
   };
 
   JS::CompartmentOptions options;
-  options.behaviors().setVersion(JSVERSION_LATEST);
+  options.behaviors().setVersion(JSVERSION_DEFAULT);
   JS::PersistentRootedObject global(cx);
   global = JS_NewGlobalObject(cx, &GlobalClass, nullptr, JS::FireOnNewGlobalHook, options);
   ASSERT_TRUE(global != nullptr);
 
   JSCompartment *oldCompartment = JS_EnterCompartment(cx, global);
 
   typedef Heap<JSObject*> ElementT;