diff --git a/test/test.js b/test/test.js
index 6a2b9c6c..10a504be 100644
--- a/test/test.js
+++ b/test/test.js
@@ -39,22 +39,22 @@ var parseNetworkSheet = sheet => {
 var noErrors = function (input) {
     var sheet = xlsx.parse(input);
     var workbook = parseNetworkSheet(sheet);
-    assert.equal(0, workbook.errors.length);
+    assert.equal(workbook.errors.length, 0);
 };
 
 var duplicateGeneError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var workbook = parseNetworkSheet(sheet);
 
-    assert.equal(frequency, workbook.errors.length);
+    assert.equal(workbook.errors.length, frequency);
 
     for (var i = 0; i < frequency; i++) {
-        assert.equal("DUPLICATE_GENE", workbook.errors[i].errorCode);
+        assert.equal(workbook.errors[i].errorCode, "DUPLICATE_GENE");
     }
 
     /* TO DO:
   workbook.errors.forEach(function (error) {
-    assert.equal("DUPLICATE_GENE", error.errorCode);
+    assert.equal(error.errorCode, "DUPLICATE_GENE");
   });
   */
 };
@@ -73,10 +73,10 @@ var invalidGeneLengthError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var workbook = parseNetworkSheet(sheet);
 
-    assert.equal(frequency, workbook.errors.length);
+    assert.equal(workbook.errors.length, frequency);
 
     for (var i = 0; i < frequency; i++) {
-        assert.equal("INVALID_GENE_LENGTH", workbook.errors[i].errorCode);
+        assert.equal(workbook.errors[i].errorCode, "INVALID_GENE_LENGTH");
     }
 };
 
@@ -84,10 +84,10 @@ var corruptGeneError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var workbook = parseNetworkSheet(sheet);
 
-    assert.equal(frequency, workbook.errors.length);
+    assert.equal(workbook.errors.length, frequency);
 
     for (var i = 0; i < frequency; i++) {
-        assert.equal("CORRUPT_GENE", workbook.errors[i].errorCode);
+        assert.equal(workbook.errors[i].errorCode, "CORRUPT_GENE");
     }
 };
 
@@ -95,10 +95,10 @@ var unknownError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var workbook = parseNetworkSheet(sheet);
 
-    assert.equal(frequency, workbook.errors.length);
+    assert.equal(workbook.errors.length, frequency);
 
     for (var i = 0; i < frequency; i++) {
-        assert.equal("UNKNOWN_ERROR", workbook.errors[i].errorCode);
+        assert.equal(workbook.errors[i].errorCode, "UNKNOWN_ERROR");
     }
 };
 
@@ -106,10 +106,10 @@ var missingValueError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var workbook = parseNetworkSheet(sheet);
 
-    assert.equal(frequency, workbook.errors.length);
+    assert.equal(workbook.errors.length, frequency);
 
     for (var i = 0; i < frequency; i++) {
-        assert.equal("MISSING_VALUE", workbook.errors[i].errorCode);
+        assert.equal(workbook.errors[i].errorCode, "MISSING_VALUE");
     }
 };
 
@@ -117,10 +117,10 @@ var missingNetworkError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var workbook = parseNetworkSheet(sheet);
 
-    assert.equal(frequency, workbook.errors.length);
+    assert.equal(workbook.errors.length, frequency);
 
     for (var i = 0; i < frequency; i++) {
-        assert.equal("MISSING_NETWORK", workbook.errors[i].errorCode);
+        assert.equal(workbook.errors[i].errorCode, "MISSING_NETWORK");
     }
 };
 
@@ -128,10 +128,10 @@ var specialCharacterError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var workbook = parseNetworkSheet(sheet);
 
-    assert.equal(frequency, workbook.errors.length);
+    assert.equal(workbook.errors.length, frequency);
 
     for (var i = 0; i < frequency; i++) {
-        assert.equal("INVALID_CHARACTER", workbook.errors[i].errorCode);
+        assert.equal(workbook.errors[i].errorCode, "INVALID_CHARACTER");
     }
 };
 
@@ -139,10 +139,10 @@ var invalidDataTypeError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var workbook = parseNetworkSheet(sheet);
 
-    assert.equal(frequency, workbook.errors.length);
+    assert.equal(workbook.errors.length, frequency);
 
     for (var i = 0; i < frequency; i++) {
-        assert.equal("INVALID_CELL_DATA_TYPE", workbook.errors[i].errorCode);
+        assert.equal(workbook.errors[i].errorCode, "INVALID_CELL_DATA_TYPE");
     }
 };
 
@@ -150,10 +150,10 @@ var workbookSizeError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var workbook = parseNetworkSheet(sheet);
 
