diff --git a/tests/jsunit/test_utilities.js b/tests/jsunit/test_utilities.js
index 81f78b23c..cdd6fd885 100644
--- a/tests/jsunit/test_utilities.js
+++ b/tests/jsunit/test_utilities.js
@@ -158,3 +158,124 @@ function captureWarnings(innerFunc) {
   }
   return msgs;
 }
+
+function _argumentsIncludeComments(expectedNumberOfNonCommentArgs, args) {
+  return args.length == expectedNumberOfNonCommentArgs + 1;
+}
+
+function _commentArg(expectedNumberOfNonCommentArgs, args) {
+  if (_argumentsIncludeComments(expectedNumberOfNonCommentArgs, args)) {
+    return args[0];
+  }
+
+  return null;
+}
+
+function _nonCommentArg(desiredNonCommentArgIndex, expectedNumberOfNonCommentArgs, args) {
+  return _argumentsIncludeComments(expectedNumberOfNonCommentArgs, args) ?
+      args[desiredNonCommentArgIndex] :
+      args[desiredNonCommentArgIndex - 1];
+}
+
+function _validateArguments(expectedNumberOfNonCommentArgs, args) {
+  if (!( args.length == expectedNumberOfNonCommentArgs ||
+      (args.length == expectedNumberOfNonCommentArgs + 1 && (typeof(args[0]) == 'string') || args[0] == null))) {
+    throw Error('Incorrect arguments passed to assert function');
+  }
+}
+/**
+ * Converts from JSUnit assertEquals to chai.assert.equal.
+ */
+function assertEquals() {
+  _validateArguments(2, arguments);
+  var var1 = _nonCommentArg(1, 2, arguments);
+  var var2 = _nonCommentArg(2, 2, arguments);
+  var comment = _commentArg(2, arguments);
+  chai.assert.equal(var1, var2, comment);
+}
+
+/**
+ * Converts from JSUnit assertNotEquals to chai.assert.notEquals.
+ */
+function assertNotEquals() {
+  _validateArguments(2, arguments);
+  var var1 = _nonCommentArg(1, 2, arguments);
+  var var2 = _nonCommentArg(2, 2, arguments);
+  var comment = _commentArg(2, arguments);
+  chai.assert.notEqual(var1, var2, comment);
+}
+
+/**
+ * Converts from JSUnit assertTrue to chai.assert.isTrue.
+ */
+function assertTrue() {
+  _validateArguments(1, arguments);
+  var commentArg = _commentArg(1, arguments);
+  var booleanValue = _nonCommentArg(1, 1, arguments);
+  if (typeof(booleanValue) != 'boolean') {
+    throw Error('Bad argument to assertTrue(boolean)');
+  }
+
+  chai.assert.isTrue(booleanValue, commentArg);
+}
+
+/**
+ * Converts from JSUnit assertFalse to chai.assert.isNotTrue.
+ */
+function assertFalse() {
+  _validateArguments(1, arguments);
+  var commentArg = _commentArg(1, arguments);
+  var booleanValue = _nonCommentArg(1, 1, arguments);
+
+  if (typeof(booleanValue) != 'boolean') {
+    throw Error('Bad argument to assertFalse(boolean)');
+  }
+
+  chai.assert.isNotTrue(booleanValue, commentArg);
+}
+
+/**
+ * Converts from JSUnit assertNull to chai.assert.isNull.
+ */
+function assertNull() {
+  _validateArguments(1, arguments);
+  var commentArg = _commentArg(1, arguments);
+  var val = _nonCommentArg(1, 1, arguments);
+  chai.assert.isNull(val, commentArg);
+}
+
+function assertNotNull() {
+  _validateArguments(1, arguments);
+  var commentArg = _commentArg(1, arguments);
+  var val = _nonCommentArg(1, 1, arguments);
+  chai.assert.isNotNull(val, commentArg);
+}
+
+function assertNotNullNorUndefined() {
+  assertNotNull(arguments);
+}
+
+function assert() {
+  chai.assert(arguments);
+}
+
+function assertUndefined() {
+  _validateArguments(1, arguments);
+  var commentArg = _commentArg(1, arguments);
+  var val = _nonCommentArg(1, 1, arguments);
+  chai.assert.isUndefined(val, commentArg);
+}
+
+function assertNotUndefined() {
+  _validateArguments(1, arguments);
+  var commentArg = _commentArg(1, arguments);
+  var val = _nonCommentArg(1, 1, arguments);
+  chai.assert.isDefined(val, commentArg);
+}
+
+function assertArrayEquals() {
+  _validateArguments(2, arguments);
+  var var1 = _nonCommentArg(1, 2, arguments);
+  var var2 = _nonCommentArg(2, 2, arguments);
+  isEqualArrays(var1, var2);
+}
\ No newline at end of file
diff --git a/tests/mocha/.eslintrc.json b/tests/mocha/.eslintrc.json
index f057f88e2..17038e164 100644
--- a/tests/mocha/.eslintrc.json
+++ b/tests/mocha/.eslintrc.json
@@ -6,22 +6,12 @@
     "globals": {
         "chai": false,
         "sinon": false,
-        "assert": true,
         "assertArrayEquals": true,
-        "assertNull": true,
-        "assertNotNull": true,
-        "assertEquals": true,
-        "assertTrue": true,
-        "assertFalse": true,
-        "isEqualArrays": true,
-        "assertUndefined": true,
-        "assertNotUndefined": true,
-        "assertNotNullNorUndefined": true,
         "assertVariableValues": true,
-        "defineStackBlock": true,
+        "createTestBlock": true,
         "defineRowBlock": true,
-        "defineStatementBlock": true,
-        "createTestBlock": true
+        "defineStackBlock": true,
+        "defineStatementBlock": true
     },
     "extends": "../../.eslintrc.json"
 }
diff --git a/tests/mocha/astnode_test.js b/tests/mocha/astnode_test.js
index 1e9a69c71..bfd4e5972 100644
--- a/tests/mocha/astnode_test.js
+++ b/tests/mocha/astnode_test.js
@@ -105,7 +105,7 @@ suite('ASTNode', function() {
       var connection = input.connection;
       var node = Blockly.ASTNode.createConnectionNode(connection);
       var newASTNode = node.findNextForInput_(input);
-      assertEquals(newASTNode.getLocation(), input2.connection);
+      chai.assert.equal(newASTNode.getLocation(), input2.connection);
     });
 
     test('findPrevForInput_', function() {
@@ -114,7 +114,7 @@ suite('ASTNode', function() {
       var connection = input2.connection;
       var node = Blockly.ASTNode.createConnectionNode(connection);
       var newASTNode = node.findPrevForInput_(input2);
-      assertEquals(newASTNode.getLocation(), input.connection);
+      chai.assert.equal(newASTNode.getLocation(), input.connection);
     });
 
     test('findNextForField_', function() {
@@ -122,7 +122,7 @@ suite('ASTNode', function() {
       var field2 = this.blocks.statementInput1.inputList[0].fieldRow[1];
       var node = Blockly.ASTNode.createFieldNode(field);
       var newASTNode = node.findNextForField_(field);
-      assertEquals(newASTNode.getLocation(), field2);
+      chai.assert.equal(newASTNode.getLocation(), field2);
     });
 
     test('findPrevForField_', function() {
@@ -130,40 +130,40 @@ suite('ASTNode', function() {
       var field2 = this.blocks.statementInput1.inputList[0].fieldRow[1];
       var node = Blockly.ASTNode.createFieldNode(field2);
       var newASTNode = node.findPrevForField_(field2);
-      assertEquals(newASTNode.getLocation(), field);
+      chai.assert.equal(newASTNode.getLocation(), field);
     });
 
     test('navigateBetweenStacks_Forward', function() {
       var node = new Blockly.ASTNode(
           Blockly.ASTNode.types.NEXT, this.blocks.statementInput1.nextConnection);
       var newASTNode = node.navigateBetweenStacks_(true);
-      assertEquals(newASTNode.getLocation(), this.blocks.statementInput4);
+      chai.assert.equal(newASTNode.getLocation(), this.blocks.statementInput4);
     });
 
     test('navigateBetweenStacks_Backward', function() {
       var node = new Blockly.ASTNode(
           Blockly.ASTNode.types.BLOCK, this.blocks.statementInput4);
       var newASTNode = node.navigateBetweenStacks_(false);
-      assertEquals(newASTNode.getLocation(), this.blocks.statementInput1);
+      chai.assert.equal(newASTNode.getLocation(), this.blocks.statementInput1);
     });
     test('getOutAstNodeForBlock_', function() {
       var node = new Blockly.ASTNode(
           Blockly.ASTNode.types.BLOCK, this.blocks.statementInput2);
       var newASTNode = node.getOutAstNodeForBlock_(this.blocks.statementInput2);
-      assertEquals(newASTNode.getLocation(), this.blocks.statementInput1);
+      chai.assert.equal(newASTNode.getLocation(), this.blocks.statementInput1);
     });
     test('getOutAstNodeForBlock_OneBlock', function() {
       var node = new Blockly.ASTNode(
           Blockly.ASTNode.types.BLOCK, this.blocks.statementInput4);
       var newASTNode = node.getOutAstNodeForBlock_(this.blocks.statementInput4);
-      assertEquals(newASTNode.getLocation(), this.blocks.statementInput4);
+      chai.assert.equal(newASTNode.getLocation(), this.blocks.statementInput4);
     });
     test('findFirstFieldOrInput_', function() {
       var node = new Blockly.ASTNode(
           Blockly.ASTNode.types.BLOCK, this.blocks.statementInput4);
       var field = this.blocks.statementInput4.inputList[0].fieldRow[0];
       var newASTNode = node.findFirstFieldOrInput_(this.blocks.statementInput4);
-      assertEquals(newASTNode.getLocation(), field);
+      chai.assert.equal(newASTNode.getLocation(), field);
     });
 
   });
@@ -345,95 +345,95 @@ suite('ASTNode', function() {
         var prevConnection = this.blocks.statementInput1.previousConnection;
         var node = Blockly.ASTNode.createConnectionNode(prevConnection);
         var nextNode = node.next();
-        assertEquals(nextNode.getLocation(), this.blocks.statementInput1);
+        chai.assert.equal(nextNode.getLocation(), this.blocks.statementInput1);
       });
       test('fromBlockToNext', function() {
         var nextConnection = this.blocks.statementInput1.nextConnection;
         var node = Blockly.ASTNode.createBlockNode(this.blocks.statementInput1);
         var nextNode = node.next();
-        assertEquals(nextNode.getLocation(), nextConnection);
+        chai.assert.equal(nextNode.getLocation(), nextConnection);
       });
       test('fromBlockToNull', function() {
         var node = Blockly.ASTNode.createBlockNode(this.blocks.noNextConnection);
         var nextNode = node.next();
-        assertEquals(nextNode, null);
+        chai.assert.isNull(nextNode);
       });
       test('fromNextToPrevious', function() {
         var nextConnection = this.blocks.statementInput1.nextConnection;
         var prevConnection = this.blocks.statementInput2.previousConnection;
         var node = Blockly.ASTNode.createConnectionNode(nextConnection);
         var nextNode = node.next();
-        assertEquals(nextNode.getLocation(), prevConnection);
+        chai.assert.equal(nextNode.getLocation(), prevConnection);
       });
       test('fromNextToNull', function() {
         var nextConnection = this.blocks.statementInput2.nextConnection;
         var node = Blockly.ASTNode.createConnectionNode(nextConnection);
         var nextNode = node.next();
-        assertEquals(nextNode, null);
+        chai.assert.isNull(nextNode);
       });
       test('fromInputToInput', function() {
         var input = this.blocks.statementInput1.inputList[0];
         var inputConnection = this.blocks.statementInput1.inputList[1].connection;
         var node = Blockly.ASTNode.createInputNode(input);
         var nextNode = node.next();
-        assertEquals(nextNode.getLocation(), inputConnection);
+        chai.assert.equal(nextNode.getLocation(), inputConnection);
       });
       test('fromInputToStatementInput', function() {
         var input = this.blocks.fieldAndInputs2.inputList[1];
         var inputConnection = this.blocks.fieldAndInputs2.inputList[2].connection;
         var node = Blockly.ASTNode.createInputNode(input);
         var nextNode = node.next();
-        assertEquals(nextNode.getLocation(), inputConnection);
+        chai.assert.equal(nextNode.getLocation(), inputConnection);
       });
       test('fromInputToField', function() {
         var input = this.blocks.fieldAndInputs2.inputList[0];
         var field = this.blocks.fieldAndInputs2.inputList[1].fieldRow[0];
         var node = Blockly.ASTNode.createInputNode(input);
         var nextNode = node.next();
-        assertEquals(nextNode.getLocation(), field);
+        chai.assert.equal(nextNode.getLocation(), field);
       });
       test('fromInputToNull', function() {
         var input = this.blocks.fieldAndInputs2.inputList[2];
         var node = Blockly.ASTNode.createInputNode(input);
         var nextNode = node.next();
-        assertEquals(nextNode, null);
+        chai.assert.isNull(nextNode);
       });
       test('fromOutputToBlock', function() {
         var output = this.blocks.fieldWithOutput.outputConnection;
         var node = Blockly.ASTNode.createConnectionNode(output);
         var nextNode = node.next();
-        assertEquals(nextNode.getLocation(), this.blocks.fieldWithOutput);
+        chai.assert.equal(nextNode.getLocation(), this.blocks.fieldWithOutput);
       });
       test('fromFieldToInput', function() {
         var field = this.blocks.statementInput1.inputList[0].fieldRow[1];
         var inputConnection = this.blocks.statementInput1.inputList[0].connection;
         var node = Blockly.ASTNode.createFieldNode(field);
         var nextNode = node.next();
-        assertEquals(nextNode.getLocation(), inputConnection);
+        chai.assert.equal(nextNode.getLocation(), inputConnection);
       });
       test('fromFieldToField', function() {
         var field = this.blocks.fieldAndInputs.inputList[0].fieldRow[0];
         var node = Blockly.ASTNode.createFieldNode(field);
         var field2 = this.blocks.fieldAndInputs.inputList[1].fieldRow[0];
         var nextNode = node.next();
-        assertEquals(nextNode.getLocation(), field2);
+        chai.assert.equal(nextNode.getLocation(), field2);
       });
       test('fromFieldToNull', function() {
         var field = this.blocks.twoFields.inputList[0].fieldRow[0];
         var node = Blockly.ASTNode.createFieldNode(field);
         var nextNode = node.next();
-        assertEquals(nextNode, null);
+        chai.assert.isNull(nextNode);
       });
       test('fromStackToStack', function() {
         var node = Blockly.ASTNode.createStackNode(this.blocks.statementInput1);
         var nextNode = node.next();
-        assertEquals(nextNode.getLocation(), this.blocks.statementInput4);
-        assertEquals(nextNode.getType(), Blockly.ASTNode.types.STACK);
+        chai.assert.equal(nextNode.getLocation(), this.blocks.statementInput4);
+        chai.assert.equal(nextNode.getType(), Blockly.ASTNode.types.STACK);
       });
       test('fromStackToNull', function() {
         var node = Blockly.ASTNode.createStackNode(this.blocks.singleBlock);
         var nextNode = node.next();
-        assertEquals(nextNode, null);
+        chai.assert.isNull(nextNode);
       });
     });
 
@@ -442,94 +442,94 @@ suite('ASTNode', function() {
         var prevConnection = this.blocks.statementInput1.previousConnection;
         var node = Blockly.ASTNode.createConnectionNode(prevConnection);
         var prevNode = node.prev();
-        assertEquals(prevNode, null);
+        chai.assert.isNull(prevNode);
       });
       test('fromPreviousToNext', function() {
         var prevConnection = this.blocks.statementInput2.previousConnection;
         var node = Blockly.ASTNode.createConnectionNode(prevConnection);
         var prevNode = node.prev();
         var nextConnection = this.blocks.statementInput1.nextConnection;
-        assertEquals(prevNode.getLocation(), nextConnection);
+        chai.assert.equal(prevNode.getLocation(), nextConnection);
       });
       test('fromPreviousToInput', function() {
         var prevConnection = this.blocks.statementInput3.previousConnection;
         var node = Blockly.ASTNode.createConnectionNode(prevConnection);
         var prevNode = node.prev();
-        assertEquals(prevNode, null);
+        chai.assert.isNull(prevNode);
       });
       test('fromBlockToPrevious', function() {
         var node = Blockly.ASTNode.createBlockNode(this.blocks.statementInput1);
         var prevNode = node.prev();
         var prevConnection = this.blocks.statementInput1.previousConnection;
-        assertEquals(prevNode.getLocation(), prevConnection);
+        chai.assert.equal(prevNode.getLocation(), prevConnection);
       });
       test('fromBlockToNull', function() {
         var node = Blockly.ASTNode.createBlockNode(this.blocks.noPrevConnection);
         var prevNode = node.prev();
-        assertEquals(prevNode, null);
+        chai.assert.isNull(prevNode);
       });
       test('fromBlockToOutput', function() {
         var node = Blockly.ASTNode.createBlockNode(this.blocks.fieldWithOutput);
         var prevNode = node.prev();
         var outputConnection = this.blocks.fieldWithOutput.outputConnection;
-        assertEquals(prevNode.getLocation(), outputConnection);
+        chai.assert.equal(prevNode.getLocation(), outputConnection);
       });
       test('fromNextToBlock', function() {
         var nextConnection = this.blocks.statementInput1.nextConnection;
         var node = Blockly.ASTNode.createConnectionNode(nextConnection);
         var prevNode = node.prev();
-        assertEquals(prevNode.getLocation(), this.blocks.statementInput1);
+        chai.assert.equal(prevNode.getLocation(), this.blocks.statementInput1);
       });
       test('fromInputToField', function() {
         var input = this.blocks.statementInput1.inputList[0];
         var node = Blockly.ASTNode.createInputNode(input);
         var prevNode = node.prev();
-        assertEquals(prevNode.getLocation(), input.fieldRow[1]);
+        chai.assert.equal(prevNode.getLocation(), input.fieldRow[1]);
       });
       test('fromInputToNull', function() {
         var input = this.blocks.fieldAndInputs2.inputList[0];
         var node = Blockly.ASTNode.createInputNode(input);
         var prevNode = node.prev();
-        assertEquals(prevNode, null);
+        chai.assert.isNull(prevNode);
       });
       test('fromInputToInput', function() {
         var input = this.blocks.fieldAndInputs2.inputList[2];
         var inputConnection = this.blocks.fieldAndInputs2.inputList[1].connection;
         var node = Blockly.ASTNode.createInputNode(input);
         var prevNode = node.prev();
-        assertEquals(prevNode.getLocation(), inputConnection);
+        chai.assert.equal(prevNode.getLocation(), inputConnection);
       });
       test('fromOutputToNull', function() {
         var output = this.blocks.fieldWithOutput.outputConnection;
         var node = Blockly.ASTNode.createConnectionNode(output);
         var prevNode = node.prev();
-        assertEquals(prevNode, null);
+        chai.assert.isNull(prevNode);
       });
       test('fromFieldToNull', function() {
         var field = this.blocks.statementInput1.inputList[0].fieldRow[0];
         var node = Blockly.ASTNode.createFieldNode(field);
         var prevNode = node.prev();
-        assertEquals(prevNode, null);
+        chai.assert.isNull(prevNode);
       });
       test('fromFieldToInput', function() {
         var field = this.blocks.fieldAndInputs2.inputList[1].fieldRow[0];
         var inputConnection = this.blocks.fieldAndInputs2.inputList[0].connection;
         var node = Blockly.ASTNode.createFieldNode(field);
         var prevNode = node.prev();
-        assertEquals(prevNode.getLocation(), inputConnection);
+        chai.assert.equal(prevNode.getLocation(), inputConnection);
       });
       test('fromFieldToField', function() {
         var field = this.blocks.fieldAndInputs.inputList[1].fieldRow[0];
         var field2 = this.blocks.fieldAndInputs.inputList[0].fieldRow[0];
         var node = Blockly.ASTNode.createFieldNode(field);
         var prevNode = node.prev();
-        assertEquals(prevNode.getLocation(), field2);
+        chai.assert.equal(prevNode.getLocation(), field2);
       });
       test('fromStackToStack', function() {
         var node = Blockly.ASTNode.createStackNode(this.blocks.statementInput4);
         var prevNode = node.prev();
-        assertEquals(prevNode.getLocation(), this.blocks.statementInput1);
-        assertEquals(prevNode.getType(), Blockly.ASTNode.types.STACK);
+        chai.assert.equal(prevNode.getLocation(), this.blocks.statementInput1);
+        chai.assert.equal(prevNode.getType(), Blockly.ASTNode.types.STACK);
       });
     });
 
