diff --git a/tests/mocha/event_test.js b/tests/mocha/event_test.js
index ef04f3e67..6cf675875 100644
--- a/tests/mocha/event_test.js
+++ b/tests/mocha/event_test.js
@@ -46,7 +46,7 @@ suite('Events', function() {
     var expected_xml = Blockly.Xml.domToText(Blockly.Xml.blockToDom(block));
     var result_xml = Blockly.Xml.domToText(event.xml);
     chai.assert.equal(expected_xml, result_xml);
-    assertArrayEquals(ids, event.ids);
+    chai.assert.deepEqual(ids, event.ids);
     chai.assert.equal(type, event.type);
   }
 
@@ -54,7 +54,7 @@ suite('Events', function() {
     var expected_xml = Blockly.Xml.domToText(Blockly.Xml.blockToDom(block));
     var result_xml = Blockly.Xml.domToText(event.oldXml);
     chai.assert.equal(expected_xml, result_xml);
-    assertArrayEquals(ids, event.ids);
+    chai.assert.deepEqual(ids, event.ids);
     chai.assert.equal(type, event.type);
   }
 
diff --git a/tests/mocha/field_variable_test.js b/tests/mocha/field_variable_test.js
index 1d24ad3f7..c1d3207a8 100644
--- a/tests/mocha/field_variable_test.js
+++ b/tests/mocha/field_variable_test.js
@@ -70,9 +70,9 @@ suite('Variable Fields', function() {
 
     // Expect three variable options, a rename option, and a delete option.
     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']);
+    chai.assert.deepEqual(result_options[0], ['name1', 'id1']);
+    chai.assert.deepEqual(result_options[1], ['name2', 'id2']);
+    chai.assert.deepEqual(result_options[2], ['name3', 'id3']);
   });
   suite('Constructor', function() {
     test('Null', 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_();
-      assertArrayEquals(resultTypes, ['']);
+      chai.assert.deepEqual(resultTypes, ['']);
     });
     test('variableTypes is explicit', function() {
       // Expect that since variableTypes is defined, it will be the return
@@ -252,7 +252,7 @@ suite('Variable Fields', function() {
       var fieldVariable = new Blockly.FieldVariable(
           'name1', null, ['type1', 'type2'], 'type1');
       var resultTypes = fieldVariable.getVariableTypes_();
-      assertArrayEquals(resultTypes, ['type1', 'type2']);
+      chai.assert.deepEqual(resultTypes, ['type1', 'type2']);
       chai.assert.equal(fieldVariable.defaultType_, 'type1',
           'Default type was wrong');
     });
@@ -267,7 +267,7 @@ suite('Variable Fields', function() {
 
       var resultTypes = fieldVariable.getVariableTypes_();
       // The empty string is always one of the options.
-      assertArrayEquals(resultTypes, ['type1', 'type2', '']);
+      chai.assert.deepEqual(resultTypes, ['type1', 'type2', '']);
     });
     test('variableTypes is the empty list', function() {
       var fieldVariable = new Blockly.FieldVariable('name1');
diff --git a/tests/mocha/test_helpers.js b/tests/mocha/test_helpers.js
index b18ab7fee..5168f2dc4 100644
--- a/tests/mocha/test_helpers.js
+++ b/tests/mocha/test_helpers.js
@@ -4,26 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-/* exported assertArrayEquals, assertVariableValues, captureWarnings
-   defineRowBlock, defineStackBlock, defineStatementBlock, createTestBlock,
-   createEventsFireStub */
-
-/**
- * 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, opt_message) {
-  chai.assert.equal(array1.length, array2.length, opt_message);
-  for (var i = 0; i < array1.length; i++) {
-    chai.assert.equal(array1[i], array2[i], opt_message);
-  }
-}
-
-function assertArrayEquals(actualArray, expectedArray, opt_message) {
-  isEqualArrays(actualArray, expectedArray, opt_message);
-}
+/* exported assertVariableValues, captureWarnings, defineRowBlock,
+   defineStackBlock, defineStatementBlock, createTestBlock, createEventsFireStub */
 
 /**
  * Check if a variable with the given values exists.
diff --git a/tests/mocha/utils_test.js b/tests/mocha/utils_test.js
index 9786158c9..5dfe92af4 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(tokens, [], 'Null interpolation');
+      chai.assert.deepEqual(tokens, [], 'Null interpolation');
 
       tokens = Blockly.utils.tokenizeInterpolation('Hello');
-      assertArrayEquals(tokens, ['Hello'], 'No interpolation');
+      chai.assert.deepEqual(tokens, ['Hello'], 'No interpolation');
 
       tokens = Blockly.utils.tokenizeInterpolation('Hello%World');
-      assertArrayEquals(tokens, ['Hello%World'], 'Unescaped %.');
+      chai.assert.deepEqual(tokens, ['Hello%World'], 'Unescaped %.');
 
       tokens = Blockly.utils.tokenizeInterpolation('Hello%%World');
-      assertArrayEquals(tokens, ['Hello%World'], 'Escaped %.');
+      chai.assert.deepEqual(tokens, ['Hello%World'], 'Escaped %.');
 
       tokens = Blockly.utils.tokenizeInterpolation('Hello %1 World');
-      assertArrayEquals(tokens, ['Hello ', 1, ' World'], 'Interpolation.');
+      chai.assert.deepEqual(tokens, ['Hello ', 1, ' World'], 'Interpolation.');
 
       tokens = Blockly.utils.tokenizeInterpolation('%123Hello%456World%789');
-      assertArrayEquals(tokens, [123, 'Hello', 456, 'World', 789], 'Interpolations.');
+      chai.assert.deepEqual(tokens, [123, 'Hello', 456, 'World', 789], 'Interpolations.');
 
       tokens = Blockly.utils.tokenizeInterpolation('%%%x%%0%00%01%');
-      assertArrayEquals(tokens, ['%%x%0', 0, 1, '%'], 'Torture interpolations.');
+      chai.assert.deepEqual(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(tokens, ['test string'], 'String table reference, lowercase');
+      chai.assert.deepEqual(tokens, ['test string'], 'String table reference, lowercase');
       tokens = Blockly.utils.tokenizeInterpolation('%{BKY_STRING_REF}');
-      assertArrayEquals(tokens, ['test string'], 'String table reference, uppercase');
+      chai.assert.deepEqual(tokens, ['test string'], 'String table reference, uppercase');
 
       Blockly.Msg.WITH_PARAM = 'before %1 after';
       tokens = Blockly.utils.tokenizeInterpolation('%{bky_with_param}');
-      assertArrayEquals(tokens, ['before ', 1, ' after'], 'String table reference, with parameter');
+      chai.assert.deepEqual(tokens, ['before ', 1, ' after'], 'String table reference, with parameter');
 
       Blockly.Msg.RECURSE = 'before %{bky_string_ref} after';
       tokens = Blockly.utils.tokenizeInterpolation('%{bky_recurse}');
-      assertArrayEquals(tokens, ['before test string after'], 'String table reference, with subreference');
+      chai.assert.deepEqual(tokens, ['before test string after'], 'String table reference, with subreference');
     });
 
     test('Error cases', function() {
       var tokens = Blockly.utils.tokenizeInterpolation('%{bky_undefined}');
-      assertArrayEquals(tokens, ['%{bky_undefined}'], 'Undefined string table reference');
+      chai.assert.deepEqual(tokens, ['%{bky_undefined}'], 'Undefined string table reference');
 
       Blockly.Msg['1'] = 'Will not match';
       tokens = Blockly.utils.tokenizeInterpolation('before %{1} after');
-      assertArrayEquals(tokens, ['before %{1} after'], 'Invalid initial digit in string table reference');
+      chai.assert.deepEqual(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(tokens, ['before %{two words} after'], 'Invalid character in string table reference: space');
+      chai.assert.deepEqual(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(tokens, ['before %{two-words} after'], 'Invalid character in string table reference: dash');
+      chai.assert.deepEqual(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(tokens, ['before %{two.words} after'], 'Invalid character in string table reference: period');
+      chai.assert.deepEqual(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(tokens, ['before %{ab&c} after'], 'Invalid character in string table reference: &');
+      chai.assert.deepEqual(tokens, ['before %{ab&c} after'], 'Invalid character in string table reference: &');
 
       Blockly.Msg['UNCLOSED'] = 'Will not match';
       tokens = Blockly.utils.tokenizeInterpolation('before %{unclosed');
-      assertArrayEquals(tokens, ['before %{unclosed'], 'String table reference, with parameter');
+      chai.assert.deepEqual(tokens, ['before %{unclosed'], 'String table reference, with parameter');
     });
   });
 
diff --git a/tests/mocha/variable_map_test.js b/tests/mocha/variable_map_test.js
index 91101f79a..c68c96984 100644
--- a/tests/mocha/variable_map_test.js
+++ b/tests/mocha/variable_map_test.js
@@ -182,13 +182,13 @@ suite('Variable Map', function() {
       this.variableMap.createVariable('name4', 'type3', 'id4');
       var resultArray = this.variableMap.getVariableTypes();
       // The empty string is always an option.
-      assertArrayEquals(resultArray, ['type1', 'type2', 'type3', '']);
+      chai.assert.deepEqual(resultArray, ['type1', 'type2', 'type3', '']);
     });
 
     test('None', function() {
       // The empty string is always an option.
       var resultArray = this.variableMap.getVariableTypes();
-      assertArrayEquals(resultArray, ['']);
+      chai.assert.deepEqual(resultArray, ['']);
     });
   });
 
@@ -200,8 +200,8 @@ suite('Variable Map', function() {
       this.variableMap.createVariable('name4', 'type3', 'id4');
       var resultArray1 = this.variableMap.getVariablesOfType('type1');
       var resultArray2 = this.variableMap.getVariablesOfType('type5');
-      assertArrayEquals(resultArray1, [var1, var2]);
-      assertArrayEquals(resultArray2, []);
+      chai.assert.deepEqual(resultArray1, [var1, var2]);
+      chai.assert.deepEqual(resultArray2, []);
     });
 
     test('Null', function() {
@@ -210,26 +210,26 @@ suite('Variable Map', function() {
       var var3 = this.variableMap.createVariable('name3', '', 'id3');
       this.variableMap.createVariable('name4', 'type1', 'id4');
       var resultArray = this.variableMap.getVariablesOfType(null);
-      assertArrayEquals(resultArray, [var1, var2, var3]);
+      chai.assert.deepEqual(resultArray, [var1, var2, var3]);
     });
 
     test('Empty string', function() {
       var var1 = this.variableMap.createVariable('name1', null, 'id1');
       var var2 = this.variableMap.createVariable('name2', null, 'id2');
       var resultArray = this.variableMap.getVariablesOfType('');
-      assertArrayEquals(resultArray, [var1, var2]);
+      chai.assert.deepEqual(resultArray, [var1, var2]);
     });
 
     test('Deleted', function() {
       var variable = this.variableMap.createVariable('name1', null, 'id1');
       this.variableMap.deleteVariable(variable);
       var resultArray = this.variableMap.getVariablesOfType('');
-      assertArrayEquals(resultArray, []);
+      chai.assert.deepEqual(resultArray, []);
     });
 
     test('Does not exist', function() {
       var resultArray = this.variableMap.getVariablesOfType('type1');
-      assertArrayEquals(resultArray, []);
+      chai.assert.deepEqual(resultArray, []);
     });
   });
 
@@ -239,12 +239,12 @@ suite('Variable Map', function() {
       var var2 = this.variableMap.createVariable('name2', 'type1', 'id2');
       var var3 = this.variableMap.createVariable('name3', 'type2', 'id3');
       var resultArray = this.variableMap.getAllVariables();
-      assertArrayEquals(resultArray, [var1, var2, var3]);
+      chai.assert.deepEqual(resultArray, [var1, var2, var3]);
     });
 
     test('None', function() {
       var resultArray = this.variableMap.getAllVariables();
-      assertArrayEquals(resultArray, []);
+      chai.assert.deepEqual(resultArray, []);
     });
   });
 });