-    assert.equal(frequency, workbook.errors.length);
+    assert.equal(workbook.errors.length, frequency);
 
     for (var i = 0; i < frequency; i++) {
-        assert.equal("INVALID_NETWORK_SIZE", workbook.errors[i].errorCode);
+        assert.equal(workbook.errors[i].errorCode, "INVALID_NETWORK_SIZE");
     }
 };
 
@@ -162,10 +162,10 @@ var checkForGene = function (test, frequency, input) {
     var workbook = parseNetworkSheet(sheet);
 
     assert.equal(
-        frequency,
         workbook.genes.filter(function (gene) {
             return gene.name === test;
-        }).length
+        }).length,
+        frequency
     );
 };
 
@@ -176,7 +176,7 @@ var warningsCountError = function (input, frequency) {
         return x.errorCode === "WARNINGS_OVERLOAD";
     });
 
-    assert.equal(frequency, warningsCountErrorArray.length);
+    assert.equal(warningsCountErrorArray.length, frequency);
 };
 
 var errorsCountError = function (input, frequency) {
@@ -186,17 +186,17 @@ var errorsCountError = function (input, frequency) {
         return x.errorCode === "ERRORS_OVERLOAD";
     });
 
-    assert.equal(frequency, errorsCountErrorArray.length);
+    assert.equal(errorsCountErrorArray.length, frequency);
 };
 
 var emptyRowError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var workbook = parseNetworkSheet(sheet);
 
-    assert.equal(frequency, workbook.errors.length);
+    assert.equal(workbook.errors.length, frequency);
 
     for (var i = 0; i < frequency; i++) {
-        assert.equal("EMPTY_ROW", workbook.errors[i].errorCode);
+        assert.equal(workbook.errors[i].errorCode, "EMPTY_ROW");
     }
 };
 
@@ -207,18 +207,18 @@ var geneMismatchError = function (input, frequency) {
         return x.errorCode === "GENE_MISMATCH";
     });
 
-    assert.equal(frequency, geneMismatchCount.length);
+    assert.equal(geneMismatchCount.length, frequency);
 };
 
 var idLabelError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var workbook = parseExpressionSheet(sheet);
-    assert.equal(frequency, workbook.expression.wt_log2_expression.errors.length);
+    assert.equal(workbook.expression.wt_log2_expression.errors.length, frequency);
 
     for (var i = 0; i < frequency; i++) {
         assert.equal(
-            "MISLABELED_ID_CELL",
-            workbook.expression.wt_log2_expression.errors[i].errorCode
+            workbook.expression.wt_log2_expression.errors[i].errorCode,
+            "MISLABELED_ID_CELL"
         );
     }
 };
@@ -226,11 +226,11 @@ var idLabelError = function (input, frequency) {
 var missingColumnHeaderError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var exp = parseExpressionSheet(sheet);
-    assert.equal(frequency, exp["expression"]["wt_log2_expression"]["errors"].length);
+    assert.equal(exp["expression"]["wt_log2_expression"]["errors"].length, frequency);
     for (var i = 0; i < frequency; i++) {
         assert.equal(
-            "MISSING_COLUMN_HEADER",
-            exp["expression"]["wt_log2_expression"]["errors"][i].errorCode
+            exp["expression"]["wt_log2_expression"]["errors"][i].errorCode,
+            "MISSING_COLUMN_HEADER"
         );
     }
 };
@@ -238,11 +238,11 @@ var missingColumnHeaderError = function (input, frequency) {
 var emptyExpressionColumnError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var exp = parseExpressionSheet(sheet);
-    assert.equal(frequency, exp["expression"]["wt_log2_expression"]["errors"].length);
+    assert.equal(exp["expression"]["wt_log2_expression"]["errors"].length, frequency);
     for (var i = 0; i < frequency; i++) {
         assert.equal(
-            "EMPTY_COLUMN",
-            exp["expression"]["wt_log2_expression"]["errors"][i].errorCode
+            exp["expression"]["wt_log2_expression"]["errors"][i].errorCode,
+            "EMPTY_COLUMN"
         );
     }
 };
@@ -250,10 +250,10 @@ var emptyExpressionColumnError = function (input, frequency) {
 var emptyExpressionRowError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var exp = parseExpressionSheet(sheet);
-    assert.equal(frequency, exp["expression"]["wt_log2_expression"]["errors"].length);
+    assert.equal(exp["expression"]["wt_log2_expression"]["errors"].length, frequency);
 
     for (var i = 0; i < frequency; i++) {
-        assert.equal("EMPTY_ROW", exp["expression"]["wt_log2_expression"]["errors"][i].errorCode);
+        assert.equal(exp["expression"]["wt_log2_expression"]["errors"][i].errorCode, "EMPTY_ROW");
     }
 };
 
