Added more typechecking functions and unit tests for existing code.

remoting/webapp/crd/js/typecheck_unittest.js

Index: remoting/webapp/crd/js/typecheck_unittest.js
diff --git a/remoting/webapp/crd/js/typecheck_unittest.js b/remoting/webapp/crd/js/typecheck_unittest.js
new file mode 100644
index 0000000000000000000000000000000000000000..c7b93c90db2eaa03803f6c0afebe66e88e9b2d2e
--- /dev/null
+++ b/remoting/webapp/crd/js/typecheck_unittest.js
@@ -0,0 +1,240 @@
+// Copyright 2015 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.
+
+(function() {
+
+'use strict';
+
+var anArray = ['an array'];
+var aBoolean = false;
+var aNumber = 42;
+var anObject = {name: 'my object'};
+var aString = 'woo';
+
+var anotherArray = ['another array'];
+var anotherBoolean = true;
+var anotherNumber = -42;
+var anotherObject = {name: 'a bad object'};
+var anotherString = 'boo!';
+
+var testObj = {
+  anArray: anArray,
+  aBoolean: aBoolean,
+  aNumber: aNumber,
+  anObject: anObject,
+  aString: aString,
+  aNull: null,
+  anUndefined: undefined
+};
+
+QUnit.module('typecheck');
+
+QUnit.test('base.assertArray', function(/** QUnit.Assert */ assert) {
+  assert.strictEqual(base.assertArray(anArray), anArray);
+  assert.throws(base.assertArray.bind(null, aBoolean), Error);
+  assert.throws(base.assertArray.bind(null, aNumber), Error);
+  assert.throws(base.assertArray.bind(null, anObject), Error);
+  assert.throws(base.assertArray.bind(null, aString), Error);
+  assert.throws(base.assertArray.bind(null, null), Error);
+  assert.throws(base.assertArray.bind(null, undefined), Error);
+});
+
+QUnit.test('base.assertBoolean', function(/** QUnit.Assert */ assert) {
+  assert.strictEqual(base.assertBoolean(aBoolean), aBoolean);
+  assert.throws(base.assertNumber.bind(null, anArray), Error);
+  assert.throws(base.assertBoolean.bind(null, aNumber), Error);
+  assert.throws(base.assertBoolean.bind(null, anObject), Error);
+  assert.throws(base.assertBoolean.bind(null, aString), Error);
+  assert.throws(base.assertBoolean.bind(null, null), Error);
+  assert.throws(base.assertBoolean.bind(null, undefined), Error);
+});
+
+QUnit.test('base.assertNumber', function(/** QUnit.Assert */ assert) {
+  assert.strictEqual(base.assertNumber(aNumber), aNumber);
+  assert.throws(base.assertNumber.bind(null, anArray), Error);
+  assert.throws(base.assertNumber.bind(null, aBoolean), Error);
+  assert.throws(base.assertNumber.bind(null, anObject), Error);
+  assert.throws(base.assertNumber.bind(null, aString), Error);
+  assert.throws(base.assertNumber.bind(null, null), Error);
+  assert.throws(base.assertNumber.bind(null, undefined), Error);
+});
+
+QUnit.test('base.assertObject', function(/** QUnit.Assert */ assert) {
+  assert.strictEqual(base.assertObject(anObject), anObject);
+  assert.throws(base.assertObject.bind(null, anArray), Error);
+  assert.throws(base.assertObject.bind(null, aBoolean), Error);
+  assert.throws(base.assertObject.bind(null, aNumber), Error);
+  assert.throws(base.assertObject.bind(null, aString), Error);
+  assert.throws(base.assertObject.bind(null, null), Error);
+  assert.throws(base.assertObject.bind(null, undefined), Error);
+});
+
+QUnit.test('base.assertString', function(/** QUnit.Assert */ assert) {
+  assert.strictEqual(base.assertString(aString), aString);
+  assert.throws(base.assertString.bind(null, anArray), Error);
+  assert.throws(base.assertString.bind(null, aBoolean), Error);
+  assert.throws(base.assertString.bind(null, aNumber), Error);
+  assert.throws(base.assertString.bind(null, anObject), Error);
+  assert.throws(base.assertString.bind(null, null), Error);
+  assert.throws(base.assertString.bind(null, undefined), Error);
+});
+
+
+QUnit.test('base.getArrayAttr', function(/** QUnit.Assert */ assert) {
+  assert.strictEqual(base.getArrayAttr(testObj, 'anArray'), anArray);
+  assert.strictEqual(
+      base.getArrayAttr(testObj, 'anArray', anotherArray),
+      anArray);
+
+  assert.throws(base.getArrayAttr.bind(null, testObj, 'aBoolean'), Error);
+  assert.throws(base.getArrayAttr.bind(null, testObj, 'aNumber'), Error);
+  assert.throws(base.getArrayAttr.bind(null, testObj, 'anObject'), Error);
+  assert.throws(base.getArrayAttr.bind(null, testObj, 'aString'), Error);
+  assert.throws(base.getArrayAttr.bind(null, testObj, 'aNull'), Error);
+  assert.throws(base.getArrayAttr.bind(null, testObj, 'anUndefined'), Error);
+  assert.throws(base.getArrayAttr.bind(null, testObj, 'noSuchKey'), Error);
+
+  assert.strictEqual(
+      base.getArrayAttr(testObj, 'aBoolean', anotherArray), anotherArray);
+  assert.strictEqual(
+      base.getArrayAttr(testObj, 'aNumber', anotherArray), anotherArray);
+  assert.strictEqual(
+      base.getArrayAttr(testObj, 'anObject', anotherArray), anotherArray);
+  assert.strictEqual(
+      base.getArrayAttr(testObj, 'aString', anotherArray), anotherArray);
+  assert.strictEqual(
+      base.getArrayAttr(testObj, 'aNull', anotherArray), anotherArray);
+  assert.strictEqual(
+      base.getArrayAttr(testObj, 'anUndefined', anotherArray), anotherArray);
+  assert.strictEqual(
+      base.getArrayAttr(testObj, 'noSuchKey', anotherArray), anotherArray);
+});
+
+QUnit.test('base.getBooleanAttr', function(/** QUnit.Assert */ assert) {
+  assert.strictEqual(base.getBooleanAttr(testObj, 'aBoolean'), aBoolean);
+  assert.strictEqual(
+      base.getBooleanAttr(testObj, 'aBoolean', anotherBoolean), aBoolean);
+
+  assert.throws(base.getBooleanAttr.bind(null, testObj, 'anArray'), Error);
+  assert.throws(base.getBooleanAttr.bind(null, testObj, 'aNumber'), Error);
+  assert.throws(base.getBooleanAttr.bind(null, testObj, 'anObject'), Error);
+  assert.throws(base.getBooleanAttr.bind(null, testObj, 'aString'), Error);
+  assert.throws(base.getBooleanAttr.bind(null, testObj, 'aNull'), Error);
+  assert.throws(base.getBooleanAttr.bind(null, testObj, 'anUndefined'), Error);
+  assert.throws(base.getBooleanAttr.bind(null, testObj, 'noSuchKey'), Error);
+
+  assert.strictEqual(
+      base.getBooleanAttr(testObj, 'anArray', anotherBoolean),
+      anotherBoolean);
+  assert.strictEqual(
+      base.getBooleanAttr(testObj, 'aNumber', anotherBoolean),
+      anotherBoolean);
+  assert.strictEqual(
+      base.getBooleanAttr(testObj, 'anObject', anotherBoolean),
+      anotherBoolean);
+  assert.strictEqual(
+      base.getBooleanAttr(testObj, 'aString', anotherBoolean),
+      anotherBoolean);
+  assert.strictEqual(
+      base.getBooleanAttr(testObj, 'aNull', anotherBoolean),
+      anotherBoolean);
+  assert.strictEqual(
+      base.getBooleanAttr(testObj, 'anUndefined', anotherBoolean),
+      anotherBoolean);
+  assert.strictEqual(
+      base.getBooleanAttr(testObj, 'noSuchKey', anotherBoolean),
+      anotherBoolean);
+});
+
+QUnit.test('base.getNumberAttr', function(/** QUnit.Assert */ assert) {
+  assert.strictEqual(
+      base.getNumberAttr(testObj, 'aNumber'), aNumber);
+  assert.strictEqual(
+      base.getNumberAttr(testObj, 'aNumber', anotherNumber), aNumber);
+
+  assert.throws(base.getNumberAttr.bind(null, testObj, 'anArray'), Error);
+  assert.throws(base.getNumberAttr.bind(null, testObj, 'aBoolean'), Error);
+  assert.throws(base.getNumberAttr.bind(null, testObj, 'anObject'), Error);
+  assert.throws(base.getNumberAttr.bind(null, testObj, 'aString'), Error);
+  assert.throws(base.getNumberAttr.bind(null, testObj, 'aNull'), Error);
+  assert.throws(base.getNumberAttr.bind(null, testObj, 'anUndefined'), Error);
+  assert.throws(base.getNumberAttr.bind(null, testObj, 'noSuchKey'), Error);
+
+  assert.strictEqual(
+      base.getNumberAttr(testObj, 'anArray', anotherNumber), anotherNumber);
+  assert.strictEqual(
+      base.getNumberAttr(testObj, 'aBoolean', anotherNumber), anotherNumber);
+  assert.strictEqual(
+      base.getNumberAttr(testObj, 'anObject', anotherNumber), anotherNumber);
+  assert.strictEqual(
+      base.getNumberAttr(testObj, 'aString', anotherNumber), anotherNumber);
+  assert.strictEqual(
+      base.getNumberAttr(testObj, 'aNull', anotherNumber), anotherNumber);
+  assert.strictEqual(
+      base.getNumberAttr(testObj, 'anUndefined', anotherNumber), anotherNumber);
+  assert.strictEqual(
+      base.getNumberAttr(testObj, 'noSuchKey', anotherNumber), anotherNumber);
+});
+
+QUnit.test('base.getObjectAttr', function(/** QUnit.Assert */ assert) {
+  assert.strictEqual(
+      base.getObjectAttr(testObj, 'anObject'), anObject);
+  assert.strictEqual(
+      base.getObjectAttr(testObj, 'anObject', anotherObject), anObject);
+
+  assert.throws(base.getObjectAttr.bind(null, testObj, 'anArray'), Error);
+  assert.throws(base.getObjectAttr.bind(null, testObj, 'aBoolean'), Error);
+  assert.throws(base.getObjectAttr.bind(null, testObj, 'aNumber'), Error);
+  assert.throws(base.getObjectAttr.bind(null, testObj, 'aString'), Error);
+  assert.throws(base.getObjectAttr.bind(null, testObj, 'aNull'), Error);
+  assert.throws(base.getObjectAttr.bind(null, testObj, 'anUndefined'), Error);
+  assert.throws(base.getObjectAttr.bind(null, testObj, 'noSuchKey'), Error);
+
+  assert.strictEqual(
+      base.getObjectAttr(testObj, 'anArray', anotherObject), anotherObject);
+  assert.strictEqual(
+      base.getObjectAttr(testObj, 'aBoolean', anotherObject), anotherObject);
+  assert.strictEqual(
+      base.getObjectAttr(testObj, 'aNumber', anotherObject), anotherObject);
+  assert.strictEqual(
+      base.getObjectAttr(testObj, 'aString', anotherObject), anotherObject);
+  assert.strictEqual(
+      base.getObjectAttr(testObj, 'aNull', anotherObject), anotherObject);
+  assert.strictEqual(
+      base.getObjectAttr(testObj, 'anUndefined', anotherObject), anotherObject);
+  assert.strictEqual(
+      base.getObjectAttr(testObj, 'noSuchKey', anotherObject), anotherObject);
+});
+
+QUnit.test('base.getStringAttr', function(/** QUnit.Assert */ assert) {
+  assert.strictEqual(
+      base.getStringAttr(testObj, 'aString'), aString);
+  assert.strictEqual(
+      base.getStringAttr(testObj, 'aString', anotherString), aString);
+
+  assert.throws(base.getStringAttr.bind(null, testObj, 'anArray'), Error);
+  assert.throws(base.getStringAttr.bind(null, testObj, 'aBoolean'), Error);
+  assert.throws(base.getStringAttr.bind(null, testObj, 'aNumber'), Error);
+  assert.throws(base.getStringAttr.bind(null, testObj, 'anObject'), Error);
+  assert.throws(base.getStringAttr.bind(null, testObj, 'aNull'), Error);
+  assert.throws(base.getStringAttr.bind(null, testObj, 'anUndefined'), Error);
+  assert.throws(base.getStringAttr.bind(null, testObj, 'noSuchKey'), Error);
+
+  assert.strictEqual(
+      base.getStringAttr(testObj, 'anArray', anotherString), anotherString);
+  assert.strictEqual(
+      base.getStringAttr(testObj, 'aBoolean', anotherString), anotherString);
+  assert.strictEqual(
+      base.getStringAttr(testObj, 'aNumber', anotherString), anotherString);
+  assert.strictEqual(
+      base.getStringAttr(testObj, 'anObject', anotherString), anotherString);
+  assert.strictEqual(
+      base.getStringAttr(testObj, 'aNull', anotherString), anotherString);
+  assert.strictEqual(
+      base.getStringAttr(testObj, 'anUndefined', anotherString), anotherString);
+  assert.strictEqual(
+      base.getStringAttr(testObj, 'noSuchKey', anotherString), anotherString);
+});
+
+})();