From 5c5ef1b56fc8fda8524135a09948f9bc6df6ece5 Mon Sep 17 00:00:00 2001
From: Alex Miller <amill128@lion.lmu.edu>
Date: Wed, 8 Jul 2026 17:30:30 -0700
Subject: [PATCH] Swapped most of the assert.equals in test.js

Went in and adjusted most of the assert.equals in the test.js file to properly show the expected and actual values in the correct place.
---
 test/test.js | 134 +++++++++++++++++++++++++--------------------------
 1 file changed, 67 insertions(+), 67 deletions(-)

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) => {