@@ -261,11 +261,11 @@ var emptyExpressionRowError = function (input, frequency) {
 var labelError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var exp = parseExpressionSheet(sheet);
-    assert.equal(frequency, exp["expression"]["wt_log2_expression"]["errors"].length);
+    assert.equal(exp["expression"]["wt_log2_expression"]["errors"].length, frequency);
     for (var i = 0; i < frequency; i++) {
         assert.equal(
-            "extra_gene_name" || "missing_a_gene_name",
-            exp["expression"]["wt_log2_expression"]["errors"][i].errorCode
+            exp["expression"]["wt_log2_expression"]["errors"][i].errorCode,
+            "extra_gene_name" || "missing_a_gene_name"
         );
     }
 };
@@ -277,7 +277,7 @@ var missingGeneNameError = function (input, frequency) {
         return x.errorCode === "MISSING_GENE_NAME";
     });
 
-    assert.equal(frequency, missingGeneCount.length);
+    assert.equal(missingGeneCount.length, frequency);
 };
 
 var extraGeneNameError = function (input, frequency) {
@@ -287,17 +287,17 @@ var extraGeneNameError = function (input, frequency) {
         return x.errorCode === "EXTRA_GENE_NAME";
     });
 
-    assert.equal(frequency, extraGeneCount.length);
+    assert.equal(extraGeneCount.length, frequency);
 };
 
 var negativeTimePointError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var exp = parseExpressionSheet(sheet);
-    assert.equal(frequency, exp["expression"]["wt_log2_expression"]["errors"].length);
+    assert.equal(exp["expression"]["wt_log2_expression"]["errors"].length, frequency);
     for (var i = 0; i < frequency; i++) {
         assert.equal(
-            "NEGATIVE_TIME_POINT",
-            exp["expression"]["wt_log2_expression"]["errors"][i].errorCode
+            exp["expression"]["wt_log2_expression"]["errors"][i].errorCode,
+            "NEGATIVE_TIME_POINT"
         );
     }
 };
@@ -305,11 +305,11 @@ var negativeTimePointError = function (input, frequency) {
 var nonMonotonicTimePointsError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var exp = parseExpressionSheet(sheet);
-    assert.equal(frequency, exp["expression"]["wt_log2_expression"]["errors"].length);
+    assert.equal(exp["expression"]["wt_log2_expression"]["errors"].length, frequency);
     for (var i = 0; i < frequency; i++) {
         assert.equal(
-            "NON_MONOTONIC_TIME_POINTS",
-            exp["expression"]["wt_log2_expression"]["errors"][i].errorCode
+            exp["expression"]["wt_log2_expression"]["errors"][i].errorCode,
+            "NON_MONOTONIC_TIME_POINTS"
         );
     }
 };
@@ -317,11 +317,11 @@ var nonMonotonicTimePointsError = function (input, frequency) {
 var nonNumericalTimePointError = function (input, frequency) {
     var sheet = xlsx.parse(input);
     var exp = parseExpressionSheet(sheet);
-    assert.equal(frequency, exp["expression"]["wt_log2_expression"]["errors"].length);
+    assert.equal(exp["expression"]["wt_log2_expression"]["errors"].length, frequency);
     for (var i = 0; i < frequency; i++) {
         assert.equal(
-            "NON_NUMERICAL_TIME_POINT",
-            exp["expression"]["wt_log2_expression"]["errors"][i].errorCode
+            exp["expression"]["wt_log2_expression"]["errors"][i].errorCode,
+            "NON_NUMERICAL_TIME_POINT"
         );
     }
 };
@@ -333,7 +333,7 @@ var emptyRowDataError = function (input, frequency) {
         return x.errorCode === "EMPTY_ROW_DATA";
     });
 
-    assert.equal(frequency, emptyRowDataCount.length);
+    assert.equal(emptyRowDataCount.length, frequency);
 };
 
 var emptyMatrixDataError = function (input, frequency) {
@@ -343,7 +343,7 @@ var emptyMatrixDataError = function (input, frequency) {
         return x.errorCode === "EMPTY_MATRIX_DATA";
     });
 
-    assert.equal(frequency, emptyMatrixDataCount.length);
+    assert.equal(emptyMatrixDataCount.length, frequency);
 };
 
 var emptyColumnDataError = function (input, frequency) {
@@ -353,7 +353,7 @@ var emptyColumnDataError = function (input, frequency) {
         return x.errorCode === "EMPTY_COLUMN_DATA";
     });
 