@@ -546,96 +546,96 @@ suite('ASTNode', function() {
         var node = Blockly.ASTNode.createInputNode(input);
         var inNode = node.in();
         var outputConnection = this.blocks.fieldWithOutput.outputConnection;
-        assertEquals(inNode.getLocation(), outputConnection);
+        chai.assert.equal(inNode.getLocation(), outputConnection);
       });
       test('fromInputToNull', function() {
         var input = this.blocks.statementInput2.inputList[0];
         var node = Blockly.ASTNode.createInputNode(input);
         var inNode = node.in();
-        assertEquals(inNode, null);
+        chai.assert.isNull(inNode);
       });
       test('fromInputToPrevious', function() {
         var input = this.blocks.statementInput2.inputList[1];
         var previousConnection = this.blocks.statementInput3.previousConnection;
         var node = Blockly.ASTNode.createInputNode(input);
         var inNode = node.in();
-        assertEquals(inNode.getLocation(), previousConnection);
+        chai.assert.equal(inNode.getLocation(), previousConnection);
       });
       test('fromBlockToInput', function() {
         var input = this.blocks.valueInput.inputList[0];
         var node = Blockly.ASTNode.createBlockNode(this.blocks.valueInput);
         var inNode = node.in();
-        assertEquals(inNode.getLocation(), input.connection);
+        chai.assert.equal(inNode.getLocation(), input.connection);
       });
       test('fromBlockToField', function() {
         var node = Blockly.ASTNode.createBlockNode(this.blocks.statementInput1);
         var inNode = node.in();
         var field = this.blocks.statementInput1.inputList[0].fieldRow[0];
-        assertEquals(inNode.getLocation(), field);
+        chai.assert.equal(inNode.getLocation(), field);
       });
       test('fromBlockToPrevious', function() {
         var prevConnection = this.blocks.statementInput4.previousConnection;
         var node = Blockly.ASTNode.createStackNode(this.blocks.statementInput4);
         var inNode = node.in();
-        assertEquals(inNode.getLocation(), prevConnection);
-        assertEquals(inNode.getType(), Blockly.ASTNode.types.PREVIOUS);
+        chai.assert.equal(inNode.getLocation(), prevConnection);
+        chai.assert.equal(inNode.getType(), Blockly.ASTNode.types.PREVIOUS);
       });
       test('fromBlockToNull_DummyInput', function() {
         var node = Blockly.ASTNode.createBlockNode(this.blocks.dummyInput);
         var inNode = node.in();
-        assertEquals(inNode, null);
+        chai.assert.isNull(inNode);
       });
       test('fromBlockToInput_DummyInputValue', function() {
         var node = Blockly.ASTNode.createBlockNode(this.blocks.dummyInputValue);
         var inputConnection = this.blocks.dummyInputValue.inputList[1].connection;
         var inNode = node.in();
-        assertEquals(inNode.getLocation(), inputConnection);
+        chai.assert.equal(inNode.getLocation(), inputConnection);
       });
       test('fromOuputToNull', function() {
         var output = this.blocks.fieldWithOutput.outputConnection;
         var node = Blockly.ASTNode.createConnectionNode(output);
         var inNode = node.in();
-        assertEquals(inNode, null);
+        chai.assert.isNull(inNode);
       });
       test('fromFieldToNull', function() {
         var field = this.blocks.statementInput1.inputList[0].fieldRow[0];
         var node = Blockly.ASTNode.createFieldNode(field);
         var inNode = node.in();
-        assertEquals(inNode, null);
+        chai.assert.isNull(inNode);
       });
       test('fromWorkspaceToStack', function() {
         var coordinate = new Blockly.utils.Coordinate(100, 100);
         var node = Blockly.ASTNode.createWorkspaceNode(this.workspace, coordinate);
         var inNode = node.in();
-        assertEquals(inNode.getLocation(), this.workspace.getTopBlocks()[0]);
-        assertEquals(inNode.getType(), Blockly.ASTNode.types.STACK);
+        chai.assert.equal(inNode.getLocation(), this.workspace.getTopBlocks()[0]);
+        chai.assert.equal(inNode.getType(), Blockly.ASTNode.types.STACK);
       });
       test('fromWorkspaceToNull', function() {
         var coordinate = new Blockly.utils.Coordinate(100, 100);
         var node = Blockly.ASTNode.createWorkspaceNode(
             this.emptyWorkspace, coordinate);
         var inNode = node.in();
-        assertEquals(inNode, null);
+        chai.assert.isNull(inNode);
       });
       test('fromStackToPrevious', function() {
         var node = Blockly.ASTNode.createStackNode(this.blocks.statementInput1);
         var previous = this.blocks.statementInput1.previousConnection;
         var inNode = node.in();
-        assertEquals(inNode.getLocation(), previous);
-        assertEquals(inNode.getType(), Blockly.ASTNode.types.PREVIOUS);
+        chai.assert.equal(inNode.getLocation(), previous);
+        chai.assert.equal(inNode.getType(), Blockly.ASTNode.types.PREVIOUS);
       });
       test('fromStackToOutput', function() {
         var node = Blockly.ASTNode.createStackNode(this.blocks.fieldWithOutput2);
         var output = this.blocks.fieldWithOutput2.outputConnection;
         var inNode = node.in();
-        assertEquals(inNode.getLocation(), output);
-        assertEquals(inNode.getType(), Blockly.ASTNode.types.OUTPUT);
+        chai.assert.equal(inNode.getLocation(), output);
+        chai.assert.equal(inNode.getType(), Blockly.ASTNode.types.OUTPUT);
       });
       test('fromStackToBlock', function() {
         var node = Blockly.ASTNode.createStackNode(this.blocks.dummyInput);
         var inNode = node.in();
-        assertEquals(inNode.getLocation(), this.blocks.dummyInput);
-        assertEquals(inNode.getType(), Blockly.ASTNode.types.BLOCK);
+        chai.assert.equal(inNode.getLocation(), this.blocks.dummyInput);
+        chai.assert.equal(inNode.getType(), Blockly.ASTNode.types.BLOCK);
       });
     });
 
@@ -774,55 +774,55 @@ suite('ASTNode', function() {
       test('createFieldNode', function() {
         var field = this.blocks.statementInput1.inputList[0].fieldRow[0];
         var node = Blockly.ASTNode.createFieldNode(field);
-        assertEquals(node.getLocation(), field);
-        assertEquals(node.getType(), Blockly.ASTNode.types.FIELD);
-        assertFalse(node.isConnection());
+        chai.assert.equal(node.getLocation(), field);
+        chai.assert.equal(node.getType(), Blockly.ASTNode.types.FIELD);
+        chai.assert.isFalse(node.isConnection());
       });
       test('createConnectionNode', function() {
         var prevConnection = this.blocks.statementInput4.previousConnection;
         var node = Blockly.ASTNode.createConnectionNode(prevConnection);
-        assertEquals(node.getLocation(), prevConnection);
-        assertEquals(node.getType(), Blockly.ASTNode.types.PREVIOUS);
-        assertTrue(node.isConnection());
+        chai.assert.equal(node.getLocation(), prevConnection);
+        chai.assert.equal(node.getType(), Blockly.ASTNode.types.PREVIOUS);
+        chai.assert.isTrue(node.isConnection());
       });
       test('createInputNode', function() {
         var input = this.blocks.statementInput1.inputList[0];
         var node = Blockly.ASTNode.createInputNode(input);
-        assertEquals(node.getLocation(), input.connection);
-        assertEquals(node.getType(), Blockly.ASTNode.types.INPUT);
-        assertTrue(node.isConnection());
+        chai.assert.equal(node.getLocation(), input.connection);
+        chai.assert.equal(node.getType(), Blockly.ASTNode.types.INPUT);
+        chai.assert.isTrue(node.isConnection());
       });
       test('createWorkspaceNode', function() {
         var coordinate = new Blockly.utils.Coordinate(100, 100);
         var node = Blockly.ASTNode
             .createWorkspaceNode(this.workspace, coordinate);
-        assertEquals(node.getLocation(), this.workspace);
-        assertEquals(node.getType(), Blockly.ASTNode.types.WORKSPACE);
-        assertEquals(node.getWsCoordinate(), coordinate);
-        assertFalse(node.isConnection());
+        chai.assert.equal(node.getLocation(), this.workspace);
+        chai.assert.equal(node.getType(), Blockly.ASTNode.types.WORKSPACE);
+        chai.assert.equal(node.getWsCoordinate(), coordinate);
+        chai.assert.isFalse(node.isConnection());
       });
       test('createStatementConnectionNode', function() {
         var nextConnection = this.blocks.statementInput1.inputList[1].connection;
         var inputConnection = this.blocks.statementInput1.inputList[1].connection;
         var node = Blockly.ASTNode.createConnectionNode(nextConnection);
-        assertEquals(node.getLocation(), inputConnection);
-        assertEquals(node.getType(), Blockly.ASTNode.types.INPUT);
-        assertTrue(node.isConnection());
+        chai.assert.equal(node.getLocation(), inputConnection);
+        chai.assert.equal(node.getType(), Blockly.ASTNode.types.INPUT);
+        chai.assert.isTrue(node.isConnection());
       });
       test('createTopNode-previous', function() {
         var block = this.blocks.statementInput1;
         var topNode = Blockly.ASTNode.createTopNode(block);
-        assertEquals(topNode.getLocation(), block.previousConnection);
+        chai.assert.equal(topNode.getLocation(), block.previousConnection);
       });
       test('createTopNode-block', function() {
         var block = this.blocks.noPrevConnection;
         var topNode = Blockly.ASTNode.createTopNode(block);
-        assertEquals(topNode.getLocation(), block);
+        chai.assert.equal(topNode.getLocation(), block);
       });
       test('createTopNode-output', function() {
         var block = this.blocks.outputNextBlock;
         var topNode = Blockly.ASTNode.createTopNode(block);
-        assertEquals(topNode.getLocation(), block.outputConnection);
+        chai.assert.equal(topNode.getLocation(), block.outputConnection);
       });
     });
   });
