Migrate Remoting Webapp Unittests to use QUnit 2.0 syntax.

remoting/webapp/base/js/base_unittest.js

Index: remoting/webapp/base/js/base_unittest.js
diff --git a/remoting/webapp/base/js/base_unittest.js b/remoting/webapp/base/js/base_unittest.js
index a5a6a6f6049ac6022f3d6a137a3a06db5c8ad1e0..0f1073900f20b7350fc62bfcc82c0744e49b994a 100644
--- a/remoting/webapp/base/js/base_unittest.js
+++ b/remoting/webapp/base/js/base_unittest.js
@@ -6,18 +6,18 @@
 
 'use strict';
 
-module('base');
+QUnit.module('base');
 
-test('mix(dest, src) should copy properties from |src| to |dest|',
+QUnit.test('mix(dest, src) should copy properties from |src| to |dest|',
   function() {
     var src = { a: 'a', b: 'b'};
     var dest = { c: 'c'};
 
     base.mix(dest, src);
-    deepEqual(dest, {a: 'a', b: 'b', c: 'c'});
+    QUnit.deepEqual(dest, {a: 'a', b: 'b', c: 'c'});
 });
 
-test('mix(dest, src) should assert if properties are overwritten',
+QUnit.test('mix(dest, src) should assert if properties are overwritten',
   function() {
     var src = { a: 'a', b: 'b'};
     var dest = { a: 'a'};
@@ -33,21 +33,21 @@ test('mix(dest, src) should assert if properties are overwritten',
     }
 });
 
-test('values(obj) should return an array containing the values of |obj|',
+QUnit.test('values(obj) should return an array containing the values of |obj|',
   function() {
     var output = base.values({ a: 'a', b: 'b'});
 
-    notEqual(output.indexOf('a'), -1, '"a" should be in the output');
-    notEqual(output.indexOf('b'), -1, '"b" should be in the output');
+    QUnit.notEqual(output.indexOf('a'), -1, '"a" should be in the output');
+    QUnit.notEqual(output.indexOf('b'), -1, '"b" should be in the output');
 });
 
-test('deepCopy(obj) should return null on NaN and undefined',
+QUnit.test('deepCopy(obj) should return null on NaN and undefined',
   function() {
     QUnit.equal(base.deepCopy(NaN), null);
     QUnit.equal(base.deepCopy(undefined), null);
 });
 
-test('deepCopy(obj) should copy primitive types recursively',
+QUnit.test('deepCopy(obj) should copy primitive types recursively',
   function() {
     QUnit.equal(base.deepCopy(1), 1);
     QUnit.equal(base.deepCopy('hello'), 'hello');
@@ -62,7 +62,7 @@ test('deepCopy(obj) should copy primitive types recursively',
     QUnit.deepEqual(base.deepCopy([1, [2, [3]]]), [1, [2, [3]]]);
 });
 
-test('modify the original after deepCopy(obj) should not affect the copy',
+QUnit.test('modify the original after deepCopy(obj) should not affect the copy',
   function() {
     var original = [1, 2, 3, 4];
     var copy = base.deepCopy(original);
@@ -70,7 +70,7 @@ test('modify the original after deepCopy(obj) should not affect the copy',
     QUnit.deepEqual(copy, [1, 2, 3, 4]);
 });
 
-test('dispose(obj) should invoke the dispose method on |obj|',
+QUnit.test('dispose(obj) should invoke the dispose method on |obj|',
   function() {
     /**
      * @constructor
@@ -84,19 +84,20 @@ test('dispose(obj) should invoke the dispose method on |obj|',
     sinon.assert.called(obj.dispose);
 });
 
-test('dispose(obj) should not crash if |obj| is null',
+QUnit.test('dispose(obj) should not crash if |obj| is null',
   function() {
-    expect(0);
+    QUnit.expect(0);
     base.dispose(null);
 });
 
-test('urljoin(url, opt_param) should return url if |opt_param| is missing',
+QUnit.test(
+  'urljoin(url, opt_param) should return url if |opt_param| is missing',
   function() {
     QUnit.equal(
         base.urlJoin('http://www.chromium.org'), 'http://www.chromium.org');
 });
 
-test('urljoin(url, opt_param) should urlencode |opt_param|',
+QUnit.test('urljoin(url, opt_param) should urlencode |opt_param|',
   function() {
     var result = base.urlJoin('http://www.chromium.org', {
       a: 'a',
@@ -109,13 +110,13 @@ test('urljoin(url, opt_param) should urlencode |opt_param|',
         '&escapist=%3A%2F%3F%23%5B%5D%40%24%26%2B%2C%3B%3D');
 });
 
-test('escapeHTML(str) should escape special characters', function() {
+QUnit.test('escapeHTML(str) should escape special characters', function() {
   QUnit.equal(
     base.escapeHTML('<script>alert("hello")</script>'),
     '&lt;script&gt;alert("hello")&lt;/script&gt;');
 });
 
-QUnit.asyncTest('Promise.sleep(delay) should fulfill the promise after |delay|',
+QUnit.test('Promise.sleep(delay) should fulfill the promise after |delay|',
   /**
    * 'this' is not defined for jscompile, so it can't figure out the type of
    * this.clock.
@@ -125,10 +126,9 @@ QUnit.asyncTest('Promise.sleep(delay) should fulfill the promise after |delay|',
     var isCalled = false;
     var clock = /** @type {QUnit.Clock} */ (this.clock);
 
-    base.Promise.sleep(100).then(function(){
+    var promise = base.Promise.sleep(100).then(function(){
       isCalled = true;
-      ok(true, 'Promise.sleep() is fulfilled after delay.');
-      QUnit.start();
+      QUnit.ok(true, 'Promise.sleep() is fulfilled after delay.');
     });
 
     // Tick the clock for 2 seconds and check if the promise is fulfilled.
@@ -137,28 +137,33 @@ QUnit.asyncTest('Promise.sleep(delay) should fulfill the promise after |delay|',
     // Promise fulfillment always occur on a new stack.  Therefore, we will run
     // the verification in a requestAnimationFrame.
     window.requestAnimationFrame(function(){
-      ok(!isCalled, 'Promise.sleep() should not be fulfilled prematurely.');
+      QUnit.ok(
+          !isCalled, 'Promise.sleep() should not be fulfilled prematurely.');
       clock.tick(101);
     });
+
+    return promise;
 });
 
-QUnit.asyncTest('Promise.negate should fulfill iff the promise does not.',
+QUnit.test('Promise.negate should fulfill iff the promise does not.',
   function() {
-
-    base.Promise.negate(Promise.reject()).then(
-        QUnit.ok.bind(null, true),
-        /** @type {Function} */ (QUnit.ok.bind(null, false)));
-    base.Promise.negate(Promise.resolve()).then(
-        QUnit.ok.bind(null, false),
-        /** @type {Function} */ (QUnit.ok.bind(null, true)));
-    window.requestAnimationFrame(function(){
-      QUnit.start();
+    return base.Promise.negate(Promise.reject())
+    .then(function() {
+      QUnit.ok(true);
+    }).catch(function() {
+      QUnit.ok(false);
+    }).then(function() {
+      return base.Promise.negate(Promise.resolve());
+    }).then(function() {
+      QUnit.ok(false);
+    }).catch(function() {
+      QUnit.ok(true);
     });
 });
 
-module('base.Deferred');
+QUnit.module('base.Deferred');
 
-QUnit.asyncTest('resolve() should fulfill the underlying promise.', function() {
+QUnit.test('resolve() should fulfill the underlying promise.', function() {
   /** @returns {Promise} */
   function async() {
     var deferred = new base.Deferred();
@@ -166,17 +171,14 @@ QUnit.asyncTest('resolve() should fulfill the underlying promise.', function() {
     return deferred.promise();
   }
 
-  async().then(
-      /** @param {string} value */
-      function(value){
-          QUnit.equal(value, 'bar');
-          QUnit.start();
-      }, function() {
-          QUnit.ok(false, 'The reject handler should not be invoked.');
-      });
+  return async().then(function(/** string */ value){
+    QUnit.equal(value, 'bar');
+  }, function() {
+    QUnit.ok(false, 'The reject handler should not be invoked.');
+  });
 });
 
-QUnit.asyncTest('reject() should fail the underlying promise.', function() {
+QUnit.test('reject() should fail the underlying promise.', function() {
   /** @returns {Promise} */
   function async() {
     var deferred = new base.Deferred();
@@ -184,11 +186,10 @@ QUnit.asyncTest('reject() should fail the underlying promise.', function() {
     return deferred.promise();
   }
 
-  async().then(function(){
+  return async().then(function(){
     QUnit.ok(false, 'The then handler should not be invoked.');
   }, function(value) {
     QUnit.equal(value, 'bar');
-    QUnit.start();
   });
 });
 
@@ -197,25 +198,26 @@ QUnit.asyncTest('reject() should fail the underlying promise.', function() {
 var source = null;
 var listener = null;
 
-module('base.EventSource', {
-  setup: function() {
+QUnit.module('base.EventSource', {
+  beforeEach: function() {
     source = new base.EventSourceImpl();
     source.defineEvents(['foo', 'bar']);
     listener = sinon.spy();
     source.addEventListener('foo', listener);
   },
-  teardown: function() {
+  afterEach: function() {
     source = null;
     listener = null;
   }
 });
 
-test('raiseEvent() should invoke the listener', function() {
+QUnit.test('raiseEvent() should invoke the listener', function() {
   source.raiseEvent('foo');
   sinon.assert.called(listener);
 });
 
-test('raiseEvent() should invoke the listener with the correct event data',
+QUnit.test(
+  'raiseEvent() should invoke the listener with the correct event data',
   function() {
     var data = {
       field: 'foo'
@@ -224,25 +226,25 @@ test('raiseEvent() should invoke the listener with the correct event data',
     sinon.assert.calledWith(listener, data);
 });
 
-test(
+QUnit.test(
   'raiseEvent() should not invoke listeners that are added during raiseEvent',
   function() {
     source.addEventListener('foo', function() {
       source.addEventListener('foo', function() {
-        ok(false);
+        QUnit.ok(false);
       });
-      ok(true);
+     QUnit.ok(true);
     });
     source.raiseEvent('foo');
 });
 
-test('raiseEvent() should not invoke listeners of a different event',
+QUnit.test('raiseEvent() should not invoke listeners of a different event',
   function() {
     source.raiseEvent('bar');
     sinon.assert.notCalled(listener);
 });
 
-test('raiseEvent() should assert when undeclared events are raised',
+QUnit.test('raiseEvent() should assert when undeclared events are raised',
   function() {
     sinon.stub(base.debug, 'assert');
     try {
@@ -254,7 +256,7 @@ test('raiseEvent() should assert when undeclared events are raised',
     }
 });
 
-test(
+QUnit.test(
   'removeEventListener() should not invoke the listener in subsequent ' +
   'calls to |raiseEvent|',
   function() {
@@ -266,7 +268,7 @@ test(
     sinon.assert.calledOnce(listener);
 });
 
-test('removeEventListener() should work even if the listener ' +
+QUnit.test('removeEventListener() should work even if the listener ' +
   'is removed during |raiseEvent|',
   function() {
     var sink = {};
@@ -282,7 +284,7 @@ test('removeEventListener() should work even if the listener ' +
     sinon.assert.calledOnce(sink.listener);
 });
 
-test('encodeUtf8() can encode UTF8 strings', function() {
+QUnit.test('encodeUtf8() can encode UTF8 strings', function() {
   /** @type {function(ArrayBuffer):Array} */
   function toJsArray(arrayBuffer) {
     var result = [];
@@ -306,7 +308,7 @@ test('encodeUtf8() can encode UTF8 strings', function() {
                   [0xF0, 0x9F, 0x98, 0x83]);
 });
 
-test('decodeUtf8() can decode UTF8 strings', function() {
+QUnit.test('decodeUtf8() can decode UTF8 strings', function() {
   // ASCII.
   QUnit.equal(base.decodeUtf8(new Uint8Array([0x41, 0x42, 0x43]).buffer),
               "ABC");