-    assert.equal(frequency, emptyRowDataCount.length);
+    assert.equal(emptyRowDataCount.length, frequency);
 };
 
 var emptyColumnError = function (input, frequency) {
@@ -363,7 +363,7 @@ var emptyColumnError = function (input, frequency) {
         return x.errorCode === "EMPTY_COLUMN";
     });
 
-    assert.equal(frequency, emptyRowDataCount.length);
+    assert.equal(emptyRowDataCount.length, frequency);
 };
 
 // WARNING TEST FUNCTIONS:
@@ -372,7 +372,7 @@ var noWarnings = function (input) {
     var sheet = xlsx.parse(input);
     var workbook = parseNetworkSheet(sheet);
 
-    assert.equal(0, workbook.warnings.length);
+    assert.equal(workbook.warnings.length, 0);
 };
 
 const noWarningsForAdditionalSheet = function (input, sheetName) {
@@ -392,7 +392,7 @@ var missingSourceWarning = function (input, frequency) {
         return x.warningCode === "MISSING_SOURCE";
     });
 
-    assert.equal(frequency, missingSourceCount.length);
+    assert.equal(missingSourceCount.length, frequency);
 };
 
 var invalidMatrixDataWarning = function (input, frequency) {
@@ -402,7 +402,7 @@ var invalidMatrixDataWarning = function (input, frequency) {
         return x.warningCode === "INVALID_DATA";
     });
 
-    assert.equal(frequency, invalidDataCount.length);
+    assert.equal(invalidDataCount.length, frequency);
 };
 
 var missingTargetWarning = function (input, frequency) {
@@ -412,7 +412,7 @@ var missingTargetWarning = function (input, frequency) {
         return x.warningCode === "MISSING_TARGET";
     });
 
-    assert.equal(frequency, missingTargetCount.length);
+    assert.equal(missingTargetCount.length, frequency);
 };
 
 var randomDataWarning = function (input, frequency) {
@@ -422,7 +422,7 @@ var randomDataWarning = function (input, frequency) {
         return x.warningCode === "RANDOM_DATA";
     });
 
-    assert.equal(frequency, randomDataCount.length);
+    assert.equal(randomDataCount.length, frequency);
 };
 
 var emptyRowWarning = function (input, frequency) {
@@ -432,7 +432,7 @@ var emptyRowWarning = function (input, frequency) {
         return x.warningCode === "EMPTY_ROW";
     });
 
-    assert.equal(frequency, emptyRowCount.length);
+    assert.equal(emptyRowCount.length, frequency);
 };
 
 var invalidNetworkSizeWarning = function (input, frequency) {
@@ -442,7 +442,7 @@ var invalidNetworkSizeWarning = function (input, frequency) {
         return x.warningCode === "INVALID_NETWORK_SIZE";
     });
 
-    assert.equal(frequency, invalidworkbookSizeCount.length);
+    assert.equal(invalidworkbookSizeCount.length, frequency);
 };
 
 var extraneousDataWarning = function (input, frequency) {
@@ -454,7 +454,7 @@ var extraneousDataWarning = function (input, frequency) {
         }
     );
 
-    assert.equal(frequency, extraneousDataCount.length);
+    assert.equal(extraneousDataCount.length, frequency);
 };
 
 var missingExpressionWarning = function (input, frequency) {
@@ -464,7 +464,7 @@ var missingExpressionWarning = function (input, frequency) {
         return x.warningCode === "MISSING_EXPRESSION_SHEET";
     });
 
-    assert.equal(frequency, missingExpressionCount.length);
+    assert.equal(missingExpressionCount.length, frequency);
 };
 
 var incorrectlyNamedExpressionSheetWarning = function (input, frequency) {
@@ -474,7 +474,7 @@ var incorrectlyNamedExpressionSheetWarning = function (input, frequency) {
         return x.warningCode === "INCORRECTLY_NAMED_EXPRESSION_SHEET";
     });
 
-    assert.equal(frequency, incorrectlyNamedSheetCount.length);
+    assert.equal(incorrectlyNamedSheetCount.length, frequency);
 };
 
 var incorrectlyNamedSheetWarning = function (input, frequency) {
@@ -484,7 +484,7 @@ var incorrectlyNamedSheetWarning = function (input, frequency) {
         return x.warningCode === "INCORRECTLY_NAMED_SHEET";
     });
 
-    assert.equal(frequency, incorrectlyNamedSheetCount.length);
+    assert.equal(incorrectlyNamedSheetCount.length, frequency);
 };
 
 const unrecognizedSheetWarning = (input, frequency) => {