diff --git a/tests/mocha/block_test.js b/tests/mocha/block_test.js
index f29b767db..1e7823bea 100644
--- a/tests/mocha/block_test.js
+++ b/tests/mocha/block_test.js
@@ -63,7 +63,7 @@ suite('Blocks', function() {
       blockB.nextConnection.connect(blockC.previousConnection);
     }
 
-    assertEquals(blockB, blockC.getParent());
+    chai.assert.equal(blockC.getParent(), blockB);
 
     return {
       A: blockA,  /* Parent */
@@ -75,30 +75,30 @@ suite('Blocks', function() {
   suite('Unplug', function() {
     function assertUnpluggedNoheal(blocks) {
       // A has nothing connected to it.
-      assertEquals(0, blocks.A.getChildren().length);
+      chai.assert.equal(blocks.A.getChildren().length, 0);
       // B and C are still connected.
-      assertEquals(blocks.B, blocks.C.getParent());
+      chai.assert.equal(blocks.C.getParent(), blocks.B);
       // B is the top of its stack.
-      assertNull(blocks.B.getParent());
+      chai.assert.isNull(blocks.B.getParent());
     }
     function assertUnpluggedHealed(blocks) {
       // A and C are connected.
-      assertEquals(1, blocks.A.getChildren().length);
-      assertEquals(blocks.A, blocks.C.getParent());
+      chai.assert.equal(blocks.A.getChildren().length, 1);
+      chai.assert.equal(blocks.C.getParent(), blocks.A);
       // B has nothing connected to it.
-      assertEquals(0, blocks.B.getChildren().length);
+      chai.assert.equal(blocks.B.getChildren().length, 0);
       // B is the top of its stack.
-      assertNull(blocks.B.getParent());
+      chai.assert.isNull(blocks.B.getParent());
     }
     function assertUnpluggedHealFailed(blocks) {
       // A has nothing connected to it.
-      assertEquals(0, blocks.A.getChildren().length);
+      chai.assert.equal(blocks.A.getChildren().length, 0);
       // B has nothing connected to it.
-      assertEquals(0, blocks.B.getChildren().length);
+      chai.assert.equal(blocks.B.getChildren().length, 0);
       // B is the top of its stack.
-      assertNull(blocks.B.getParent());
+      chai.assert.isNull(blocks.B.getParent());
       // C is the top of its stack.
-      assertNull(blocks.C.getParent());
+      chai.assert.isNull(blocks.C.getParent());
     }
 
     suite('Row', function() {
@@ -195,7 +195,7 @@ suite('Blocks', function() {
     function assertDisposedNoheal(blocks) {
       chai.assert.isFalse(blocks.A.disposed);
       // A has nothing connected to it.
-      chai.assert.equal(0, blocks.A.getChildren().length);
+      chai.assert.equal(blocks.A.getChildren().length, 0);
       // B is disposed.
       chai.assert.isTrue(blocks.B.disposed);
       // And C is disposed.
@@ -205,8 +205,8 @@ suite('Blocks', function() {
       chai.assert.isFalse(blocks.A.disposed);
       chai.assert.isFalse(blocks.C.disposed);
       // A and C are connected.
-      assertEquals(1, blocks.A.getChildren().length);
-      assertEquals(blocks.A, blocks.C.getParent());
+      chai.assert.equal(blocks.A.getChildren().length, 1);
+      chai.assert.equal(blocks.C.getParent(), blocks.A);
       // B is disposed.
       chai.assert.isTrue(blocks.B.disposed);
     }
@@ -214,11 +214,11 @@ suite('Blocks', function() {
       chai.assert.isFalse(blocks.A.disposed);
       chai.assert.isFalse(blocks.C.disposed);
       // A has nothing connected to it.
-      chai.assert.equal(0, blocks.A.getChildren().length);
+      chai.assert.equal(blocks.A.getChildren().length, 0);
       // B is disposed.
       chai.assert.isTrue(blocks.B.disposed);
       // C is the top of its stack.
-      assertNull(blocks.C.getParent());
+      chai.assert.isNull(blocks.C.getParent());
     }
 
     suite('Row', function() {
@@ -1075,14 +1075,14 @@ suite('Blocks', function() {
         });
         test('Text Null', function() {
           this.block.setCommentText(null);
-          chai.assert.equal(this.block.getCommentText(), null);
+          chai.assert.isNull(this.block.getCommentText());
           assertNoCommentEvent(this.eventSpy);
         });
         test('Text -> Null', function() {
           this.block.setCommentText('first text');
 
           this.block.setCommentText(null);
-          chai.assert.equal(this.block.getCommentText(), null);
+          chai.assert.isNull(this.block.getCommentText());
           assertCommentEvent(this.eventSpy, 'first text', null);
         });
       });
@@ -1111,14 +1111,14 @@ suite('Blocks', function() {
         });
         test('Text Null', function() {
           this.block.setCommentText(null);
-          chai.assert.equal(this.block.getCommentText(), null);
+          chai.assert.isNull(this.block.getCommentText());
           assertNoCommentEvent(this.eventSpy);
         });
         test('Text -> Null', function() {
           this.block.setCommentText('first text');
 
           this.block.setCommentText(null);
-          chai.assert.equal(this.block.getCommentText(), null);
+          chai.assert.isNull(this.block.getCommentText());
           assertCommentEvent(this.eventSpy, 'first text', null);
         });
         test('Set While Visible - Editable', function() {
@@ -1558,7 +1558,7 @@ suite('Blocks', function() {
         assertCollapsed(blockA);
         var field = blockA.getField('FIELD');
         chai.assert.isNotNull(field);
-        chai.assert.equal('test', field.getText());
+        chai.assert.equal(field.getText(), 'test');
       });
       test('Add Icon', function() {
         var blockA = this.createBlock('empty_block');
@@ -1646,16 +1646,16 @@ suite('Blocks', function() {
       });
       test('Set colour', function() {
         this.block.setColour('20');
-        assertEquals(this.block.getColour(), '#a5745b');
-        assertEquals(this.block.colour_, this.block.getColour());
-        assertEquals(this.block.hue_, '20');
+        chai.assert.equal(this.block.getColour(), '#a5745b');
+        chai.assert.equal(this.block.colour_, this.block.getColour());
+        chai.assert.equal(this.block.hue_, '20');
       });
       test('Set style', function() {
         this.block.setStyle('styleOne');
-        assertEquals(this.block.getStyleName(), 'styleOne');
-        assertEquals(this.block.hue_, null);
+        chai.assert.equal(this.block.getStyleName(), 'styleOne');
+        chai.assert.isNull(this.block.hue_);
         // Calling setStyle does not update the colour on a headless block.
-        assertEquals(this.block.getColour(), '#000000');
+        chai.assert.equal(this.block.getColour(), '#000000');
       });
     });
     suite('Rendered', function() {
@@ -1678,23 +1678,23 @@ suite('Blocks', function() {
       });
       test('Set colour hue', function() {
         this.block.setColour('20');
-        assertEquals(this.block.getStyleName(), 'auto_#a5745b');
-        assertEquals(this.block.getColour(), '#a5745b');
-        assertEquals(this.block.colour_, this.block.getColour());
-        assertEquals(this.block.hue_, '20');
+        chai.assert.equal(this.block.getStyleName(), 'auto_#a5745b');
+        chai.assert.equal(this.block.getColour(), '#a5745b');
+        chai.assert.equal(this.block.colour_, this.block.getColour());
+        chai.assert.equal(this.block.hue_, '20');
       });
       test('Set colour hex', function() {
         this.block.setColour('#000000');
-        assertEquals(this.block.getStyleName(), 'auto_#000000');
-        assertEquals(this.block.getColour(), '#000000');
-        assertEquals(this.block.colour_, this.block.getColour());
-        assertEquals(this.block.hue_, null);
+        chai.assert.equal(this.block.getStyleName(), 'auto_#000000');
+        chai.assert.equal(this.block.getColour(), '#000000');
+        chai.assert.equal(this.block.colour_, this.block.getColour());
+        chai.assert.isNull(this.block.hue_);
       });
       test('Set style', function() {
         this.block.setStyle('styleOne');
-        assertEquals(this.block.getStyleName(), 'styleOne');
-        assertEquals(this.block.getColour(), '#000000');
-        assertEquals(this.block.colour_, this.block.getColour());
+        chai.assert.equal(this.block.getStyleName(), 'styleOne');
+        chai.assert.equal(this.block.getColour(), '#000000');
+        chai.assert.equal(this.block.colour_, this.block.getColour());
       });
     });
   });
diff --git a/tests/mocha/cursor_test.js b/tests/mocha/cursor_test.js
index bc367e09b..6286ff283 100644
--- a/tests/mocha/cursor_test.js
+++ b/tests/mocha/cursor_test.js
@@ -83,14 +83,14 @@ suite('Cursor', function() {
     this.cursor.setCurNode(prevNode);
     this.cursor.next();
     var curNode = this.cursor.getCurNode();
-    assertEquals(curNode.getLocation(), this.blocks.B.previousConnection);
+    chai.assert.equal(curNode.getLocation(), this.blocks.B.previousConnection);
   });
   test('Next - From last block in a stack go to next connection', function() {
     var prevNode = Blockly.ASTNode.createConnectionNode(this.blocks.B.previousConnection);
     this.cursor.setCurNode(prevNode);
     this.cursor.next();
     var curNode = this.cursor.getCurNode();
-    assertEquals(curNode.getLocation(), this.blocks.B.nextConnection);
+    chai.assert.equal(curNode.getLocation(), this.blocks.B.nextConnection);
   });
 
   test('In - From output connection', function() {
@@ -99,7 +99,7 @@ suite('Cursor', function() {
     this.cursor.setCurNode(outputNode);
     this.cursor.in();
     var curNode = this.cursor.getCurNode();
-    assertEquals(curNode.getLocation(), fieldBlock.inputList[0].fieldRow[0]);
+    chai.assert.equal(curNode.getLocation(), fieldBlock.inputList[0].fieldRow[0]);
   });
 
   test('Prev - From previous connection skip over next connection', function() {
@@ -108,7 +108,7 @@ suite('Cursor', function() {
     this.cursor.setCurNode(prevConnectionNode);
     this.cursor.prev();
     var curNode = this.cursor.getCurNode();
-    assertEquals(curNode.getLocation(), this.blocks.A.previousConnection);
+    chai.assert.equal(curNode.getLocation(), this.blocks.A.previousConnection);
   });
 
   test('Out - From field skip over block node', function() {
@@ -117,6 +117,6 @@ suite('Cursor', function() {
     this.cursor.setCurNode(fieldNode);
     this.cursor.out();
     var curNode = this.cursor.getCurNode();
-    assertEquals(curNode.getLocation(), this.blocks.E.outputConnection);
+    chai.assert.equal(curNode.getLocation(), this.blocks.E.outputConnection);
   });
 });
diff --git a/tests/mocha/event_test.js b/tests/mocha/event_test.js
index 8304d6a34..a85d8a4fa 100644
--- a/tests/mocha/event_test.js
+++ b/tests/mocha/event_test.js
@@ -38,24 +38,24 @@ suite('Events', function() {
     var keys = Object.keys(values);
     for (var i = 0; i < keys.length; i++) {
       var field = keys[i];
-      assertEquals(values[field], event[field]);
+      chai.assert.equal(values[field], event[field]);
     }
   }
 
   function checkCreateEventValues(event, block, ids, type) {
     var expected_xml = Blockly.Xml.domToText(Blockly.Xml.blockToDom(block));
     var result_xml = Blockly.Xml.domToText(event.xml);
-    assertEquals(expected_xml, result_xml);
-    isEqualArrays(ids, event.ids);
-    assertEquals(type, event.type);
+    chai.assert.equal(expected_xml, result_xml);
+    assertArrayEquals(ids, event.ids);
+    chai.assert.equal(type, event.type);
   }
 
   function checkDeleteEventValues(event, block, ids, type) {
     var expected_xml = Blockly.Xml.domToText(Blockly.Xml.blockToDom(block));
     var result_xml = Blockly.Xml.domToText(event.oldXml);
-    assertEquals(expected_xml, result_xml);
-    isEqualArrays(ids, event.ids);
-    assertEquals(type, event.type);
+    chai.assert.equal(expected_xml, result_xml);
+    assertArrayEquals(ids, event.ids);
+    chai.assert.equal(type, event.type);
   }
 
   function createSimpleTestBlock(workspace, opt_prototypeName) {
@@ -71,9 +71,9 @@ suite('Events', function() {
   suite('Constructors', function() {
     test('Abstract', function() {
       var event = new Blockly.Events.Abstract();
-      assertUndefined(event.blockId);
-      assertUndefined(event.workspaceId);
-      assertUndefined(event.varId);
+      chai.assert.isUndefined(event.blockId);
+      chai.assert.isUndefined(event.workspaceId);
+      chai.assert.isUndefined(event.varId);
       checkExactEventValues(event, {'group': '', 'recordUndo': true});
     });
 
@@ -106,7 +106,7 @@ suite('Events', function() {
 
       test('Block base', function() {
         var event = new Blockly.Events.BlockBase(this.block);
-        assertUndefined(event.varId);
+        chai.assert.isUndefined(event.varId);
         checkExactEventValues(event,
             {
               'blockId': this.FAKE_ID,
@@ -228,10 +228,26 @@ suite('Events', function() {
       this.variable = this.workspace.createVariable('name1', 'type1', 'id1');
     });
 
+    /**
+     * Check if a variable with the given values exists.
+     * @param {Blockly.Workspace|Blockly.VariableMap} container The workspace  or
+     *     variableMap the checked variable belongs to.
+     * @param {!string} name The expected name of the variable.
+     * @param {!string} type The expected type of the variable.
+     * @param {!string} id The expected id of the variable.
+     */
+    function checkVariableValues(container, name, type, id) {
+      var variable = container.getVariableById(id);
+      chai.assert.isDefined(variable);
+      chai.assert.equal(name, variable.name);
+      chai.assert.equal(type, variable.type);
+      chai.assert.equal(id, variable.getId());
+    }
+
     suite('Constructors', function() {
       test('Var base', function() {
         var event = new Blockly.Events.VarBase(this.variable);
-        assertUndefined(event.blockId);
+        chai.assert.isUndefined(event.blockId);
         checkExactEventValues(event, {'varId': 'id1',
           'workspaceId': this.workspace.id, 'group': '', 'recordUndo': true});
       });
@@ -262,7 +278,7 @@ suite('Events', function() {
         var json = event.toJson();
         event2.fromJson(json);
 
-        assertEquals(JSON.stringify(json), JSON.stringify(event2.toJson()));
+        chai.assert.equal(JSON.stringify(json), JSON.stringify(event2.toJson()));
       });
       test('Var delete', function() {
         var event = new Blockly.Events.VarDelete(this.variable);
@@ -270,7 +286,7 @@ suite('Events', function() {
         var json = event.toJson();
         event2.fromJson(json);
 
-        assertEquals(JSON.stringify(json), JSON.stringify(event2.toJson()));
+        chai.assert.equal(JSON.stringify(json), JSON.stringify(event2.toJson()));
       });
       test('Var rename', function() {
         var event = new Blockly.Events.VarRename(this.variable, '');
@@ -278,7 +294,7 @@ suite('Events', function() {
         var json = event.toJson();
         event2.fromJson(json);
 
-        assertEquals(JSON.stringify(json), JSON.stringify(event2.toJson()));
+        chai.assert.equal(JSON.stringify(json), JSON.stringify(event2.toJson()));
       });
     });
 
@@ -289,7 +305,7 @@ suite('Events', function() {
         var expectedJson = ({type: "var_create", varId: "id1", varType: "type1",
           varName: "name1"});
 
-        assertEquals(JSON.stringify(expectedJson), JSON.stringify(json));
+        chai.assert.equal(JSON.stringify(expectedJson), JSON.stringify(json));
       });
 
       test('Var delete', function() {
@@ -298,7 +314,7 @@ suite('Events', function() {
         var expectedJson = ({type: "var_delete", varId: "id1", varType: "type1",
           varName: "name1"});
 
-        assertEquals(JSON.stringify(expectedJson), JSON.stringify(json));
+        chai.assert.equal(JSON.stringify(expectedJson), JSON.stringify(json));
       });
 
       test('Var rename', function() {
@@ -307,7 +323,7 @@ suite('Events', function() {
         var expectedJson = ({type: "var_rename", varId: "id1", oldName: "name1",
           newName: "name2"});
 
-        assertEquals(JSON.stringify(expectedJson), JSON.stringify(json));
+        chai.assert.equal(JSON.stringify(expectedJson), JSON.stringify(json));
       });
     });
 
@@ -317,29 +333,29 @@ suite('Events', function() {
           varName: "name2"};
         var event = Blockly.Events.fromJson(json, this.workspace);
         var x = this.workspace.getVariableById('id2');
-        assertNull(x);
+        chai.assert.isNull(x);
         event.run(true);
         assertVariableValues(this.workspace, 'name2', 'type2', 'id2');
       });
 
       test('Var delete', function() {
         var event = new Blockly.Events.VarDelete(this.variable);
-        assertNotNull(this.workspace.getVariableById('id1'));
+        chai.assert.isNotNull(this.workspace.getVariableById('id1'));
         event.run(true);
-        assertNull(this.workspace.getVariableById('id1'));
+        chai.assert.isNull(this.workspace.getVariableById('id1'));
       });
 
       test('Var rename', function() {
         var event = new Blockly.Events.VarRename(this.variable, 'name2');
         event.run(true);
-        assertNull(this.workspace.getVariable('name1'));
-        assertVariableValues(this.workspace, 'name2', 'type1', 'id1');
+        chai.assert.isNull(this.workspace.getVariable('name1'));
+        checkVariableValues(this.workspace, 'name2', 'type1', 'id1');
       });
     });
     suite('Run Backward', function() {
       test('Var create', function() {
         var event = new Blockly.Events.VarCreate(this.variable);
-        assertNotNull(this.workspace.getVariableById('id1'));
+        chai.assert.isNotNull(this.workspace.getVariableById('id1'));
         event.run(false);
       });
 
@@ -347,7 +363,7 @@ suite('Events', function() {
         var json = {type: "var_delete", varId: "id2", varType: "type2",
           varName: "name2"};
         var event = Blockly.Events.fromJson(json, this.workspace);
-        assertNull(this.workspace.getVariableById('id2'));
+        chai.assert.isNull(this.workspace.getVariableById('id2'));
         event.run(false);
         assertVariableValues(this.workspace, 'name2', 'type2', 'id2');
       });
@@ -355,8 +371,8 @@ suite('Events', function() {
       test('Var rename', function() {
         var event = new Blockly.Events.VarRename(this.variable, 'name2');
         event.run(false);
-        assertNull(this.workspace.getVariable('name2'));
-        assertVariableValues(this.workspace, 'name1', 'type1', 'id1');
+        chai.assert.isNull(this.workspace.getVariable('name2'));
+        checkVariableValues(this.workspace, 'name1', 'type1', 'id1');
       });
     });
   });
@@ -384,12 +400,12 @@ suite('Events', function() {
         new Blockly.Events.Ui(block, 'click', undefined, undefined)
       ];
       var filteredEvents = Blockly.Events.filter(events, true);
-      assertEquals(4, filteredEvents.length);  // no event should have been removed.
+      chai.assert.equal(4, filteredEvents.length);  // no event should have been removed.
       // test that the order hasn't changed
-      assertTrue(filteredEvents[0] instanceof Blockly.Events.BlockCreate);
-      assertTrue(filteredEvents[1] instanceof Blockly.Events.BlockMove);
-      assertTrue(filteredEvents[2] instanceof Blockly.Events.BlockChange);
-      assertTrue(filteredEvents[3] instanceof Blockly.Events.Ui);
+      chai.assert.isTrue(filteredEvents[0] instanceof Blockly.Events.BlockCreate);
+      chai.assert.isTrue(filteredEvents[1] instanceof Blockly.Events.BlockMove);
+      chai.assert.isTrue(filteredEvents[2] instanceof Blockly.Events.BlockChange);
+      chai.assert.isTrue(filteredEvents[3] instanceof Blockly.Events.Ui);
     });
 
     test('Different blocks no removed', function() {
@@ -402,7 +418,7 @@ suite('Events', function() {
         new Blockly.Events.BlockMove(block2)
       ];
       var filteredEvents = Blockly.Events.filter(events, true);
-      assertEquals(4, filteredEvents.length);  // no event should have been removed.
+      chai.assert.equal(4, filteredEvents.length);  // no event should have been removed.
     });
 
     test('Forward', function() {
@@ -412,12 +428,12 @@ suite('Events', function() {
       addMoveEvent(events, block, 2, 2);
       addMoveEvent(events, block, 3, 3);
       var filteredEvents = Blockly.Events.filter(events, true);
-      assertEquals(2, filteredEvents.length);  // duplicate moves should have been removed.
+      chai.assert.equal(2, filteredEvents.length);  // duplicate moves should have been removed.
       // test that the order hasn't changed
-      assertTrue(filteredEvents[0] instanceof Blockly.Events.BlockCreate);
-      assertTrue(filteredEvents[1] instanceof Blockly.Events.BlockMove);
-      assertEquals(3, filteredEvents[1].newCoordinate.x);
-      assertEquals(3, filteredEvents[1].newCoordinate.y);
+      chai.assert.isTrue(filteredEvents[0] instanceof Blockly.Events.BlockCreate);
+      chai.assert.isTrue(filteredEvents[1] instanceof Blockly.Events.BlockMove);
+      chai.assert.equal(3, filteredEvents[1].newCoordinate.x);
+      chai.assert.equal(3, filteredEvents[1].newCoordinate.y);
     });
 
     test('Backward', function() {
@@ -427,12 +443,12 @@ suite('Events', function() {
       addMoveEvent(events, block, 2, 2);
       addMoveEvent(events, block, 3, 3);
       var filteredEvents = Blockly.Events.filter(events, false);
-      assertEquals(2, filteredEvents.length);  // duplicate event should have been removed.
+      chai.assert.equal(2, filteredEvents.length);  // duplicate event should have been removed.
       // test that the order hasn't changed
-      assertTrue(filteredEvents[0] instanceof Blockly.Events.BlockCreate);
-      assertTrue(filteredEvents[1] instanceof Blockly.Events.BlockMove);
-      assertEquals(1, filteredEvents[1].newCoordinate.x);
-      assertEquals(1, filteredEvents[1].newCoordinate.y);
+      chai.assert.isTrue(filteredEvents[0] instanceof Blockly.Events.BlockCreate);
+      chai.assert.isTrue(filteredEvents[1] instanceof Blockly.Events.BlockMove);
+      chai.assert.equal(1, filteredEvents[1].newCoordinate.x);
+      chai.assert.equal(1, filteredEvents[1].newCoordinate.y);
     });
 
     test('Merge move events', function() {
@@ -441,9 +457,9 @@ suite('Events', function() {
       addMoveEvent(events, block, 0, 0);
       addMoveEvent(events, block, 1, 1);
       var filteredEvents = Blockly.Events.filter(events, true);
-      assertEquals(1, filteredEvents.length);  // second move event merged into first
-      assertEquals(1, filteredEvents[0].newCoordinate.x);
-      assertEquals(1, filteredEvents[0].newCoordinate.y);
+      chai.assert.equal(1, filteredEvents.length);  // second move event merged into first
+      chai.assert.equal(1, filteredEvents[0].newCoordinate.x);
+      chai.assert.equal(1, filteredEvents[0].newCoordinate.y);
     });
 
     test('Merge change events', function() {
@@ -453,9 +469,9 @@ suite('Events', function() {
         new Blockly.Events.Change(block1, 'field', 'VAR', 'item1', 'item2')
       ];
       var filteredEvents = Blockly.Events.filter(events, true);
-      assertEquals(1, filteredEvents.length);  // second change event merged into first
-      assertEquals('item', filteredEvents[0].oldValue);
-      assertEquals('item2', filteredEvents[0].newValue);
+      chai.assert.equal(1, filteredEvents.length);  // second change event merged into first
+      chai.assert.equal(filteredEvents[0].oldValue, 'item');
+      chai.assert.equal(filteredEvents[0].newValue, 'item2');
     });
 
     test('Merge ui events', function() {
@@ -471,10 +487,11 @@ suite('Events', function() {
         new Blockly.Events.Ui(block3, 'click', 'false', 'true')
       ];
       var filteredEvents = Blockly.Events.filter(events, true);
-      assertEquals(3, filteredEvents.length);  // click event merged into corresponding *Open event
-      assertEquals('commentOpen', filteredEvents[0].element);
-      assertEquals('mutatorOpen', filteredEvents[1].element);
-      assertEquals('warningOpen', filteredEvents[2].element);
+      // click event merged into corresponding *Open event
+      chai.assert.equal(filteredEvents.length, 3);
+      chai.assert.equal(filteredEvents[0].element, 'commentOpen');
+      chai.assert.equal(filteredEvents[1].element, 'mutatorOpen');
+      chai.assert.equal(filteredEvents[2].element, 'warningOpen');
     });
 
     test('Colliding events not dropped', function() {
@@ -487,9 +504,9 @@ suite('Events', function() {
       ];
       var filteredEvents = Blockly.Events.filter(events, true);
       // click and stackclick should both exist
-      assertEquals(2, filteredEvents.length);
-      assertEquals('click', filteredEvents[0].element);
-      assertEquals('stackclick', filteredEvents[1].element);
+      chai.assert.equal(2, filteredEvents.length);
+      chai.assert.equal(filteredEvents[0].element, 'click');
+      chai.assert.equal(filteredEvents[1].element, 'stackclick');
     });
 
     test('Merging null operations dropped', function() {
@@ -508,7 +525,7 @@ suite('Events', function() {
       var filteredEvents = Blockly.Events.filter(events, true);
       // The two events should be merged, but because nothing has changed
       // they will be filtered out.
-      assertEquals(0, filteredEvents.length);
+      chai.assert.equal(0, filteredEvents.length);
     });
 
     test('Move events different blocks not merged', function() {
@@ -528,12 +545,12 @@ suite('Events', function() {
 
       var filteredEvents = Blockly.Events.filter(events, true);
       // Nothing should have merged.
-      assertEquals(4, filteredEvents.length);
+      chai.assert.equal(4, filteredEvents.length);
       // test that the order hasn't changed
-      assertTrue(filteredEvents[0] instanceof Blockly.Events.BlockMove);
-      assertTrue(filteredEvents[1] instanceof Blockly.Events.BlockMove);
-      assertTrue(filteredEvents[2] instanceof Blockly.Events.BlockDelete);
-      assertTrue(filteredEvents[3] instanceof Blockly.Events.BlockMove);
+      chai.assert.isTrue(filteredEvents[0] instanceof Blockly.Events.BlockMove);
+      chai.assert.isTrue(filteredEvents[1] instanceof Blockly.Events.BlockMove);
+      chai.assert.isTrue(filteredEvents[2] instanceof Blockly.Events.BlockDelete);
+      chai.assert.isTrue(filteredEvents[3] instanceof Blockly.Events.BlockMove);
     });
   });
 
@@ -568,22 +585,22 @@ suite('Events', function() {
 
       var firedEvents = this.workspace.undoStack_;
       // Expect two events: varCreate and block create.
-      assertEquals(2, firedEvents.length);
+      chai.assert.equal(2, firedEvents.length);
 
       var event0 = firedEvents[0];
       var event1 = firedEvents[1];
-      assertEquals('var_create', event0.type);
-      assertEquals('create', event1.type);
+      chai.assert.equal(event0.type, 'var_create');
+      chai.assert.equal(event1.type, 'create');
 
       // Expect the events to have the same group ID.
-      assertEquals(event0.group, event1.group);
+      chai.assert.equal(event0.group, event1.group);
 
       // Expect the group ID to be the result of the second call to genUid.
-      assertEquals('2', event0.group);
+      chai.assert.equal(event0.group, '2');
 
       // Expect the workspace to have a variable with ID '3'.
-      assertNotNull(this.workspace.getVariableById('3'));
-      assertEquals('3', event0.varId);
+      chai.assert.isNotNull(this.workspace.getVariableById('3'));
+      chai.assert.equal(event0.varId, '3');
     });
 
     test('New block new var xml', function() {
@@ -599,19 +616,19 @@ suite('Events', function() {
 
       var firedEvents = this.workspace.undoStack_;
       // Expect two events: varCreate and block create.
-      assertEquals(2, firedEvents.length);
+      chai.assert.equal(2, firedEvents.length);
 
       var event0 = firedEvents[0];
       var event1 = firedEvents[1];
-      assertEquals('var_create', event0.type);
-      assertEquals('create', event1.type);
+      chai.assert.equal(event0.type, 'var_create');
+      chai.assert.equal(event1.type, 'create');
 
       // Expect the events to have the same group ID.
-      assertEquals(event0.group, event1.group);
+      chai.assert.equal(event0.group, event1.group);
 
       // Expect the workspace to have a variable with ID 'id1'.
-      assertNotNull(this.workspace.getVariableById('id1'));
-      assertEquals('id1', event0.varId);
+      chai.assert.isNotNull(this.workspace.getVariableById('id1'));
+      chai.assert.equal(event0.varId, 'id1');
     });
   });
 });
diff --git a/tests/mocha/extensions_test.js b/tests/mocha/extensions_test.js
index fcabd8e30..ea9a81bb4 100644
--- a/tests/mocha/extensions_test.js
+++ b/tests/mocha/extensions_test.js
@@ -32,7 +32,7 @@ suite('Extensions', function() {
     this.extensionsCleanup_.push('extensions_test_after');
     this.blockTypesCleanup_.push('extension_test_block');
 
-    assertUndefined(Blockly.Extensions.ALL_['extensions_test_before']);
+    chai.assert.isUndefined(Blockly.Extensions.ALL_['extensions_test_before']);
     var beforeCallback = sinon.spy();
     // Extension defined before the block type is defined.
     Blockly.Extensions.register('extensions_test_before', beforeCallback);
@@ -43,13 +43,13 @@ suite('Extensions', function() {
       "extensions": ["extensions_test_before", "extensions_test_after"]
     }]);
 
-    assertUndefined(Blockly.Extensions.ALL_['extensions_test_after']);
+    chai.assert.isUndefined(Blockly.Extensions.ALL_['extensions_test_after']);
     var afterCallback = sinon.spy();
     // Extension defined after the block type (but before instantiation).
     Blockly.Extensions.register('extensions_test_after', afterCallback);
 
-    assert(typeof Blockly.Extensions.ALL_['extensions_test_before'] == 'function');
-    assert(typeof Blockly.Extensions.ALL_['extensions_test_after'] == 'function');
+    chai.assert.typeOf(Blockly.Extensions.ALL_['extensions_test_before'], 'function');
+    chai.assert.typeOf(Blockly.Extensions.ALL_['extensions_test_after'], 'function');
     sinon.assert.notCalled(beforeCallback);
     sinon.assert.notCalled(afterCallback);
 
@@ -92,27 +92,27 @@ suite('Extensions', function() {
         new Blockly.Block(this.workspace, 'test_parent_tooltip_when_inline');
 
     // Tooltip is dynamic after extension initialization.
-    assert(typeof block.tooltip == 'function');
-    assertEquals(block.tooltip(), defaultTooltip);
+    chai.assert.typeOf(block.tooltip, 'function');
+    chai.assert.equal(block.tooltip(), defaultTooltip);
 
     // Tooltip is normal before connected to parent.
     var parent = new Blockly.Block(this.workspace, 'test_parent');
-    assertEquals(parent.tooltip, parentTooltip);
-    assertFalse(!!parent.inputsInline);
+    chai.assert.equal(parent.tooltip, parentTooltip);
+    chai.assert.isFalse(!!parent.inputsInline);
 
     // Tooltip is normal when parent is not inline.
     parent.getInput('INPUT').connection.connect(block.outputConnection);
-    assertEquals(block.getParent(), parent);
-    assertEquals(block.tooltip(), defaultTooltip);
+    chai.assert.equal(block.getParent(), parent);
+    chai.assert.equal(block.tooltip(), defaultTooltip);
 
     // Tooltip is parent's when parent is inline.
     parent.setInputsInline(true);
-    assertEquals(block.tooltip(), parentTooltip);
+    chai.assert.equal(block.tooltip(), parentTooltip);
 
     // Tooltip revert when disconnected.
     parent.getInput('INPUT').connection.disconnect();
-    assert(!block.getParent());
-    assertEquals(block.tooltip(), defaultTooltip);
+    chai.assert.notExists(block.getParent());
+    chai.assert.equal(block.tooltip(), defaultTooltip);
   });
 
   suite('Mixin', function() {
@@ -127,11 +127,11 @@ suite('Extensions', function() {
         }
       };
 
-      assertUndefined(Blockly.Extensions.ALL_['mixin_test']);
+      chai.assert.isUndefined(Blockly.Extensions.ALL_['mixin_test']);
       // Extension defined before the block type is defined.
       Blockly.Extensions.registerMixin('mixin_test', testMixin);
 
-      assert(typeof Blockly.Extensions.ALL_['mixin_test'] == 'function');
+      chai.assert.typeOf(Blockly.Extensions.ALL_['mixin_test'], 'function');
 
       Blockly.defineBlocksWithJsonArray([{
         "type": "test_block_mixin",
@@ -141,8 +141,8 @@ suite('Extensions', function() {
 
       var block = new Blockly.Block(this.workspace, 'test_block_mixin');
 
-      assertEquals(testMixin.field, block.field);
-      assertEquals(testMixin.method, block.method);
+      chai.assert.equal(testMixin.field, block.field);
+      chai.assert.equal(testMixin.method, block.method);
     });
 
     suite('Mutator', function() {
@@ -178,10 +178,10 @@ suite('Extensions', function() {
         var block = new Blockly.Block(this.workspace, 'mutator_test_block');
 
         // Make sure all of the functions were installed correctly.
-        assertEquals(block.domToMutation(), 'domToMutationFn');
-        assertEquals(block.mutationToDom(), 'mutationToDomFn');
-        assertEquals(block.compose(), 'composeFn');
-        assertEquals(block.decompose(), 'decomposeFn');
+        chai.assert.equal(block.domToMutation(), 'domToMutationFn');
+        chai.assert.equal(block.mutationToDom(), 'mutationToDomFn');
+        chai.assert.equal(block.compose(), 'composeFn');
+        chai.assert.equal(block.decompose(), 'decomposeFn');
       });
 
       test('With helper function', function() {
@@ -197,7 +197,7 @@ suite('Extensions', function() {
         // Events code calls mutationToDom and expects it to give back a
         // meaningful value.
         Blockly.Events.disable();
-        assertUndefined(Blockly.Extensions.ALL_['extensions_test']);
+        chai.assert.isUndefined(Blockly.Extensions.ALL_['extensions_test']);
         var helperFunctionSpy = sinon.spy();
         Blockly.Extensions.registerMutator('extensions_test',
             {
@@ -229,7 +229,7 @@ suite('Extensions', function() {
         // Events code calls mutationToDom and expects it to give back a
         // meaningful value.
         Blockly.Events.disable();
-        assertUndefined(Blockly.Extensions.ALL_['mutator_test']);
+        chai.assert.isUndefined(Blockly.Extensions.ALL_['mutator_test']);
         Blockly.Extensions.registerMutator('mutator_test',
             {
               domToMutation: function() {
@@ -243,10 +243,10 @@ suite('Extensions', function() {
         var block = new Blockly.Block(this.workspace, 'mutator_test_block');
 
         // Make sure all of the functions were installed correctly.
-        assertEquals(block.domToMutation(), 'domToMutationFn');
-        assertEquals(block.mutationToDom(), 'mutationToDomFn');
-        assertFalse(block.hasOwnProperty('compose'));
-        assertFalse(block.hasOwnProperty('decompose'));
+        chai.assert.equal(block.domToMutation(), 'domToMutationFn');
+        chai.assert.equal(block.mutationToDom(), 'mutationToDomFn');
+        chai.assert.isFalse(block.hasOwnProperty('compose'));
+        chai.assert.isFalse(block.hasOwnProperty('decompose'));
       });
     });
   });
@@ -261,7 +261,7 @@ suite('Extensions', function() {
         "extensions": ["missing_extension"]
       }]);
 
-      assertUndefined(Blockly.Extensions.ALL_['missing_extension']);
+      chai.assert.isUndefined(Blockly.Extensions.ALL_['missing_extension']);
       var workspace = this.workspace;
       chai.assert.throws(function() {
         var _ = new Blockly.Block(workspace, 'missing_extension_block');
@@ -276,10 +276,10 @@ suite('Extensions', function() {
         inputList: 'bad inputList'  // Defined in constructor
       };
 
-      assertUndefined(Blockly.Extensions.ALL_['mixin_bad_inputList']);
+      chai.assert.isUndefined(Blockly.Extensions.ALL_['mixin_bad_inputList']);
       // Extension defined before the block type is defined.
       Blockly.Extensions.registerMixin('mixin_bad_inputList', TEST_MIXIN_BAD_INPUTLIST);
-      assert(typeof Blockly.Extensions.ALL_['mixin_bad_inputList'] == 'function');
+      chai.assert.typeOf(Blockly.Extensions.ALL_['mixin_bad_inputList'], 'function');
 
       Blockly.defineBlocksWithJsonArray([{
         "type": "test_block_bad_inputList",
@@ -301,10 +301,10 @@ suite('Extensions', function() {
         colour_: 'bad colour_' // Defined on prototype
       };
 
-      assertUndefined(Blockly.Extensions.ALL_['mixin_bad_colour_']);
+      chai.assert.isUndefined(Blockly.Extensions.ALL_['mixin_bad_colour_']);
       // Extension defined before the block type is defined.
       Blockly.Extensions.registerMixin('mixin_bad_colour_', TEST_MIXIN_BAD_COLOUR);
-      assert(typeof Blockly.Extensions.ALL_['mixin_bad_colour_'] == 'function');
+      chai.assert.typeOf(Blockly.Extensions.ALL_['mixin_bad_colour_'], 'function');
 
       Blockly.defineBlocksWithJsonArray([{
         "type": "test_block_bad_colour",
@@ -331,7 +331,7 @@ suite('Extensions', function() {
       // Events code calls mutationToDom and expects it to give back a
       // meaningful value.
       Blockly.Events.disable();
-      assertUndefined(Blockly.Extensions.ALL_['mutator_test']);
+      chai.assert.isUndefined(Blockly.Extensions.ALL_['mutator_test']);
       Blockly.Extensions.registerMutator('mutator_test',
           {
             domToMutation: function() {
@@ -347,7 +347,7 @@ suite('Extensions', function() {
         var _ = new Blockly.Block(workspace, 'mutator_test_block');
       });
       // Should have failed on apply, not on register.
-      assertNotNull(Blockly.Extensions.ALL_['mutator_test']);
+      chai.assert.isNotNull(Blockly.Extensions.ALL_['mutator_test']);
     });
 
     test('Use mutator mixin as extension', function() {
@@ -363,7 +363,7 @@ suite('Extensions', function() {
       // Events code calls mutationToDom and expects it to give back a
       // meaningful value.
       Blockly.Events.disable();
-      assertUndefined(Blockly.Extensions.ALL_['mutator_test']);
+      chai.assert.isUndefined(Blockly.Extensions.ALL_['mutator_test']);
       Blockly.Extensions.registerMixin('mutator_test',
           {
             domToMutation: function() {
@@ -379,7 +379,7 @@ suite('Extensions', function() {
         var _ = new Blockly.Block(workspace, 'mutator_test_block');
       });
       // Should have failed on apply, not on register.
-      assertNotNull(Blockly.Extensions.ALL_['mutator_test']);
+      chai.assert.isNotNull(Blockly.Extensions.ALL_['mutator_test']);
     });
 
     test('Use extension as mutator', function() {
@@ -395,7 +395,7 @@ suite('Extensions', function() {
       // Events code calls mutationToDom and expects it to give back a
       // meaningful value.
       Blockly.Events.disable();
-      assertUndefined(Blockly.Extensions.ALL_['extensions_test']);
+      chai.assert.isUndefined(Blockly.Extensions.ALL_['extensions_test']);
       Blockly.Extensions.register('extensions_test', function() {
         return 'extensions_test_fn';
       });
@@ -405,13 +405,13 @@ suite('Extensions', function() {
         var _ = new Blockly.Block(workspace, 'mutator_test_block');
       });
       // Should have failed on apply, not on register.
-      assertNotNull(Blockly.Extensions.ALL_['extensions_test']);
+      chai.assert.isNotNull(Blockly.Extensions.ALL_['extensions_test']);
     });
 
     suite('register', function() {
       test('Just a string', function() {
         this.extensionsCleanup_.push('extension_just_a_string');
-        assertUndefined(Blockly.Extensions.ALL_['extension_just_a_string']);
+        chai.assert.isUndefined(Blockly.Extensions.ALL_['extension_just_a_string']);
         chai.assert.throws(function() {
           Blockly.Extensions.register('extension_just_a_string', null);
         });
@@ -419,7 +419,7 @@ suite('Extensions', function() {
 
       test('Null', function() {
         this.extensionsCleanup_.push('extension_is_null');
-        assertUndefined(Blockly.Extensions.ALL_['extension_is_null']);
+        chai.assert.isUndefined(Blockly.Extensions.ALL_['extension_is_null']);
         chai.assert.throws(function() {
           Blockly.Extensions.register('extension_is_null', null);
         });
@@ -427,7 +427,7 @@ suite('Extensions', function() {
 
       test('Undefined', function() {
         this.extensionsCleanup_.push('extension_is_undefined');
-        assertUndefined(Blockly.Extensions.ALL_['extension_is_undefined']);
+        chai.assert.isUndefined(Blockly.Extensions.ALL_['extension_is_undefined']);
         chai.assert.throws(function() {
           Blockly.Extensions.register('extension_is_undefined', null);
         });
diff --git a/tests/mocha/field_angle_test.js b/tests/mocha/field_angle_test.js
index 3c59bf627..8fde28c4b 100644
--- a/tests/mocha/field_angle_test.js
+++ b/tests/mocha/field_angle_test.js
@@ -9,9 +9,9 @@ suite('Angle Fields', function() {
     var actualValue = angleField.getValue();
     var actualText = angleField.getText();
     opt_expectedText = opt_expectedText || String(expectedValue);
-    assertEquals(String(actualValue), String(expectedValue));
-    assertEquals(Number(actualValue), expectedValue);
-    assertEquals(actualText, opt_expectedText);
+    chai.assert.equal(String(actualValue), String(expectedValue));
+    chai.assert.equal(Number(actualValue), expectedValue);
+    chai.assert.equal(actualText, opt_expectedText);
   }
   function assertValueDefault(angleField) {
     assertValue(angleField, 0);
diff --git a/tests/mocha/field_checkbox_test.js b/tests/mocha/field_checkbox_test.js
index 9348bbb4f..dfc95f372 100644
--- a/tests/mocha/field_checkbox_test.js
+++ b/tests/mocha/field_checkbox_test.js
@@ -8,8 +8,8 @@ suite('Checkbox Fields', function() {
   function assertValue(checkboxField, expectedValue, expectedText) {
     var actualValue = checkboxField.getValue();
     var actualText = checkboxField.getText();
-    assertEquals(actualValue, expectedValue);
-    assertEquals(actualText, expectedText);
+    chai.assert.equal(actualValue, expectedValue);
+    chai.assert.equal(actualText, expectedText);
   }
   function assertValueDefault(checkboxField) {
     assertValue(checkboxField, 'FALSE', 'false');
diff --git a/tests/mocha/field_colour_test.js b/tests/mocha/field_colour_test.js
index d2987a691..dbadc14c8 100644
--- a/tests/mocha/field_colour_test.js
+++ b/tests/mocha/field_colour_test.js
@@ -8,8 +8,8 @@ suite('Colour Fields', function() {
   function assertValue(colourField, expectedValue, expectedText) {
     var actualValue = colourField.getValue();
     var actualText = colourField.getText();
-    assertEquals(actualValue, expectedValue);
-    assertEquals(actualText, expectedText);
+    chai.assert.equal(actualValue, expectedValue);
+    chai.assert.equal(actualText, expectedText);
   }
   function assertValueDefault(colourField) {
     var expectedValue = Blockly.FieldColour.COLOURS[0];
diff --git a/tests/mocha/field_date_test.js b/tests/mocha/field_date_test.js
index 50fd781f5..736339ee0 100644
--- a/tests/mocha/field_date_test.js
+++ b/tests/mocha/field_date_test.js
@@ -12,8 +12,8 @@ suite.skip('Date Fields', function() {
   function assertValue(dateField, expectedValue) {
     var actualValue = dateField.getValue();
     var actualText = dateField.getText();
-    assertEquals(actualValue, expectedValue);
-    assertEquals(actualText, expectedValue);
+    chai.assert.equal(actualValue, expectedValue);
+    chai.assert.equal(actualText, expectedValue);
   }
   function assertValueDefault(dateField) {
     var today = new goog.date.Date().toIsoString(true);
diff --git a/tests/mocha/field_dropdown_test.js b/tests/mocha/field_dropdown_test.js
index 0d6e26c30..9e126adc1 100644
--- a/tests/mocha/field_dropdown_test.js
+++ b/tests/mocha/field_dropdown_test.js
@@ -8,8 +8,8 @@ suite('Dropdown Fields', function() {
   function assertValue(dropdownField, expectedValue, expectedText) {
     var actualValue = dropdownField.getValue();
     var actualText = dropdownField.getText();
-    assertEquals(actualValue, expectedValue);
-    assertEquals(actualText, expectedText);
+    chai.assert.equal(actualValue, expectedValue);
+    chai.assert.equal(actualText, expectedText);
   }
   suite('Constructor', function() {
     test('Empty', function() {
diff --git a/tests/mocha/field_image_test.js b/tests/mocha/field_image_test.js
index e5113de1a..f2c415a84 100644
--- a/tests/mocha/field_image_test.js
+++ b/tests/mocha/field_image_test.js
@@ -8,8 +8,8 @@ suite('Image Fields', function() {
   function assertValue(imageField, expectedValue, expectedText) {
     var actualValue = imageField.getValue();
     var actualText = imageField.getText();
-    assertEquals(actualValue, expectedValue);
-    assertEquals(actualText, expectedText);
+    chai.assert.equal(actualValue, expectedValue);
+    chai.assert.equal(actualText, expectedText);
   }
   suite('Constructor', function() {
     test('Empty', function() {
@@ -136,7 +136,7 @@ suite('Image Fields', function() {
       test('Remove Click Handler', function() {
         var field = new Blockly.FieldImage('src', 10, 10, null, this.onClick);
         field.setOnClickHandler(null);
-        chai.assert.equal(field.clickHandler_, null);
+        chai.assert.isNull(field.clickHandler_);
       });
     });
     suite('Alt', function() {
diff --git a/tests/mocha/field_label_serializable_test.js b/tests/mocha/field_label_serializable_test.js
index 676e14fe3..9aa2baebf 100644
--- a/tests/mocha/field_label_serializable_test.js
+++ b/tests/mocha/field_label_serializable_test.js
@@ -8,8 +8,8 @@ suite('Label Serializable Fields', function() {
   function assertValue(labelField, expectedValue) {
     var actualValue = labelField.getValue();
     var actualText = labelField.getText();
-    assertEquals(actualValue, expectedValue);
-    assertEquals(actualText, expectedValue);
+    chai.assert.equal(actualValue, expectedValue);
+    chai.assert.equal(actualText, expectedValue);
   }
   function assertValueDefault(labelField) {
     assertValue(labelField, '');
diff --git a/tests/mocha/field_label_test.js b/tests/mocha/field_label_test.js
index fba48723c..2e7910bbf 100644
--- a/tests/mocha/field_label_test.js
+++ b/tests/mocha/field_label_test.js
@@ -8,8 +8,8 @@ suite('Label Fields', function() {
   function assertValue(labelField, expectedValue) {
     var actualValue = labelField.getValue();
     var actualText = labelField.getText();
-    assertEquals(actualValue, expectedValue);
-    assertEquals(actualText, expectedValue);
+    chai.assert.equal(actualValue, expectedValue);
+    chai.assert.equal(actualText, expectedValue);
   }
   function assertValueDefault(labelField) {
     assertValue(labelField, '');
diff --git a/tests/mocha/field_number_test.js b/tests/mocha/field_number_test.js
index c6564fad7..fcb74d4ab 100644
--- a/tests/mocha/field_number_test.js
+++ b/tests/mocha/field_number_test.js
@@ -9,9 +9,9 @@ suite('Number Fields', function() {
     var actualValue = numberField.getValue();
     var actualText = numberField.getText();
     opt_expectedText = opt_expectedText || String(expectedValue);
-    assertEquals(String(actualValue), String(expectedValue));
-    assertEquals(Number(actualValue), expectedValue);
-    assertEquals(actualText, opt_expectedText);
+    chai.assert.equal(String(actualValue), String(expectedValue));
+    chai.assert.equal(Number(actualValue), expectedValue);
+    chai.assert.equal(actualText, opt_expectedText);
   }
   function assertValueDefault(numberField) {
     assertValue(numberField, 0);
@@ -244,7 +244,7 @@ suite('Number Fields', function() {
         test('Null', function() {
           var numberField = new Blockly.FieldNumber
               .fromJson({ precision: null});
-          assertEquals(numberField.getPrecision(), 0);
+          chai.assert.equal(numberField.getPrecision(), 0);
         });
       });
       suite('Min', function() {
@@ -278,7 +278,7 @@ suite('Number Fields', function() {
         test('Null', function() {
           var numberField = new Blockly.FieldNumber
               .fromJson({ min: null});
-          assertEquals(numberField.getMin(), -Infinity);
+          chai.assert.equal(numberField.getMin(), -Infinity);
         });
       });
       suite('Max', function() {
@@ -312,7 +312,7 @@ suite('Number Fields', function() {
         test('null', function() {
           var numberField = new Blockly.FieldNumber
               .fromJson({ max: null});
-          assertEquals(numberField.getMax(), Infinity);
+          chai.assert.equal(numberField.getMax(), Infinity);
         });
       });
     });
diff --git a/tests/mocha/field_registry_test.js b/tests/mocha/field_registry_test.js
index c8ea3bb2f..c96cd13c8 100644
--- a/tests/mocha/field_registry_test.js
+++ b/tests/mocha/field_registry_test.js
@@ -82,7 +82,7 @@ suite('Field Registry', function() {
 
       var field = Blockly.fieldRegistry.fromJson(json);
       chai.assert.isNotNull(field);
-      chai.assert.equal('ok', field.getValue());
+      chai.assert.equal(field.getValue(), 'ok');
     });
     test('Not Registered', function() {
       var json = {
@@ -106,7 +106,7 @@ suite('Field Registry', function() {
 
       var field = Blockly.fieldRegistry.fromJson(json);
       chai.assert.isNotNull(field);
-      chai.assert.equal('ok', field.getValue());
+      chai.assert.equal(field.getValue(), 'ok');
     });
   });
 });
diff --git a/tests/mocha/field_test.js b/tests/mocha/field_test.js
index 553122fce..1381fb515 100644
--- a/tests/mocha/field_test.js
+++ b/tests/mocha/field_test.js
@@ -36,26 +36,26 @@ suite('Abstract Fields', function() {
       // An old default field should be serialized.
       var field = new FieldDefault();
       var stub = sinon.stub(console, 'warn');
-      assertEquals(true, field.isSerializable());
+      chai.assert.isTrue(field.isSerializable());
       chai.assert(stub.calledOnce);
       stub.restore();
     });
     test('Editable False, Serializable Default(false)', function() {
       // An old non-editable field should not be serialized.
       var field = new FieldFalseDefault();
-      assertEquals(false, field.isSerializable());
+      chai.assert.isFalse(field.isSerializable());
     });
     /* Test Other Cases */
     test('Editable Default(true), Serializable True', function() {
       // A field that is both editable and serializable should be serialized.
       var field = new FieldDefaultTrue();
-      assertEquals(true, field.isSerializable());
+      chai.assert.isTrue(field.isSerializable());
     });
     test('Editable False, Serializable True', function() {
       // A field that is not editable, but overrides serializable to true
       // should be serialized (e.g. field_label_serializable)
       var field = new FieldFalseTrue();
-      assertEquals(true, field.isSerializable());
+      chai.assert.isTrue(field.isSerializable());
     });
   });
   suite('setValue', function() {
diff --git a/tests/mocha/field_textinput_test.js b/tests/mocha/field_textinput_test.js
index 9fcbc16c4..f529452d8 100644
--- a/tests/mocha/field_textinput_test.js
+++ b/tests/mocha/field_textinput_test.js
@@ -9,8 +9,8 @@ suite('Text Input Fields', function() {
     var actualValue = textInputField.getValue();
     var actualText = textInputField.getText();
     opt_expectedText = opt_expectedText || expectedValue;
-    assertEquals(actualValue, expectedValue);
-    assertEquals(actualText, opt_expectedText);
+    chai.assert.equal(actualValue, expectedValue);
+    chai.assert.equal(actualText, opt_expectedText);
   }
   function assertValueDefault(textInputField) {
     assertValue(textInputField, '');
diff --git a/tests/mocha/field_variable_test.js b/tests/mocha/field_variable_test.js
index c3f6bf3c0..1d24ad3f7 100644
--- a/tests/mocha/field_variable_test.js
+++ b/tests/mocha/field_variable_test.js
@@ -36,8 +36,8 @@ suite('Variable Fields', function() {
     var actualName = variableField.getText();
     var actualId = variableField.getValue();
     opt_expectedId = opt_expectedId || FAKE_ID;
-    assertEquals(actualName, expectedName);
-    assertEquals(actualId, opt_expectedId);
+    chai.assert.equal(actualName, expectedName);
+    chai.assert.equal(actualId, opt_expectedId);
   }
   function assertValueDefault(variableField) {
     assertValue(variableField, FAKE_VARIABLE_NAME, FAKE_ID);
@@ -69,10 +69,10 @@ suite('Variable Fields', function() {
         fieldVariable);
 
     // Expect three variable options, a rename option, and a delete option.
-    assertEquals(result_options.length, 5);
-    isEqualArrays(result_options[0], ['name1', 'id1']);
-    isEqualArrays(result_options[1], ['name2', 'id2']);
-    isEqualArrays(result_options[2], ['name3', 'id3']);
+    chai.assert.equal(result_options.length, 5);
+    assertArrayEquals(result_options[0], ['name1', 'id1']);
+    assertArrayEquals(result_options[1], ['name2', 'id2']);
+    assertArrayEquals(result_options[2], ['name3', 'id3']);
   });
   suite('Constructor', function() {
     test('Null', function() {
@@ -86,8 +86,8 @@ suite('Variable Fields', function() {
     });
     test('No Value Before InitModel', function() {
       var fieldVariable = new Blockly.FieldVariable('name1');
-      assertEquals('', fieldVariable.getText());
-      assertNull(fieldVariable.getValue());
+      chai.assert.equal(fieldVariable.getText(), '');
+      chai.assert.isNull(fieldVariable.getValue());
     });
     test('Given Variable Name', function() {
       var fieldVariable = createAndInitFieldConstructor(
@@ -106,8 +106,8 @@ suite('Variable Fields', function() {
     });
     test('No Value Before InitModel', function() {
       var variableField = new Blockly.FieldVariable('name1');
-      assertEquals('', variableField.getText());
-      assertNull(variableField.getValue());
+      chai.assert.equal(variableField.getText(), '');
+      chai.assert.isNull(variableField.getValue());
     });
     test('Given Variable Name', function() {
       var variableField = createAndInitFieldJson(this.workspace, 'name1');
@@ -139,8 +139,8 @@ suite('Variable Fields', function() {
 
       variableField.setValue('id2');
       // Setting value by ID gives us the right text as well.
-      assertEquals('name2', variableField.getText());
-      assertEquals('id2', variableField.getValue());
+      chai.assert.equal(variableField.getText(), 'name2');
+      chai.assert.equal(variableField.getValue(), 'id2');
       chai.assert.notEqual(oldId, variableField.getValue());
     });
     test('Variable Does not Exist', function() {
@@ -244,7 +244,7 @@ suite('Variable Fields', function() {
       // will be returned (regardless of what types are available on the workspace).
       var fieldVariable = new Blockly.FieldVariable('name1');
       var resultTypes = fieldVariable.getVariableTypes_();
-      isEqualArrays(resultTypes, ['']);
+      assertArrayEquals(resultTypes, ['']);
     });
     test('variableTypes is explicit', function() {
       // Expect that since variableTypes is defined, it will be the return
@@ -252,9 +252,9 @@ suite('Variable Fields', function() {
       var fieldVariable = new Blockly.FieldVariable(
           'name1', null, ['type1', 'type2'], 'type1');
       var resultTypes = fieldVariable.getVariableTypes_();
-      isEqualArrays(resultTypes, ['type1', 'type2']);
-      assertEquals('Default type was wrong', 'type1',
-          fieldVariable.defaultType_);
+      assertArrayEquals(resultTypes, ['type1', 'type2']);
+      chai.assert.equal(fieldVariable.defaultType_, 'type1',
+          'Default type was wrong');
     });
     test('variableTypes is null', function() {
       // Expect all variable types to be returned.
@@ -267,7 +267,7 @@ suite('Variable Fields', function() {
 
       var resultTypes = fieldVariable.getVariableTypes_();
       // The empty string is always one of the options.
-      isEqualArrays(resultTypes, ['type1', 'type2', '']);
+      assertArrayEquals(resultTypes, ['type1', 'type2', '']);
     });
     test('variableTypes is the empty list', function() {
       var fieldVariable = new Blockly.FieldVariable('name1');
@@ -283,15 +283,14 @@ suite('Variable Fields', function() {
   suite('Default types', function() {
     test('Default type exists', function() {
       var fieldVariable = new Blockly.FieldVariable(null, null, ['b'], 'b');
-      assertEquals('The variable field\'s default type should be "b"',
-          'b', fieldVariable.defaultType_);
+      chai.assert.equal(fieldVariable.defaultType_, 'b',
+          'The variable field\'s default type should be "b"');
     });
     test('No default type', function() {
       var fieldVariable = new Blockly.FieldVariable(null);
-      assertEquals('The variable field\'s default type should be the empty string',
-          '', fieldVariable.defaultType_);
-      assertNull('The variable field\'s allowed types should be null',
-          fieldVariable.variableTypes);
+      chai.assert.equal(fieldVariable.defaultType_, '', 'The variable field\'s default type should be the empty string');
+      chai.assert.isNull(fieldVariable.variableTypes,
+          'The variable field\'s allowed types should be null');
     });
     test('Default type mismatch', function() {
       // Invalid default type when creating a variable field.
diff --git a/tests/mocha/gesture_test.js b/tests/mocha/gesture_test.js
index 974c7ec0e..89fab0323 100644
--- a/tests/mocha/gesture_test.js
+++ b/tests/mocha/gesture_test.js
@@ -24,8 +24,8 @@ suite('Gesture', function() {
 
   test('Constructor', function() {
     var gesture = new Blockly.Gesture(this.e, this.workspace);
-    assertEquals(gesture.mostRecentEvent_, this.e);
-    assertEquals(gesture.creatorWorkspace_, this.workspace);
+    chai.assert.equal(gesture.mostRecentEvent_, this.e);
+    chai.assert.equal(gesture.creatorWorkspace_, this.workspace);
   });
 
   test('Field click - Click in workspace', function() {
@@ -37,7 +37,7 @@ suite('Gesture', function() {
     gesture.setStartField(field);
   
     var isFieldClick = gesture.isFieldClick_();
-    assertEquals(isFieldClick, true);
+    chai.assert.isTrue(isFieldClick);
   });
 
   function gestureIsFieldClick_InFlyoutHelper(flyout, expectedResult){
@@ -55,7 +55,7 @@ suite('Gesture', function() {
     gesture.setStartFlyout_(this.workspace.flyout_);
   
     var isFieldClick = gesture.isFieldClick_();
-    assertEquals(isFieldClick, expectedResult);
+    chai.assert.equal(isFieldClick, expectedResult);
   }
 
   test('Field click - Auto close flyout', function() {
@@ -82,6 +82,6 @@ suite('Gesture', function() {
     var gesture = new Blockly.Gesture(event, ws);
     gesture.doWorkspaceClick_(event);
     var cursor = ws.getCursor();
-    assertEquals(cursor.getCurNode().getType(), Blockly.ASTNode.types.WORKSPACE);
+    chai.assert.equal(cursor.getCurNode().getType(), Blockly.ASTNode.types.WORKSPACE);
   });
 });
diff --git a/tests/mocha/json_test.js b/tests/mocha/json_test.js
index b6b79123b..290c7ced4 100644
--- a/tests/mocha/json_test.js
+++ b/tests/mocha/json_test.js
@@ -61,11 +61,10 @@ suite('JSON Block Definitions', function() {
       });
       this.blocks_.push(block);
 
-      assertNotNull(block);
-      assertEquals(BLOCK_TYPE, block.type);
-      assertEquals(
-          'Expecting no warnings when defining and creating a simple block.',
-          warnings.length, 0);
+      chai.assert.isNotNull(block);
+      chai.assert.equal(BLOCK_TYPE, block.type);
+      chai.assert.equal(warnings.length, 0,
+          'Expecting no warnings when defining and creating a simple block.');
     });
 
     test('Null or undefined type id', function() {
@@ -74,8 +73,8 @@ suite('JSON Block Definitions', function() {
       this.blockTypes_.push(BLOCK_TYPE1);
       this.blockTypes_.push(BLOCK_TYPE2);
 
-      assertUndefined(Blockly.Blocks[BLOCK_TYPE1]);
-      assertUndefined(Blockly.Blocks[BLOCK_TYPE2]);
+      chai.assert.isUndefined(Blockly.Blocks[BLOCK_TYPE1]);
+      chai.assert.isUndefined(Blockly.Blocks[BLOCK_TYPE2]);
       var blockTypeCount = Object.keys(Blockly.Blocks).length;
 
       var warnings = captureWarnings(function() {
@@ -86,13 +85,13 @@ suite('JSON Block Definitions', function() {
           {"type": BLOCK_TYPE2}]);
       });
 
-      assertNotNullNorUndefined('Block before bad blocks should be defined.',
-          Blockly.Blocks[BLOCK_TYPE1]);
-      assertNotNullNorUndefined('Block after bad blocks should be defined.',
-          Blockly.Blocks[BLOCK_TYPE2]);
-      assertEquals(Object.keys(Blockly.Blocks).length, blockTypeCount + 2);
-      assertEquals(
-          'Expecting 2 warnings, one for each bad block.', warnings.length, 2);
+      chai.assert.isNotNull(Blockly.Blocks[BLOCK_TYPE1],
+          'Block before bad blocks should be defined.');
+      chai.assert.isNotNull(Blockly.Blocks[BLOCK_TYPE2],
+          'Block after bad blocks should be defined.');
+      chai.assert.equal(Object.keys(Blockly.Blocks).length, blockTypeCount + 2);
+      chai.assert.equal(warnings.length, 2,
+          'Expecting 2 warnings, one for each bad block.');
     });
 
     test('Null item', function() {
@@ -101,8 +100,8 @@ suite('JSON Block Definitions', function() {
       this.blockTypes_.push(BLOCK_TYPE1);
       this.blockTypes_.push(BLOCK_TYPE2);
 
-      assertUndefined(Blockly.Blocks[BLOCK_TYPE1]);
-      assertUndefined(Blockly.Blocks[BLOCK_TYPE2]);
+      chai.assert.isUndefined(Blockly.Blocks[BLOCK_TYPE1]);
+      chai.assert.isUndefined(Blockly.Blocks[BLOCK_TYPE2]);
       var blockTypeCount = Object.keys(Blockly.Blocks).length;
 
       var warnings = captureWarnings(function() {
@@ -117,14 +116,12 @@ suite('JSON Block Definitions', function() {
             "message0": 'after'
           }]);
       });
-      assertNotNullNorUndefined(
-          'Block before null in array should be defined.',
-          Blockly.Blocks[BLOCK_TYPE1]);
-      assertNotNullNorUndefined(
-          'Block after null in array should be defined.',
-          Blockly.Blocks[BLOCK_TYPE2]);
-      assertEquals(Object.keys(Blockly.Blocks).length, blockTypeCount + 2);
-      assertEquals('Expected 1 warning for the bad block.', warnings.length, 1);
+      chai.assert.isNotNull(Blockly.Blocks[BLOCK_TYPE1],
+          'Block before null in array should be defined.');
+      chai.assert.isNotNull(Blockly.Blocks[BLOCK_TYPE2],
+          'Block after null in array should be defined.');
+      chai.assert.equal(Object.keys(Blockly.Blocks).length, blockTypeCount + 2);
+      chai.assert.equal(warnings.length, 1, 'Expected 1 warning for the bad block.');
     });
 
     test('Undefined item', function() {
@@ -133,8 +130,8 @@ suite('JSON Block Definitions', function() {
       this.blockTypes_.push(BLOCK_TYPE1);
       this.blockTypes_.push(BLOCK_TYPE2);
 
-      assertUndefined(Blockly.Blocks[BLOCK_TYPE1]);
-      assertUndefined(Blockly.Blocks[BLOCK_TYPE2]);
+      chai.assert.isUndefined(Blockly.Blocks[BLOCK_TYPE1]);
+      chai.assert.isUndefined(Blockly.Blocks[BLOCK_TYPE2]);
       var blockTypeCount = Object.keys(Blockly.Blocks).length;
       var warnings = captureWarnings(function() {
         Blockly.defineBlocksWithJsonArray([
@@ -148,14 +145,12 @@ suite('JSON Block Definitions', function() {
             "message0": 'after'
           }]);
       });
-      assertNotNullNorUndefined(
-          'Block before undefined in array should be defined.',
-          Blockly.Blocks[BLOCK_TYPE1]);
-      assertNotNullNorUndefined(
-          'Block after undefined in array should be defined.',
-          Blockly.Blocks[BLOCK_TYPE2]);
-      assertEquals(Object.keys(Blockly.Blocks).length, blockTypeCount + 2);
-      assertEquals('Expected 1 warning for the bad block.', warnings.length, 1);
+      chai.assert.isNotNull(Blockly.Blocks[BLOCK_TYPE1],
+          'Block before undefined in array should be defined.');
+      chai.assert.isNotNull(Blockly.Blocks[BLOCK_TYPE2],
+          'Block after undefined in array should be defined.');
+      chai.assert.equal(Object.keys(Blockly.Blocks).length, blockTypeCount + 2);
+      chai.assert.equal( warnings.length, 1, 'Expected 1 warning for the bad block.');
     });
 
     test('message0 creates input', function() {
@@ -168,11 +163,11 @@ suite('JSON Block Definitions', function() {
       }]);
 
       var block = new Blockly.Block(this.workspace_, BLOCK_TYPE);
-      assertEquals(1, block.inputList.length);
-      assertEquals(1, block.inputList[0].fieldRow.length);
+      chai.assert.equal(1, block.inputList.length);
+      chai.assert.equal(1, block.inputList[0].fieldRow.length);
       var textField = block.inputList[0].fieldRow[0];
-      assertEquals(Blockly.FieldLabel, textField.constructor);
-      assertEquals(MESSAGE0, textField.getText());
+      chai.assert.equal(Blockly.FieldLabel, textField.constructor);
+      chai.assert.equal(MESSAGE0, textField.getText());
     });
 
     test('message1 and message0 creates two inputs', function() {
@@ -189,17 +184,17 @@ suite('JSON Block Definitions', function() {
 
       var block = new Blockly.Block(this.workspace_, BLOCK_TYPE);
       this.blocks_.push(block);
-      assertEquals(2, block.inputList.length);
+      chai.assert.equal(2, block.inputList.length);
 
-      assertEquals(1, block.inputList[0].fieldRow.length);
+      chai.assert.equal(1, block.inputList[0].fieldRow.length);
       var textField = block.inputList[0].fieldRow[0];
-      assertEquals(Blockly.FieldLabel, textField.constructor);
-      assertEquals(MESSAGE0, textField.getText());
+      chai.assert.equal(Blockly.FieldLabel, textField.constructor);
+      chai.assert.equal(MESSAGE0, textField.getText());
 
-      assertEquals(1, block.inputList[1].fieldRow.length);
+      chai.assert.equal(1, block.inputList[1].fieldRow.length);
       var textField = block.inputList[1].fieldRow[0];
-      assertEquals(Blockly.FieldLabel, textField.constructor);
-      assertEquals(MESSAGE1, textField.getText());
+      chai.assert.equal(Blockly.FieldLabel, textField.constructor);
+      chai.assert.equal(MESSAGE1, textField.getText());
     });
 
     test('Message string is dereferenced', function() {
@@ -217,11 +212,11 @@ suite('JSON Block Definitions', function() {
 
       var block = new Blockly.Block(this.workspace_, BLOCK_TYPE);
       this.blocks_.push(block);
-      assertEquals(1, block.inputList.length);
-      assertEquals(1, block.inputList[0].fieldRow.length);
+      chai.assert.equal(1, block.inputList.length);
+      chai.assert.equal(1, block.inputList[0].fieldRow.length);
       var textField = block.inputList[0].fieldRow[0];
-      assertEquals(Blockly.FieldLabel, textField.constructor);
-      assertEquals(MESSAGE, textField.getText());
+      chai.assert.equal(Blockly.FieldLabel, textField.constructor);
+      chai.assert.equal(MESSAGE, textField.getText());
     });
 
     test('Dropdown', function() {
@@ -249,18 +244,18 @@ suite('JSON Block Definitions', function() {
 
       var block = new Blockly.Block(this.workspace_, BLOCK_TYPE);
       this.blocks_.push(block);
-      assertEquals(1, block.inputList.length);
-      assertEquals(1, block.inputList[0].fieldRow.length);
+      chai.assert.equal(1, block.inputList.length);
+      chai.assert.equal(1, block.inputList[0].fieldRow.length);
       var dropdown = block.inputList[0].fieldRow[0];
-      assertEquals(dropdown, block.getField(FIELD_NAME));
-      assertEquals(Blockly.FieldDropdown, dropdown.constructor);
-      assertEquals(VALUE0, dropdown.getValue());
+      chai.assert.equal(dropdown, block.getField(FIELD_NAME));
+      chai.assert.equal(Blockly.FieldDropdown, dropdown.constructor);
+      chai.assert.equal(VALUE0, dropdown.getValue());
 
       var options = dropdown.getOptions();
-      assertEquals(LABEL0, options[0][0]);
-      assertEquals(VALUE0, options[0][1]);
-      assertEquals(LABEL1, options[1][0]);
-      assertEquals(VALUE1, options[1][1]);
+      chai.assert.equal(LABEL0, options[0][0]);
+      chai.assert.equal(VALUE0, options[0][1]);
+      chai.assert.equal(LABEL1, options[1][0]);
+      chai.assert.equal(VALUE1, options[1][1]);
     });
 
 
@@ -310,34 +305,34 @@ suite('JSON Block Definitions', function() {
 
       var block = new Blockly.Block(this.workspace_, BLOCK_TYPE);
       this.blocks_.push(block);
-      assertEquals(1, block.inputList.length);
-      assertEquals(1, block.inputList[0].fieldRow.length);
+      chai.assert.equal(1, block.inputList.length);
+      chai.assert.equal(1, block.inputList[0].fieldRow.length);
       var dropdown = block.inputList[0].fieldRow[0];
-      assertEquals(dropdown, block.getField(FIELD_NAME));
-      assertEquals(Blockly.FieldDropdown, dropdown.constructor);
-      assertEquals(VALUE0, dropdown.getValue());
+      chai.assert.equal(dropdown, block.getField(FIELD_NAME));
+      chai.assert.equal(Blockly.FieldDropdown, dropdown.constructor);
+      chai.assert.equal(VALUE0, dropdown.getValue());
 
       function assertImageEquals(actualImage, expectedImage) {
-        assertEquals(actualImage.width, expectedImage.width);
-        assertEquals(actualImage.height, expectedImage.height);
-        assertEquals(actualImage.src, expectedImage.src);
+        chai.assert.equal(actualImage.width, expectedImage.width);
+        chai.assert.equal(actualImage.height, expectedImage.height);
+        chai.assert.equal(actualImage.src, expectedImage.src);
       }
 
       var options = dropdown.getOptions();
       var image0 = options[0][0];
       assertImageEquals(IMAGE0, image0);
-      assertEquals(IMAGE0.alt, image0.alt);
-      assertEquals(options[0][1], VALUE0);
+      chai.assert.equal(IMAGE0.alt, image0.alt);
+      chai.assert.equal(options[0][1], VALUE0);
 
       var image1 = options[1][0];
       assertImageEquals(IMAGE1, image1);
-      assertEquals(IMAGE1.alt, IMAGE1_ALT_TEXT);  // Via Msg reference
-      assertEquals(VALUE1, options[1][1]);
+      chai.assert.equal(IMAGE1.alt, IMAGE1_ALT_TEXT);  // Via Msg reference
+      chai.assert.equal(VALUE1, options[1][1]);
 
       var image2 = options[2][0];
       assertImageEquals(IMAGE1, image1);
-      assert(image2.alt == null);  // No alt specified.
-      assertEquals(VALUE2, options[2][1]);
+      chai.assert.notExists(image2.alt);  // No alt specified.
+      chai.assert.equal(VALUE2, options[2][1]);
     });
   });
 });
diff --git a/tests/mocha/key_map_test.js b/tests/mocha/key_map_test.js
index 6683f9fc9..6ccef7335 100644
--- a/tests/mocha/key_map_test.js
+++ b/tests/mocha/key_map_test.js
@@ -14,38 +14,38 @@ suite('Key Map Tests', function() {
       return "test";
     });
     Blockly.user.keyMap.setActionForKey('65', newAction);
-    assertEquals(Blockly.user.keyMap.map_['65'].name, 'test_action');
+    chai.assert.equal(Blockly.user.keyMap.map_['65'].name, 'test_action');
   });
 
   test('Test giving an old action a new key', function() {
     Blockly.user.keyMap.setActionForKey(Blockly.utils.KeyCodes.F,
         Blockly.navigation.ACTION_PREVIOUS);
-    assertEquals(Blockly.user.keyMap.map_[Blockly.utils.KeyCodes.W], undefined);
-    assertEquals(Blockly.user.keyMap.map_[Blockly.utils.KeyCodes.F],
+    chai.assert.isUndefined(Blockly.user.keyMap.map_[Blockly.utils.KeyCodes.W]);
+    chai.assert.equal(Blockly.user.keyMap.map_[Blockly.utils.KeyCodes.F],
         Blockly.navigation.ACTION_PREVIOUS);
   });
 
   test('Test get key by action defined', function() {
     var key = Blockly.user.keyMap.getKeyByAction(Blockly.navigation.ACTION_PREVIOUS);
-    assertEquals(key, Blockly.utils.KeyCodes.W);
+    chai.assert.equal(key, Blockly.utils.KeyCodes.W);
   });
 
-  test('Test get key by action undefined', function() {
+  test('Test get key by action not defined', function() {
     var key = Blockly.user.keyMap.getKeyByAction(new Blockly.Action('something'));
-    assertEquals(key, undefined);
+    chai.assert.notExists(key);
   });
 
   test('Test set key map', function() {
     var testKeyMap = Blockly.user.keyMap.createDefaultKeyMap();
     testKeyMap['randomKey'] = new Blockly.Action('test','',null);
     Blockly.user.keyMap.setKeyMap(testKeyMap);
-    assertEquals(Blockly.user.keyMap.map_['randomKey'].name, 'test');
+    chai.assert.equal(Blockly.user.keyMap.map_['randomKey'].name, 'test');
   });
 
   test('Test get key map returns a clone', function() {
     var keyMap = Blockly.user.keyMap.getKeyMap();
     keyMap['randomKey'] = new Blockly.Action('test', '', null);
-    assertEquals(Blockly.user.keyMap.map_['randomKey'], undefined);
+    chai.assert.isUndefined(Blockly.user.keyMap.map_['randomKey']);
   });
 
   test('Test serialize key code with modifiers', function() {
@@ -56,7 +56,7 @@ suite('Key Map Tests', function() {
       keyCode: 65
     };
     var serializedKey = Blockly.user.keyMap.serializeKeyEvent(mockEvent);
-    assertEquals(serializedKey, 'ShiftControlAltMeta65');
+    chai.assert.equal(serializedKey, 'ShiftControlAltMeta65');
   });
 
   test('Test serialize key code without modifiers', function() {
@@ -67,7 +67,7 @@ suite('Key Map Tests', function() {
       keyCode: 65
     };
     var serializedKey = Blockly.user.keyMap.serializeKeyEvent(mockEvent);
-    assertEquals(serializedKey, '65');
+    chai.assert.equal(serializedKey, '65');
   });
 
   test('Test modifiers in reverse order', function() {
@@ -76,8 +76,8 @@ suite('Key Map Tests', function() {
           Blockly.user.keyMap.modifierKeys.SHIFT]);
     Blockly.user.keyMap.setActionForKey(testKey, new Blockly.Action('test', '', null));
     var action = Blockly.user.keyMap.getActionByKeyCode('ShiftControl75');
-    assertNotNull(action);
-    assertEquals(action.name, 'test');
+    chai.assert.isNotNull(action);
+    chai.assert.equal(action.name, 'test');
   });
 
   test('Test report invalid modifiers', function() {
diff --git a/tests/mocha/metrics_test.js b/tests/mocha/metrics_test.js
index 1a646b3cd..f5bfbfbc9 100644
--- a/tests/mocha/metrics_test.js
+++ b/tests/mocha/metrics_test.js
@@ -12,10 +12,10 @@
 
 suite('Metrics', function() {
   function assertDimensionsMatch(toCheck, left, top, width, height) {
-    assertEquals('Top did not match.', top, toCheck.top);
-    assertEquals('Left did not match.', left, toCheck.left);
-    assertEquals('Width did not match.', width, toCheck.width);
-    assertEquals('Height did not match.', height, toCheck.height);
+    chai.assert.equal(top, toCheck.top, 'Top did not match.');
+    chai.assert.equal(left, toCheck.left, 'Left did not match.');
+    chai.assert.equal(width, toCheck.width, 'Width did not match.');
+    chai.assert.equal(height, toCheck.height, 'Height did not match.');
   }
 
   // Make a mock workspace object with two properties:
diff --git a/tests/mocha/names_test.js b/tests/mocha/names_test.js
index 18b1e5503..8cf89f380 100644
--- a/tests/mocha/names_test.js
+++ b/tests/mocha/names_test.js
@@ -14,44 +14,43 @@ suite('Names', function() {
 
   test('Safe name', function() {
     var varDB = new Blockly.Names('window,door');
-    assertEquals('SafeName empty.', 'unnamed', varDB.safeName_(''));
-    assertEquals('SafeName ok.', 'foobar', varDB.safeName_('foobar'));
-    assertEquals('SafeName number start.', 'my_9lives',
-        varDB.safeName_('9lives'));
-    assertEquals('SafeName number end.', 'lives9', varDB.safeName_('lives9'));
-    assertEquals('SafeName special chars.', '____', varDB.safeName_('!@#$'));
-    assertEquals('SafeName reserved.', 'door', varDB.safeName_('door'));
+    chai.assert.equal(varDB.safeName_(''), 'unnamed','SafeName empty.');
+    chai.assert.equal( varDB.safeName_('foobar'), 'foobar','SafeName ok.');
+    chai.assert.equal(varDB.safeName_('9lives'), 'my_9lives', 'SafeName number start.');
+    chai.assert.equal(varDB.safeName_('lives9'), 'lives9', 'SafeName number end.');
+    chai.assert.equal(varDB.safeName_('!@#$'), '____', 'SafeName special chars.');
+    chai.assert.equal(varDB.safeName_('door'), 'door', 'SafeName reserved.');
   });
 
   test('Get name', function() {
     var varDB = new Blockly.Names('window,door');
-    assertEquals('Name add #1.', 'Foo_bar', varDB.getName('Foo.bar', 'var'));
-    assertEquals('Name get #1.', 'Foo_bar', varDB.getName('Foo.bar', 'var'));
-    assertEquals('Name add #2.', 'Foo_bar2', varDB.getName('Foo bar', 'var'));
-    assertEquals('Name get #2.', 'Foo_bar2', varDB.getName('foo BAR', 'var'));
-    assertEquals('Name add #3.', 'door2', varDB.getName('door', 'var'));
-    assertEquals('Name add #4.', 'Foo_bar3', varDB.getName('Foo.bar', 'proc'));
-    assertEquals('Name get #1b.', 'Foo_bar', varDB.getName('Foo.bar', 'var'));
-    assertEquals('Name get #4.', 'Foo_bar3', varDB.getName('Foo.bar', 'proc'));
+    chai.assert.equal(varDB.getName('Foo.bar', 'var'), 'Foo_bar', 'Name add #1.');
+    chai.assert.equal(varDB.getName('Foo.bar', 'var'), 'Foo_bar', 'Name get #1.');
+    chai.assert.equal(varDB.getName('Foo bar', 'var'), 'Foo_bar2', 'Name add #2.');
+    chai.assert.equal(varDB.getName('foo BAR', 'var'), 'Foo_bar2', 'Name get #2.');
+    chai.assert.equal(varDB.getName('door', 'var'), 'door2', 'Name add #3.');
+    chai.assert.equal(varDB.getName('Foo.bar', 'proc'), 'Foo_bar3', 'Name add #4.');
+    chai.assert.equal(varDB.getName('Foo.bar', 'var'), 'Foo_bar', 'Name get #1b.');
+    chai.assert.equal(varDB.getName('Foo.bar', 'proc'), 'Foo_bar3', 'Name get #4.');
   });
 
   test('Get distinct name', function() {
     var varDB = new Blockly.Names('window,door');
-    assertEquals('Name distinct #1.', 'Foo_bar',
-        varDB.getDistinctName('Foo.bar', 'var'));
-    assertEquals('Name distinct #2.', 'Foo_bar2',
-        varDB.getDistinctName('Foo.bar', 'var'));
-    assertEquals('Name distinct #3.', 'Foo_bar3',
-        varDB.getDistinctName('Foo.bar', 'proc'));
+    chai.assert.equal(varDB.getDistinctName('Foo.bar', 'var'), 'Foo_bar',
+        'Name distinct #1.');
+    chai.assert.equal(varDB.getDistinctName('Foo.bar', 'var'), 'Foo_bar2',
+        'Name distinct #2.');
+    chai.assert.equal(varDB.getDistinctName('Foo.bar', 'proc'), 'Foo_bar3',
+        'Name distinct #3.');
     varDB.reset();
-    assertEquals('Name distinct #4.', 'Foo_bar',
-        varDB.getDistinctName('Foo.bar', 'var'));
+    chai.assert.equal(varDB.getDistinctName('Foo.bar', 'var'), 'Foo_bar',
+        'Name distinct #4.');
   });
 
   test('name equals', function() {
-    assertTrue('Name equals #1.', Blockly.Names.equals('Foo.bar', 'Foo.bar'));
-    assertFalse('Name equals #2.', Blockly.Names.equals('Foo.bar', 'Foo_bar'));
-    assertTrue('Name equals #3.', Blockly.Names.equals('Foo.bar', 'FOO.BAR'));
+    chai.assert.isTrue(Blockly.Names.equals('Foo.bar', 'Foo.bar'), 'Name equals #1.');
+    chai.assert.isFalse(Blockly.Names.equals('Foo.bar', 'Foo_bar'), 'Name equals #2.');
+    chai.assert.isTrue(Blockly.Names.equals('Foo.bar', 'FOO.BAR'), 'Name equals #3.');
   });
 
 });
diff --git a/tests/mocha/navigation_modify_test.js b/tests/mocha/navigation_modify_test.js
index 3cd5fdaf1..0c993bde9 100644
--- a/tests/mocha/navigation_modify_test.js
+++ b/tests/mocha/navigation_modify_test.js
@@ -195,7 +195,7 @@ suite('Insert/Modify', function() {
             Blockly.ASTNode.createConnectionNode(
                 this.row_block_1.outputConnection));
         chai.assert.isFalse(Blockly.navigation.modify_());
-        chai.assert.equal(this.row_block_1.getParent(), null);
+        chai.assert.isNull(this.row_block_1.getParent());
       });
 
     });
diff --git a/tests/mocha/navigation_test.js b/tests/mocha/navigation_test.js
index 5a377b383..a176daeb5 100644
--- a/tests/mocha/navigation_test.js
+++ b/tests/mocha/navigation_test.js
@@ -662,7 +662,7 @@ suite('Navigation', function() {
       Blockly.navigation.connect_(cursorLocation, markedLocation);
 
       chai.assert.equal(this.basicBlock.nextConnection.targetBlock(), this.basicBlock4);
-      chai.assert.equal(this.basicBlock3.nextConnection.targetConnection, null);
+      chai.assert.isNull(this.basicBlock3.nextConnection.targetConnection);
     });
 
     test('Connect cursor with parents', function() {
@@ -680,7 +680,7 @@ suite('Navigation', function() {
 
       Blockly.navigation.connect_(cursorLocation, markedLocation);
 
-      chai.assert.equal(this.inlineBlock2.outputConnection.targetBlock(), null);
+      chai.assert.isNull(this.inlineBlock2.outputConnection.targetBlock());
       chai.assert.equal(this.inlineBlock1.outputConnection.targetBlock(), this.inlineBlock2);
     });
   });
diff --git a/tests/mocha/test_helpers.js b/tests/mocha/test_helpers.js
index 86748490c..af4624174 100644
--- a/tests/mocha/test_helpers.js
+++ b/tests/mocha/test_helpers.js
@@ -4,141 +4,24 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-/* exported assertEquals, assertNotEquals, assertArrayEquals, assertTrue, assertFalse,
-   assertNull, assertNotNull, assertNotNullNorUndefined, assert,
-   isEqualArrays, assertUndefined, assertNotUndefined, assertVariableValues,
-   defineRowBlock, defineStackBlock, defineStatementBlock, createTestBlock */
-function _argumentsIncludeComments(expectedNumberOfNonCommentArgs, args) {
-  return args.length == expectedNumberOfNonCommentArgs + 1;
-}
-
-function _commentArg(expectedNumberOfNonCommentArgs, args) {
-  if (_argumentsIncludeComments(expectedNumberOfNonCommentArgs, args)) {
-    return args[0];
-  }
-
-  return null;
-}
-
-function _nonCommentArg(desiredNonCommentArgIndex, expectedNumberOfNonCommentArgs, args) {
-  return _argumentsIncludeComments(expectedNumberOfNonCommentArgs, args) ?
-      args[desiredNonCommentArgIndex] :
-      args[desiredNonCommentArgIndex - 1];
-}
-
-function _validateArguments(expectedNumberOfNonCommentArgs, args) {
-  if (!( args.length == expectedNumberOfNonCommentArgs ||
-      (args.length == expectedNumberOfNonCommentArgs + 1 && (typeof(args[0]) == 'string') || args[0] == null))) {
-    throw Error('Incorrect arguments passed to assert function');
-  }
-}
-/**
- * Converts from JSUnit assertEquals to chai.assert.equal.
- */
-function assertEquals() {
-  _validateArguments(2, arguments);
-  var var1 = _nonCommentArg(1, 2, arguments);
-  var var2 = _nonCommentArg(2, 2, arguments);
-  var comment = _commentArg(2, arguments);
-  chai.assert.equal(var1, var2, comment);
-}
-
-/**
- * Converts from JSUnit assertNotEquals to chai.assert.notEquals.
- */
-function assertNotEquals() {
-  _validateArguments(2, arguments);
-  var var1 = _nonCommentArg(1, 2, arguments);
-  var var2 = _nonCommentArg(2, 2, arguments);
-  var comment = _commentArg(2, arguments);
-  chai.assert.notEqual(var1, var2, comment);
-}
-
-/**
- * Converts from JSUnit assertTrue to chai.assert.isTrue.
- */
-function assertTrue() {
-  _validateArguments(1, arguments);
-  var commentArg = _commentArg(1, arguments);
-  var booleanValue = _nonCommentArg(1, 1, arguments);
-  if (typeof(booleanValue) != 'boolean') {
-    throw Error('Bad argument to assertTrue(boolean)');
-  }
-
-  chai.assert.isTrue(booleanValue, commentArg);
-}
-
-/**
- * Converts from JSUnit assertFalse to chai.assert.isNotTrue.
- */
-function assertFalse() {
-  _validateArguments(1, arguments);
-  var commentArg = _commentArg(1, arguments);
-  var booleanValue = _nonCommentArg(1, 1, arguments);
-
-  if (typeof(booleanValue) != 'boolean') {
-    throw Error('Bad argument to assertFalse(boolean)');
-  }
-
-  chai.assert.isNotTrue(booleanValue, commentArg);
-}
-
-/**
- * Converts from JSUnit assertNull to chai.assert.isNull.
- */
-function assertNull() {
-  _validateArguments(1, arguments);
-  var commentArg = _commentArg(1, arguments);
-  var val = _nonCommentArg(1, 1, arguments);
-  chai.assert.isNull(val, commentArg);
-}
-
-function assertNotNull() {
-  _validateArguments(1, arguments);
-  var commentArg = _commentArg(1, arguments);
-  var val = _nonCommentArg(1, 1, arguments);
-  chai.assert.isNotNull(val, commentArg);
-}
-
-function assertNotNullNorUndefined() {
-  assertNotNull(arguments);
-}
-
-function assert() {
-  chai.assert(arguments);
-}
+/* exported assertArrayEquals, assertVariableValues, defineRowBlock,
+   defineStackBlock, defineStatementBlock, createTestBlock */
 
 /**
  * Check that two arrays have the same content.
  * @param {!Array.<string>} array1 The first array.
  * @param {!Array.<string>} array2 The second array.
+ * @param {?string} opt_message Optional message to pass into assert.
  */
-function isEqualArrays(array1, array2) {
-  assertEquals(array1.length, array2.length);
+function isEqualArrays(array1, array2, opt_message) {
+  chai.assert.equal(array1.length, array2.length, opt_message);
   for (var i = 0; i < array1.length; i++) {
-    assertEquals(array1[i], array2[i]);
+    chai.assert.equal(array1[i], array2[i], opt_message);
   }
 }
 
-function assertUndefined() {
-  _validateArguments(1, arguments);
-  var commentArg = _commentArg(1, arguments);
-  var val = _nonCommentArg(1, 1, arguments);
-  chai.assert.isUndefined(val, commentArg);
-}
-
-function assertNotUndefined() {
-  _validateArguments(1, arguments);
-  var commentArg = _commentArg(1, arguments);
-  var val = _nonCommentArg(1, 1, arguments);
-  chai.assert.isDefined(val, commentArg);
-}
-
-function assertArrayEquals() {
-  _validateArguments(2, arguments);
-  var var1 = _nonCommentArg(1, 2, arguments);
-  var var2 = _nonCommentArg(2, 2, arguments);
-  isEqualArrays(var1, var2);
+function assertArrayEquals(actualArray, expectedArray, opt_message) {
+  isEqualArrays(actualArray, expectedArray, opt_message);
 }
 
 /**
@@ -151,10 +34,10 @@ function assertArrayEquals() {
  */
 function assertVariableValues(container, name, type, id) {
   var variable = container.getVariableById(id);
-  assertNotNull(variable);
-  assertEquals(name, variable.name);
-  assertEquals(type, variable.type);
-  assertEquals(id, variable.getId());
+  chai.assert.isDefined(variable);
+  chai.assert.equal(variable.name, name);
+  chai.assert.equal(variable.type, type);
+  chai.assert.equal(variable.getId(), id);
 }
 
 function defineStackBlock() {
diff --git a/tests/mocha/theme_test.js b/tests/mocha/theme_test.js
index cfe9aa376..d9c15d709 100644
--- a/tests/mocha/theme_test.js
+++ b/tests/mocha/theme_test.js
@@ -69,7 +69,7 @@ suite('Theme', function() {
   function stringifyAndCompare(val1, val2) {
     var stringVal1 = JSON.stringify(val1);
     var stringVal2 = JSON.stringify(val2);
-    assertEquals(stringVal1, stringVal2);
+    chai.assert.equal(stringVal1, stringVal2);
   }
 
   test('Set All BlockStyles', function() {
@@ -136,12 +136,12 @@ suite('Theme', function() {
     stringifyAndCompare(workspace.getTheme(), blockStyles);
 
     // Checks that the setTheme function was called on the block
-    assertEquals(blockA.getStyleName(), 'styleTwo');
+    chai.assert.equal(blockA.getStyleName(), 'styleTwo');
 
     // check that the toolbox refreshed method was called
-    assertEquals(workspace.refreshToolboxSelection(), 3);
+    chai.assert.equal(workspace.refreshToolboxSelection(), 3);
 
-    assertEquals(Blockly.Events.FIRE_QUEUE_.pop().element, 'theme');
+    chai.assert.equal(Blockly.Events.FIRE_QUEUE_.pop().element, 'theme');
 
     undefineThemeTestBlocks();
 
diff --git a/tests/mocha/utils_test.js b/tests/mocha/utils_test.js
index 2f06958d5..9786158c9 100644
--- a/tests/mocha/utils_test.js
+++ b/tests/mocha/utils_test.js
@@ -18,71 +18,71 @@ suite('Utils', function() {
   suite('tokenizeInterpolation', function() {
     test('Basic', function() {
       var tokens = Blockly.utils.tokenizeInterpolation('');
-      assertArrayEquals('Null interpolation', [], tokens);
+      assertArrayEquals(tokens, [], 'Null interpolation');
 
       tokens = Blockly.utils.tokenizeInterpolation('Hello');
-      assertArrayEquals('No interpolation', ['Hello'], tokens);
+      assertArrayEquals(tokens, ['Hello'], 'No interpolation');
 
       tokens = Blockly.utils.tokenizeInterpolation('Hello%World');
-      assertArrayEquals('Unescaped %.', ['Hello%World'], tokens);
+      assertArrayEquals(tokens, ['Hello%World'], 'Unescaped %.');
 
       tokens = Blockly.utils.tokenizeInterpolation('Hello%%World');
-      assertArrayEquals('Escaped %.', ['Hello%World'], tokens);
+      assertArrayEquals(tokens, ['Hello%World'], 'Escaped %.');
 
       tokens = Blockly.utils.tokenizeInterpolation('Hello %1 World');
-      assertArrayEquals('Interpolation.', ['Hello ', 1, ' World'], tokens);
+      assertArrayEquals(tokens, ['Hello ', 1, ' World'], 'Interpolation.');
 
       tokens = Blockly.utils.tokenizeInterpolation('%123Hello%456World%789');
-      assertArrayEquals('Interpolations.', [123, 'Hello', 456, 'World', 789], tokens);
+      assertArrayEquals(tokens, [123, 'Hello', 456, 'World', 789], 'Interpolations.');
 
       tokens = Blockly.utils.tokenizeInterpolation('%%%x%%0%00%01%');
-      assertArrayEquals('Torture interpolations.', ['%%x%0', 0, 1, '%'], tokens);
+      assertArrayEquals(tokens, ['%%x%0', 0, 1, '%'], 'Torture interpolations.');
     });
 
     test('String table', function() {
       Blockly.Msg = Blockly.Msg || {};
       Blockly.Msg.STRING_REF = 'test string';
       var tokens = Blockly.utils.tokenizeInterpolation('%{bky_string_ref}');
-      assertArrayEquals('String table reference, lowercase', ['test string'], tokens);
+      assertArrayEquals(tokens, ['test string'], 'String table reference, lowercase');
       tokens = Blockly.utils.tokenizeInterpolation('%{BKY_STRING_REF}');
-      assertArrayEquals('String table reference, uppercase', ['test string'], tokens);
+      assertArrayEquals(tokens, ['test string'], 'String table reference, uppercase');
 
       Blockly.Msg.WITH_PARAM = 'before %1 after';
       tokens = Blockly.utils.tokenizeInterpolation('%{bky_with_param}');
-      assertArrayEquals('String table reference, with parameter', ['before ', 1, ' after'], tokens);
+      assertArrayEquals(tokens, ['before ', 1, ' after'], 'String table reference, with parameter');
 
       Blockly.Msg.RECURSE = 'before %{bky_string_ref} after';
       tokens = Blockly.utils.tokenizeInterpolation('%{bky_recurse}');
-      assertArrayEquals('String table reference, with subreference', ['before test string after'], tokens);
+      assertArrayEquals(tokens, ['before test string after'], 'String table reference, with subreference');
     });
 
     test('Error cases', function() {
       var tokens = Blockly.utils.tokenizeInterpolation('%{bky_undefined}');
-      assertArrayEquals('Undefined string table reference', ['%{bky_undefined}'], tokens);
+      assertArrayEquals(tokens, ['%{bky_undefined}'], 'Undefined string table reference');
 
       Blockly.Msg['1'] = 'Will not match';
       tokens = Blockly.utils.tokenizeInterpolation('before %{1} after');
-      assertArrayEquals('Invalid initial digit in string table reference', ['before %{1} after'], tokens);
+      assertArrayEquals(tokens, ['before %{1} after'], 'Invalid initial digit in string table reference');
 
       Blockly.Msg['TWO WORDS'] = 'Will not match';
       tokens = Blockly.utils.tokenizeInterpolation('before %{two words} after');
-      assertArrayEquals('Invalid character in string table reference: space', ['before %{two words} after'], tokens);
+      assertArrayEquals(tokens, ['before %{two words} after'], 'Invalid character in string table reference: space');
 
       Blockly.Msg['TWO-WORDS'] = 'Will not match';
       tokens = Blockly.utils.tokenizeInterpolation('before %{two-words} after');
-      assertArrayEquals('Invalid character in string table reference: dash', ['before %{two-words} after'], tokens);
+      assertArrayEquals(tokens, ['before %{two-words} after'], 'Invalid character in string table reference: dash');
 
       Blockly.Msg['TWO.WORDS'] = 'Will not match';
       tokens = Blockly.utils.tokenizeInterpolation('before %{two.words} after');
-      assertArrayEquals('Invalid character in string table reference: period', ['before %{two.words} after'], tokens);
+      assertArrayEquals(tokens, ['before %{two.words} after'], 'Invalid character in string table reference: period');
 
       Blockly.Msg['AB&C'] = 'Will not match';
       tokens = Blockly.utils.tokenizeInterpolation('before %{ab&c} after');
-      assertArrayEquals('Invalid character in string table reference: &', ['before %{ab&c} after'], tokens);
+      assertArrayEquals(tokens, ['before %{ab&c} after'], 'Invalid character in string table reference: &');
 
       Blockly.Msg['UNCLOSED'] = 'Will not match';
       tokens = Blockly.utils.tokenizeInterpolation('before %{unclosed');
-      assertArrayEquals('String table reference, with parameter', ['before %{unclosed'], tokens);
+      assertArrayEquals(tokens, ['before %{unclosed'], 'String table reference, with parameter');
     });
   });
 
@@ -94,252 +94,252 @@ suite('Utils', function() {
     Blockly.Msg.STRING_REF_WITH_SUBREF = 'test %{bky_subref} string';
 
     var resultString = Blockly.utils.replaceMessageReferences('');
-    assertEquals('Empty string produces empty string', '', resultString);
+    chai.assert.equal(resultString, '', 'Empty string produces empty string');
 
     resultString = Blockly.utils.replaceMessageReferences('%%');
-    assertEquals('Escaped %', '%', resultString);
+    chai.assert.equal(resultString, '%', 'Escaped %');
     resultString = Blockly.utils.replaceMessageReferences('%%{bky_string_ref}');
-    assertEquals('Escaped %', '%{bky_string_ref}', resultString);
+    chai.assert.equal(resultString, '%{bky_string_ref}', 'Escaped %');
 
     resultString = Blockly.utils.replaceMessageReferences('%a');
-    assertEquals('Unrecognized % escape code treated as literal', '%a', resultString);
+    chai.assert.equal(resultString, '%a', 'Unrecognized % escape code treated as literal');
 
     resultString = Blockly.utils.replaceMessageReferences('%1');
-    assertEquals('Interpolation tokens ignored.', '%1', resultString);
+    chai.assert.equal(resultString, '%1', 'Interpolation tokens ignored.');
     resultString = Blockly.utils.replaceMessageReferences('%1 %2');
-    assertEquals('Interpolation tokens ignored.', '%1 %2', resultString);
+    chai.assert.equal(resultString, '%1 %2', 'Interpolation tokens ignored.');
     resultString = Blockly.utils.replaceMessageReferences('before %1 after');
-    assertEquals('Interpolation tokens ignored.', 'before %1 after', resultString);
+    chai.assert.equal(resultString, 'before %1 after', 'Interpolation tokens ignored.');
 
     // Blockly.Msg.STRING_REF cases:
     resultString = Blockly.utils.replaceMessageReferences('%{bky_string_ref}');
-    assertEquals('Message ref dereferenced.', 'test string', resultString);
+    chai.assert.equal(resultString, 'test string', 'Message ref dereferenced.');
     resultString = Blockly.utils.replaceMessageReferences('before %{bky_string_ref} after');
-    assertEquals('Message ref dereferenced.', 'before test string after', resultString);
+    chai.assert.equal(resultString, 'before test string after', 'Message ref dereferenced.');
 
     // Blockly.Msg.STRING_REF_WITH_ARG cases:
     resultString = Blockly.utils.replaceMessageReferences('%{bky_string_ref_with_arg}');
-    assertEquals('Message ref dereferenced with argument preserved.', 'test %1 string', resultString);
+    chai.assert.equal(resultString, 'test %1 string', 'Message ref dereferenced with argument preserved.');
     resultString = Blockly.utils.replaceMessageReferences('before %{bky_string_ref_with_arg} after');
-    assertEquals('Message ref dereferenced with argument preserved.', 'before test %1 string after', resultString);
+    chai.assert.equal(resultString, 'before test %1 string after', 'Message ref dereferenced with argument preserved.');
 
     // Blockly.Msg.STRING_REF_WITH_SUBREF cases:
     resultString = Blockly.utils.replaceMessageReferences('%{bky_string_ref_with_subref}');
-    assertEquals('Message ref and subref dereferenced.', 'test subref string', resultString);
+    chai.assert.equal(resultString, 'test subref string', 'Message ref and subref dereferenced.');
     resultString = Blockly.utils.replaceMessageReferences('before %{bky_string_ref_with_subref} after');
-    assertEquals('Message ref and subref dereferenced.', 'before test subref string after', resultString);
+    chai.assert.equal(resultString, 'before test subref string after', 'Message ref and subref dereferenced.');
   });
 
   test('arrayRemove', function() {
     var arr = [1, 2, 3, 2];
-    assertEquals('Remove Not found', false, Blockly.utils.arrayRemove(arr, 0));
-    assertEquals('Remove Not found result', '1,2,3,2', arr.join(','));
-    assertEquals('Remove item', true, Blockly.utils.arrayRemove(arr, 2));
-    assertEquals('Remove item result', '1,3,2', arr.join(','));
-    assertEquals('Remove item again', true, Blockly.utils.arrayRemove(arr, 2));
-    assertEquals('Remove item again result', '1,3', arr.join(','));
+    chai.assert.isFalse(Blockly.utils.arrayRemove(arr, 0), 'Remove Not found');
+    chai.assert.equal(arr.join(','), '1,2,3,2', 'Remove Not found result');
+    chai.assert.isTrue(Blockly.utils.arrayRemove(arr, 2), 'Remove item');
+    chai.assert.equal(arr.join(','), '1,3,2', 'Remove item result');
+    chai.assert.isTrue(Blockly.utils.arrayRemove(arr, 2), 'Remove item again');
+    chai.assert.equal(arr.join(','), '1,3', 'Remove item again result');
   });
 
   test('XY_REGEX_', function() {
     var regex = Blockly.utils.getRelativeXY.XY_REGEX_;
     var m;
     m = 'INVALID'.match(regex);
-    assertNull(m);
+    chai.assert.isNull(m);
 
     m = 'translate(10)'.match(regex);
-    assertEquals('translate(10), x', '10', m[1]);
-    assertUndefined('translate(10), y', m[3]);
+    chai.assert.equal(m[1], '10', 'translate(10), x');
+    chai.assert.isUndefined(m[3], 'translate(10), y');
 
     m = 'translate(11, 12)'.match(regex);
-    assertEquals('translate(11, 12), x', '11', m[1]);
-    assertEquals('translate(11, 12), y', '12', m[3]);
+    chai.assert.equal(m[1], '11', 'translate(11, 12), x');
+    chai.assert.equal(m[3], '12', 'translate(11, 12), y');
 
     m = 'translate(13,14)'.match(regex);
-    assertEquals('translate(13,14), x', '13', m[1]);
-    assertEquals('translate(13,14), y', '14', m[3]);
+    chai.assert.equal(m[1], '13', 'translate(13,14), x');
+    chai.assert.equal(m[3], '14', 'translate(13,14), y');
 
     m = 'translate(15 16)'.match(regex);
-    assertEquals('translate(15 16), x', '15', m[1]);
-    assertEquals('translate(15 16), y', '16', m[3]);
+    chai.assert.equal(m[1], '15', 'translate(15 16), x');
+    chai.assert.equal(m[3], '16', 'translate(15 16), y');
 
     m = 'translate(1.23456e+42 0.123456e-42)'.match(regex);
-    assertEquals('translate(1.23456e+42 0.123456e-42), x', '1.23456e+42', m[1]);
-    assertEquals('translate(1.23456e+42 0.123456e-42), y', '0.123456e-42', m[3]);
+    chai.assert.equal(m[1], '1.23456e+42', 'translate(1.23456e+42 0.123456e-42), x');
+    chai.assert.equal(m[3], '0.123456e-42', 'translate(1.23456e+42 0.123456e-42), y');
   });
 
   test('XY_STYLE_REGEX_', function() {
     var regex = Blockly.utils.getRelativeXY.XY_STYLE_REGEX_;
     var m;
     m = 'INVALID'.match(regex);
-    assertNull(m);
+    chai.assert.isNull(m);
 
     m = 'transform:translate(9px)'.match(regex);
-    assertEquals('transform:translate(9px), x', '9', m[1]);
-    assertUndefined('transform:translate(9px), y', m[3]);
+    chai.assert.equal(m[1], '9', 'transform:translate(9px), x');
+    chai.assert.isUndefined(m[3], 'transform:translate(9px), y');
 
     m = 'transform:translate3d(10px)'.match(regex);
-    assertEquals('transform:translate3d(10px), x', '10', m[1]);
-    assertUndefined('transform:translate(10px), y', m[3]);
+    chai.assert.equal(m[1], '10', 'transform:translate3d(10px), x');
+    chai.assert.isUndefined(m[3], 'transform:translate(10px), y');
 
     m = 'transform: translate(11px, 12px)'.match(regex);
-    assertEquals('transform: translate(11px, 12px), x', '11', m[1]);
-    assertEquals('transform: translate(11px, 12px), y', '12', m[3]);
+    chai.assert.equal(m[1], '11', 'transform: translate(11px, 12px), x');
+    chai.assert.equal(m[3], '12', 'transform: translate(11px, 12px), y');
 
     m = 'transform: translate(13px,14px)'.match(regex);
-    assertEquals('transform: translate(13px,14px), x', '13', m[1]);
-    assertEquals('transform: translate(13px,14px), y', '14', m[3]);
+    chai.assert.equal(m[1], '13', 'transform: translate(13px,14px), x');
+    chai.assert.equal(m[3], '14', 'transform: translate(13px,14px), y');
 
     m = 'transform: translate(15px 16px)'.match(regex);
-    assertEquals('transform: translate(15px 16px), x', '15', m[1]);
-    assertEquals('transform: translate(15px 16px), y', '16', m[3]);
+    chai.assert.equal(m[1], '15', 'transform: translate(15px 16px), x');
+    chai.assert.equal(m[3], '16', 'transform: translate(15px 16px), y');
 
     m = 'transform: translate(1.23456e+42px 0.123456e-42px)'.match(regex);
-    assertEquals('transform: translate(1.23456e+42px 0.123456e-42px), x', '1.23456e+42', m[1]);
-    assertEquals('transform: translate(1.23456e+42px 0.123456e-42px), y', '0.123456e-42', m[3]);
+    chai.assert.equal(m[1], '1.23456e+42', 'transform: translate(1.23456e+42px 0.123456e-42px), x');
+    chai.assert.equal(m[3], '0.123456e-42', 'transform: translate(1.23456e+42px 0.123456e-42px), y');
 
     m = 'transform:translate3d(20px, 21px, 22px)'.match(regex);
-    assertEquals('transform:translate3d(20px, 21px, 22px), x', '20', m[1]);
-    assertEquals('transform:translate3d(20px, 21px, 22px), y', '21', m[3]);
+    chai.assert.equal(m[1], '20', 'transform:translate3d(20px, 21px, 22px), x');
+    chai.assert.equal(m[3], '21', 'transform:translate3d(20px, 21px, 22px), y');
 
     m = 'transform:translate3d(23px,24px,25px)'.match(regex);
-    assertEquals('transform:translate3d(23px,24px,25px), x', '23', m[1]);
-    assertEquals('transform:translate3d(23px,24px,25px), y', '24', m[3]);
+    chai.assert.equal(m[1], '23', 'transform:translate3d(23px,24px,25px), x');
+    chai.assert.equal(m[3], '24', 'transform:translate3d(23px,24px,25px), y');
 
     m = 'transform:translate3d(26px 27px 28px)'.match(regex);
-    assertEquals('transform:translate3d(26px 27px 28px), x', '26', m[1]);
-    assertEquals('transform:translate3d(26px 27px 28px), y', '27', m[3]);
+    chai.assert.equal(m[1], '26', 'transform:translate3d(26px 27px 28px), x');
+    chai.assert.equal(m[3], '27', 'transform:translate3d(26px 27px 28px), y');
 
     m = 'transform:translate3d(1.23456e+42px 0.123456e-42px 42px)'.match(regex);
-    assertEquals('transform:translate3d(1.23456e+42px 0.123456e-42px 42px), x', '1.23456e+42', m[1]);
-    assertEquals('transform:translate3d(1.23456e+42px 0.123456e-42px 42px), y', '0.123456e-42', m[3]);
+    chai.assert.equal(m[1], '1.23456e+42', 'transform:translate3d(1.23456e+42px 0.123456e-42px 42px), x');
+    chai.assert.equal(m[3], '0.123456e-42', 'transform:translate3d(1.23456e+42px 0.123456e-42px 42px), y');
   });
 
   suite('DOM', function() {
     test('addClass', function() {
       var p = document.createElement('p');
       Blockly.utils.dom.addClass(p, 'one');
-      assertEquals('Adding "one"', 'one', p.className);
+      chai.assert.equal(p.className, 'one', 'Adding "one"');
       Blockly.utils.dom.addClass(p, 'one');
-      assertEquals('Adding duplicate "one"', 'one', p.className);
+      chai.assert.equal(p.className, 'one', 'Adding duplicate "one"');
       Blockly.utils.dom.addClass(p, 'two');
-      assertEquals('Adding "two"', 'one two', p.className);
+      chai.assert.equal(p.className, 'one two', 'Adding "two"');
       Blockly.utils.dom.addClass(p, 'two');
-      assertEquals('Adding duplicate "two"', 'one two', p.className);
+      chai.assert.equal(p.className, 'one two', 'Adding duplicate "two"');
       Blockly.utils.dom.addClass(p, 'three');
-      assertEquals('Adding "three"', 'one two three', p.className);
+      chai.assert.equal(p.className, 'one two three', 'Adding "three"');
     });
 
     test('hasClass', function() {
       var p = document.createElement('p');
       p.className = ' one three  two three  ';
-      assertTrue('Has "one"', Blockly.utils.dom.hasClass(p, 'one'));
-      assertTrue('Has "two"', Blockly.utils.dom.hasClass(p, 'two'));
-      assertTrue('Has "three"', Blockly.utils.dom.hasClass(p, 'three'));
-      assertFalse('Has no "four"', Blockly.utils.dom.hasClass(p, 'four'));
-      assertFalse('Has no "t"', Blockly.utils.dom.hasClass(p, 't'));
+      chai.assert.isTrue(Blockly.utils.dom.hasClass(p, 'one'), 'Has "one"');
+      chai.assert.isTrue(Blockly.utils.dom.hasClass(p, 'two'), 'Has "two"');
+      chai.assert.isTrue(Blockly.utils.dom.hasClass(p, 'three'), 'Has "three"');
+      chai.assert.isFalse(Blockly.utils.dom.hasClass(p, 'four'), 'Has no "four"');
+      chai.assert.isFalse(Blockly.utils.dom.hasClass(p, 't'), 'Has no "t"');
     });
 
     test('removeClass', function() {
       var p = document.createElement('p');
       p.className = ' one three  two three  ';
       Blockly.utils.dom.removeClass(p, 'two');
-      assertEquals('Removing "two"', 'one three three', p.className);
+      chai.assert.equal(p.className, 'one three three', 'Removing "two"');
       Blockly.utils.dom.removeClass(p, 'four');
-      assertEquals('Removing "four"', 'one three three', p.className);
+      chai.assert.equal(p.className, 'one three three', 'Removing "four"');
       Blockly.utils.dom.removeClass(p, 'three');
-      assertEquals('Removing "three"', 'one', p.className);
+      chai.assert.equal(p.className, 'one', 'Removing "three"');
       Blockly.utils.dom.removeClass(p, 'ne');
-      assertEquals('Removing "ne"', 'one', p.className);
+      chai.assert.equal(p.className, 'one', 'Removing "ne"');
       Blockly.utils.dom.removeClass(p, 'one');
-      assertEquals('Removing "one"', '', p.className);
+      chai.assert.equal(p.className, '', 'Removing "one"');
       Blockly.utils.dom.removeClass(p, 'zero');
-      assertEquals('Removing "zero"', '', p.className);
+      chai.assert.equal(p.className, '', 'Removing "zero"');
     });
   });
 
   suite('String', function() {
     test('starts with', function() {
-      assertEquals('Does not start with', false, Blockly.utils.string.startsWith('123', '2'));
-      assertEquals('Start with', true, Blockly.utils.string.startsWith('123', '12'));
-      assertEquals('Start with empty string 1', true, Blockly.utils.string.startsWith('123', ''));
-      assertEquals('Start with empty string 2', true, Blockly.utils.string.startsWith('', ''));
+      chai.assert.isFalse(Blockly.utils.string.startsWith('123', '2'), 'Does not start with');
+      chai.assert.isTrue(Blockly.utils.string.startsWith('123', '12'), 'Start with');
+      chai.assert.isTrue(Blockly.utils.string.startsWith('123', ''), 'Start with empty string 1');
+      chai.assert.isTrue(Blockly.utils.string.startsWith('', ''), 'Start with empty string 12');
     });
 
     test('shortest string length', function() {
       var len = Blockly.utils.string.shortestStringLength('one,two,three,four,five'.split(','));
-      assertEquals('Length of "one"', 3, len);
+      chai.assert.equal(len, 3, 'Length of "one"');
       len = Blockly.utils.string.shortestStringLength('one,two,three,four,five,'.split(','));
-      assertEquals('Length of ""', 0, len);
+      chai.assert.equal(len, 0, 'Length of ""');
       len = Blockly.utils.string.shortestStringLength(['Hello World']);
-      assertEquals('List of one', 11, len);
+      chai.assert.equal(len, 11, 'List of one');
       len = Blockly.utils.string.shortestStringLength([]);
-      assertEquals('Empty list', 0, len);
+      chai.assert.equal(len, 0, 'Empty list');
     });
 
     test('comment word prefix', function() {
       var len = Blockly.utils.string.commonWordPrefix('one,two,three,four,five'.split(','));
-      assertEquals('No prefix', 0, len);
+      chai.assert.equal(len, 0, 'No prefix');
       len = Blockly.utils.string.commonWordPrefix('Xone,Xtwo,Xthree,Xfour,Xfive'.split(','));
-      assertEquals('No word prefix', 0, len);
+      chai.assert.equal(len, 0, 'No word prefix');
       len = Blockly.utils.string.commonWordPrefix('abc de,abc de,abc de,abc de'.split(','));
-      assertEquals('Full equality', 6, len);
+      chai.assert.equal(len, 6, 'Full equality');
       len = Blockly.utils.string.commonWordPrefix('abc deX,abc deY'.split(','));
-      assertEquals('One word prefix', 4, len);
+      chai.assert.equal(len, 4, 'One word prefix');
       len = Blockly.utils.string.commonWordPrefix('abc de,abc deY'.split(','));
-      assertEquals('Overflow no', 4, len);
+      chai.assert.equal(len, 4, 'Overflow no');
       len = Blockly.utils.string.commonWordPrefix('abc de,abc de Y'.split(','));
-      assertEquals('Overflow yes', 6, len);
+      chai.assert.equal(len, 6, 'Overflow yes');
       len = Blockly.utils.string.commonWordPrefix(['Hello World']);
-      assertEquals('List of one', 11, len);
+      chai.assert.equal(len, 11, 'List of one');
       len = Blockly.utils.string.commonWordPrefix([]);
-      assertEquals('Empty list', 0, len);
+      chai.assert.equal(len, 0, 'Empty list');
       len = Blockly.utils.string.commonWordPrefix('turn&nbsp;left,turn&nbsp;right'.split(','));
-      assertEquals('No prefix due to &amp;nbsp;', 0, len);
+      chai.assert.equal(len, 0, 'No prefix due to &amp;nbsp;');
       len = Blockly.utils.string.commonWordPrefix('turn\u00A0left,turn\u00A0right'.split(','));
-      assertEquals('No prefix due to \\u00A0', 0, len);
+      chai.assert.equal(len, 0, 'No prefix due to \\u00A0');
     });
 
     test('comment word suffix', function() {
       var len = Blockly.utils.string.commonWordSuffix('one,two,three,four,five'.split(','));
-      assertEquals('No suffix', 0, len);
+      chai.assert.equal(len, 0, 'No suffix');
       len = Blockly.utils.string.commonWordSuffix('oneX,twoX,threeX,fourX,fiveX'.split(','));
-      assertEquals('No word suffix', 0, len);
+      chai.assert.equal(len, 0, 'No word suffix');
       len = Blockly.utils.string.commonWordSuffix('abc de,abc de,abc de,abc de'.split(','));
-      assertEquals('Full equality', 6, len);
+      chai.assert.equal(len, 6, 'Full equality');
       len = Blockly.utils.string.commonWordSuffix('Xabc de,Yabc de'.split(','));
-      assertEquals('One word suffix', 3, len);
+      chai.assert.equal(len, 3, 'One word suffix');
       len = Blockly.utils.string.commonWordSuffix('abc de,Yabc de'.split(','));
-      assertEquals('Overflow no', 3, len);
+      chai.assert.equal(len, 3, 'Overflow no');
       len = Blockly.utils.string.commonWordSuffix('abc de,Y abc de'.split(','));
-      assertEquals('Overflow yes', 6, len);
+      chai.assert.equal(len, 6, 'Overflow yes');
       len = Blockly.utils.string.commonWordSuffix(['Hello World']);
-      assertEquals('List of one', 11, len);
+      chai.assert.equal(len, 11, 'List of one');
       len = Blockly.utils.string.commonWordSuffix([]);
-      assertEquals('Empty list', 0, len);
+      chai.assert.equal(len, 0, 'Empty list');
     });
   });
 
   suite('Math', function() {
     test('toRadians', function() {
       var quarter = Math.PI / 2;
-      assertEquals('-90', -quarter, Blockly.utils.math.toRadians(-90));
-      assertEquals('0', 0, Blockly.utils.math.toRadians(0));
-      assertEquals('90', quarter, Blockly.utils.math.toRadians(90));
-      assertEquals('180', 2 * quarter, Blockly.utils.math.toRadians(180));
-      assertEquals('270', 3 * quarter, Blockly.utils.math.toRadians(270));
-      assertEquals('360', 4 * quarter, Blockly.utils.math.toRadians(360));
-      assertEquals('450', 5 * quarter, Blockly.utils.math.toRadians(360 + 90));
+      chai.assert.equal(Blockly.utils.math.toRadians(-90), -quarter, '-90');
+      chai.assert.equal(Blockly.utils.math.toRadians(0), 0, '0');
+      chai.assert.equal(Blockly.utils.math.toRadians(90), quarter, '90');
+      chai.assert.equal(Blockly.utils.math.toRadians(180), 2 * quarter, '180');
+      chai.assert.equal(Blockly.utils.math.toRadians(270), 3 * quarter, '270');
+      chai.assert.equal(Blockly.utils.math.toRadians(360), 4 * quarter, '360');
+      chai.assert.equal(Blockly.utils.math.toRadians(360 + 90), 5 * quarter, '450');
     });
 
     test('toDegrees', function() {
       var quarter = Math.PI / 2;
-      assertEquals('-90', -90, Blockly.utils.math.toDegrees(-quarter));
-      assertEquals('0', 0, Blockly.utils.math.toDegrees(0));
-      assertEquals('90', 90, Blockly.utils.math.toDegrees(quarter));
-      assertEquals('180', 180, Blockly.utils.math.toDegrees(2 * quarter));
-      assertEquals('270', 270, Blockly.utils.math.toDegrees(3 * quarter));
-      assertEquals('360', 360, Blockly.utils.math.toDegrees(4 * quarter));
-      assertEquals('450', 360 + 90, Blockly.utils.math.toDegrees(5 * quarter));
+      chai.assert.equal(Blockly.utils.math.toDegrees(-quarter), -90, '-90');
+      chai.assert.equal(Blockly.utils.math.toDegrees(0), 0, '0');
+      chai.assert.equal(Blockly.utils.math.toDegrees(quarter), 90, '90');
+      chai.assert.equal(Blockly.utils.math.toDegrees(2 * quarter), 180, '180');
+      chai.assert.equal(Blockly.utils.math.toDegrees(3 * quarter), 270, '270');
+      chai.assert.equal(Blockly.utils.math.toDegrees(4 * quarter), 360, '360');
+      chai.assert.equal(Blockly.utils.math.toDegrees(5 * quarter), 360 + 90, '450');
     });
   });
 });
diff --git a/tests/mocha/variables_test.js b/tests/mocha/variables_test.js
index 7e0efbdb9..01710045a 100644
--- a/tests/mocha/variables_test.js
+++ b/tests/mocha/variables_test.js
@@ -57,18 +57,18 @@ suite('Variables', function() {
       createTestVarBlock(this.workspace, '3');
 
       var result = Blockly.Variables.allUsedVarModels(this.workspace);
-      assertEquals('Expected three variables in the list of used variables',
-          3, result.length);
+      chai.assert.equal(result.length, 3,
+          'Expected three variables in the list of used variables');
     });
 
     test('Some unused', function() {
       createTestVarBlock(this.workspace, '2');
 
       var result = Blockly.Variables.allUsedVarModels(this.workspace);
-      assertEquals('Expected one variable in the list of used variables',
-          1, result.length);
-      assertEquals('Expected variable with ID 2 in the list of used variables',
-          '2', result[0].getId());
+      chai.assert.equal(result.length, 1,
+          'Expected one variable in the list of used variables');
+      chai.assert.equal(result[0].getId(), '2',
+          'Expected variable with ID 2 in the list of used variables');
     });
 
     test('Var used twice', function() {
@@ -78,16 +78,16 @@ suite('Variables', function() {
       var result = Blockly.Variables.allUsedVarModels(this.workspace);
       // Using the same variable multiple times should not change the number of
       // elements in the list.
-      assertEquals('Expected one variable in the list of used variables',
-          1, result.length);
-      assertEquals('Expected variable with ID 2 in the list of used variables',
-          '2', result[0].getId());
+      chai.assert.equal(result.length, 1,
+          'Expected one variable in the list of used variables');
+      chai.assert.equal(result[0].getId(), '2',
+          'Expected variable with ID 2 in the list of used variables');
     });
 
     test('All unused', function() {
       var result = Blockly.Variables.allUsedVarModels(this.workspace);
-      assertEquals('Expected no variables in the list of used variables',
-          0, result.length);
+      chai.assert.equal(result.length, 0,
+          'Expected no variables in the list of used variables');
     });
   });
 
@@ -100,9 +100,9 @@ suite('Variables', function() {
       var result2 = Blockly.Variables.getVariable(this.workspace, 'id2');
       var result3 = Blockly.Variables.getVariable(this.workspace, 'id3');
 
-      assertEquals(var1, result1);
-      assertEquals(var2, result2);
-      assertEquals(var3, result3);
+      chai.assert.equal(var1, result1);
+      chai.assert.equal(var2, result2);
+      chai.assert.equal(var3, result3);
     });
 
     test('By name and type', function() {
@@ -117,9 +117,9 @@ suite('Variables', function() {
           Blockly.Variables.getVariable(this.workspace, null, 'name3', 'type2');
 
       // Searching by name + type is correct.
-      assertEquals(var1, result1);
-      assertEquals(var2, result2);
-      assertEquals(var3, result3);
+      chai.assert.equal(var1, result1);
+      chai.assert.equal(var2, result2);
+      chai.assert.equal(var3, result3);
     });
 
     test('Bad id with name and type fallback', function() {
@@ -134,9 +134,9 @@ suite('Variables', function() {
           Blockly.Variables.getVariable(this.workspace, 'badId', 'name3', 'type2');
 
       // Searching by ID failed, but falling back onto name + type is correct.
-      assertEquals(var1, result1);
-      assertEquals(var2, result2);
-      assertEquals(var3, result3);
+      chai.assert.equal(var1, result1);
+      chai.assert.equal(var2, result2);
+      chai.assert.equal(var3, result3);
     });
   });
 });
diff --git a/tests/mocha/xml_test.js b/tests/mocha/xml_test.js
index bcf826a23..806bab044 100644
--- a/tests/mocha/xml_test.js
+++ b/tests/mocha/xml_test.js
@@ -6,33 +6,26 @@
 
 suite('XML', function() {
   var assertSimpleFieldDom = function(fieldDom, name, text) {
-    assertEquals(text, fieldDom.textContent);
-    assertEquals(name, fieldDom.getAttribute('name'));
+    chai.assert.equal(text, fieldDom.textContent);
+    chai.assert.equal(name, fieldDom.getAttribute('name'));
   };
   var assertNonSerializingFieldDom = function(fieldDom) {
-    assertEquals(undefined, fieldDom.childNodes[0]);
+    chai.assert.isUndefined(fieldDom.childNodes[0]);
   };
   var assertNonVariableField = function(fieldDom, name, text) {
     assertSimpleFieldDom(fieldDom, name, text);
-    assertNull('id', fieldDom.getAttribute('id'));
-    assertNull('variabletype', fieldDom.getAttribute('variabletype'));
+    chai.assert.isNull(fieldDom.getAttribute('id'), 'id');
+    chai.assert.isNull(fieldDom.getAttribute('variabletype'), 'variabletype');
   };
   var assertVariableDomField = function(fieldDom, name, type, id, text) {
     assertSimpleFieldDom(fieldDom, name, text);
-    assertEquals(type, fieldDom.getAttribute('variabletype'));
-    assertEquals(id, fieldDom.getAttribute('id'));
+    chai.assert.equal(fieldDom.getAttribute('variabletype'), type);
+    chai.assert.equal(fieldDom.getAttribute('id'), id);
   };
   var assertVariableDom = function(fieldDom, type, id, text) {
-    assertEquals(type, fieldDom.getAttribute('type'));
-    assertEquals(id, fieldDom.getAttribute('id'));
-    assertEquals(text, fieldDom.textContent);
-  };
-  var assertVariableValues = function(container, name, type, id) {
-    var variable = container.getVariableById(id);
-    assertNotUndefined(variable);
-    assertEquals(name, variable.name);
-    assertEquals(type, variable.type);
-    assertEquals(id, variable.getId());
+    chai.assert.equal(fieldDom.getAttribute('type'), type);
+    chai.assert.equal(fieldDom.getAttribute('id'), id);
+    chai.assert.equal(fieldDom.textContent, text);
   };
   setup(function() {
     Blockly.defineBlocksWithJsonArray([
@@ -84,8 +77,8 @@ suite('XML', function() {
   suite('textToDom', function() {
     test('Basic', function() {
       var dom = Blockly.Xml.textToDom(this.complexXmlText);
-      assertEquals('XML tag', 'xml', dom.nodeName);
-      assertEquals('Block tags', 6, dom.getElementsByTagName('block').length);
+      chai.assert.equal(dom.nodeName, 'xml', 'XML tag');
+      chai.assert.equal(dom.getElementsByTagName('block').length, 6, 'Block tags');
     });
   });
   suite('blockToDom', function() {
@@ -442,11 +435,11 @@ suite('XML', function() {
       this.workspace.createVariable('name1');
       var resultDom =
           Blockly.Xml.variablesToDom(this.workspace.getAllVariables());
-      assertEquals(1, resultDom.children.length);
+      chai.assert.equal(resultDom.children.length, 1);
       var resultVariableDom = resultDom.children[0];
-      assertEquals('name1', resultVariableDom.textContent);
-      assertEquals(null, resultVariableDom.getAttribute('type'));
-      assertEquals('1', resultVariableDom.getAttribute('id'));
+      chai.assert.equal(resultVariableDom.textContent, 'name1');
+      chai.assert.isNull(resultVariableDom.getAttribute('type'));
+      chai.assert.equal(resultVariableDom.getAttribute('id'), '1');
     });
     test('Two Variable one block', function() {
       this.workspace.createVariable('name1', '', 'id1');
@@ -459,7 +452,7 @@ suite('XML', function() {
       Blockly.Events.enable();
 
       var resultDom = Blockly.Xml.variablesToDom(this.workspace.getAllVariables());
-      assertEquals(2, resultDom.children.length);
+      chai.assert.equal(resultDom.children.length, 2);
       assertVariableDom(resultDom.children[0], null, 'id1',
           'name1');
       assertVariableDom(resultDom.children[1], 'type2', 'id2',
@@ -468,23 +461,23 @@ suite('XML', function() {
     test('No variables', function() {
       var resultDom =
           Blockly.Xml.variablesToDom(this.workspace.getAllVariables());
-      assertEquals(0, resultDom.children.length);
+      chai.assert.equal(resultDom.children.length, 0);
     });
   });
   suite('domToText', function() {
     test('Round tripping', function() {
       var dom = Blockly.Xml.textToDom(this.complexXmlText);
       var text = Blockly.Xml.domToText(dom);
-      assertEquals('Round trip', this.complexXmlText.replace(/\s+/g, ''),
-          text.replace(/\s+/g, ''));
+      chai.assert.equal(text.replace(/\s+/g, ''),
+          this.complexXmlText.replace(/\s+/g, ''), 'Round trip');
     });
   });
   suite('domToPrettyText', function() {
     test('Round tripping', function() {
       var dom = Blockly.Xml.textToDom(this.complexXmlText);
       var text = Blockly.Xml.domToPrettyText(dom);
-      assertEquals('Round trip', this.complexXmlText.replace(/\s+/g, ''),
-          text.replace(/\s+/g, ''));
+      chai.assert.equal(text.replace(/\s+/g, ''),
+          this.complexXmlText.replace(/\s+/g, ''), 'Round trip');
     });
   });
   suite('domToBlock', function() {
@@ -722,7 +715,7 @@ suite('XML', function() {
           '  </block>' +
           '</xml>');
       Blockly.Xml.domToWorkspace(dom, this.workspace);
-      assertEquals('Block count', 1, this.workspace.getAllBlocks(false).length);
+      chai.assert.equal(this.workspace.getAllBlocks(false).length, 1, 'Block count');
       assertVariableValues(this.workspace, 'name1', '', '1');
     });
     test('Variables at top', function() {
@@ -738,7 +731,7 @@ suite('XML', function() {
           '  </block>' +
           '</xml>');
       Blockly.Xml.domToWorkspace(dom, this.workspace);
-      assertEquals('Block count', 1, this.workspace.getAllBlocks(false).length);
+      chai.assert.equal(this.workspace.getAllBlocks(false).length, 1, 'Block count');
       assertVariableValues(this.workspace, 'name1', 'type1', 'id1');
       assertVariableValues(this.workspace, 'name2', 'type2', 'id2');
       assertVariableValues(this.workspace, 'name3', '', 'id3');
@@ -806,10 +799,10 @@ suite('XML', function() {
           '  </block>' +
           '</xml>');
       Blockly.Xml.appendDomToWorkspace(dom, this.workspace);
-      assertEquals('Block count', 1, this.workspace.getAllBlocks(false).length);
+      chai.assert.equal(this.workspace.getAllBlocks(false).length, 1, 'Block count');
       var newBlockIds = Blockly.Xml.appendDomToWorkspace(dom, this.workspace);
-      assertEquals('Block count', 2, this.workspace.getAllBlocks(false).length);
-      assertEquals('Number of new block ids', 1, newBlockIds.length);
+      chai.assert.equal(this.workspace.getAllBlocks(false).length, 2, 'Block count');
+      chai.assert.equal(newBlockIds.length, 1, 'Number of new block ids');
     });
   });
   suite('workspaceToDom -> domToWorkspace -> workspaceToDom', function() {
@@ -881,7 +874,7 @@ suite('XML', function() {
           ' id="' + varId + '"' +
           ' variabletype="' + type + '"' +
           '>' + name + '</field>';
-      assertEquals(expectedXml, generatedXml);
+      chai.assert.equal(generatedXml, expectedXml);
     });
   });
 });