assert: support inequalities

doc/api/assert.md

@@ -551,6 +551,30 @@ added: v0.5.9
 
 An alias of [`assert.ok()`][].
 
+## `assert.greaterThanOrEqualTo(actual, expected[, message])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `actual` {number}
+* `expected` {number}
+* `message` {string|Error}
+
+Expects the `actual` input to be greater than or equal to the `expected` value.
+
+## `assert.lessThanOrEqualTo(actual, expected[, message])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `actual` {number}
+* `expected` {number}
+* `message` {string|Error}
+
+Expects the `actual` input to be less than or equal to the `expected` value.
+
 ## `assert.deepEqual(actual, expected[, message])`
 
 <!-- YAML
@@ -1311,6 +1335,18 @@ parameter is undefined, a default error message is assigned. If the `message`
 parameter is an instance of an [`Error`][] then it will be thrown instead of the
 `AssertionError`.
 
+## `assert.greaterThan(actual, expected[, message])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `actual` {number}
+* `expected` {number}
+* `message` {string|Error}
+
+Expects the `actual` input to be greater than the `expected` value.
+
 ## `assert.fail([message])`
 
 <!-- YAML
@@ -1450,6 +1486,18 @@ suppressFrame();
 //     ...
 ```
 
+## `assert.lessThan(actual, expected[, message])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `actual` {number}
+* `expected` {number}
+* `message` {string|Error}
+
+Expects the `actual` input to be less than the `expected` value.
+
 ## `assert.ifError(value)`
 
 <!-- YAML

lib/assert.js

@@ -791,6 +791,78 @@ assert.doesNotMatch = function doesNotMatch(string, regexp, message) {
   internalMatch(string, regexp, message, doesNotMatch);
 };
 
+/**
+ * Asserts that the first number is greater than the second number.
+ * @param {number} actual
+ * @param {number} expected
+ * @param {string | Error} [message]
+ */
+assert.greaterThan = function greaterThan(actual, expected, message = `Expected ${actual} to be greater than ${expected}`) {
+  if (actual <= expected) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: '>',
+      stackStartFn: greaterThan,
+    });
+  }
+};
+
+/**
+ * Asserts that the first number is greater than or equal to the second number.
+ * @param {number} actual
+ * @param {number} expected
+ * @param {string | Error} [message]
+ */
+assert.greaterThanOrEqualTo = function greaterThanOrEqualTo(actual, expected, message = `Expected ${actual} to be greater than or equal to ${expected}`) {
+  if (actual < expected) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: '\u2265',
+      stackStartFn: greaterThanOrEqualTo,
+    });
+  }
+};
+
+/**
+ * Asserts that the first number is less than the second number.
+ * @param {number} actual
+ * @param {number} expected
+ * @param {string | Error} [message]
+ */
+assert.lessThan = function lessThan(actual, expected, message = `Expected ${actual} to be less than ${expected}`) {
+  if (actual >= expected) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: '<',
+      stackStartFn: lessThan,
+    });
+  }
+};
+
+/**
+ * Asserts that the first number is less than or equal to the second number.
+ * @param {number} actual
+ * @param {number} expected
+ * @param {string | Error} [message]
+ */
+assert.lessThanOrEqualTo = function lessThanOrEqualTo(actual, expected, message = `Expected ${actual} to be less than or equal to ${expected}`) {
+  if (actual > expected) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: '\u2264',
+      stackStartFn: lessThanOrEqualTo,
+    });
+  }
+};
+
 assert.CallTracker = deprecate(CallTracker, 'assert.CallTracker is deprecated.', 'DEP0173');
 
 /**

lib/internal/test_runner/test.js

@@ -105,14 +105,18 @@ function lazyAssertObject(harness) {
     assertObj = new SafeMap();
     const assert = require('assert');
     const methodsToCopy = [
+      'greaterThanOrEqualTo',
+      'lessThanOrEqualTo',
       'deepEqual',
       'deepStrictEqual',
       'doesNotMatch',
       'doesNotReject',
       'doesNotThrow',
       'equal',
       'fail',
+      'greaterThan',
       'ifError',
+      'lessThan',
       'match',
       'notDeepEqual',
       'notDeepStrictEqual',

test/parallel/test-assert-inequalities.js

@@ -0,0 +1,50 @@
+'use strict';
+
+require('../common');
+const assert = require('node:assert');
+const { describe, it } = require('node:test');
+
+const testCases = {
+  greaterThan: [
+    { actual: 5, expected: 3, shouldPass: true },
+    { actual: 3, expected: 3, shouldPass: false },
+    { actual: 2, expected: 3, shouldPass: false },
+  ],
+  greaterThanOrEqualTo: [
+    { actual: 5, expected: 3, shouldPass: true },
+    { actual: 3, expected: 3, shouldPass: true },
+    { actual: 2, expected: 3, shouldPass: false },
+  ],
+  lessThan: [
+    { actual: 2, expected: 3, shouldPass: true },
+    { actual: 3, expected: 3, shouldPass: false },
+    { actual: 4, expected: 3, shouldPass: false },
+  ],
+  lessThanOrEqualTo: [
+    { actual: 2, expected: 3, shouldPass: true },
+    { actual: 3, expected: 3, shouldPass: true },
+    { actual: 4, expected: 3, shouldPass: false },
+  ]
+};
+
+const comparison = {
+  greaterThan: 'greater than',
+  greaterThanOrEqualTo: 'greater than or equal to',
+  lessThan: 'less than',
+  lessThanOrEqualTo: 'less than or equal to'
+};
+
+const methods = Object.keys(testCases);
+
+for (const method of methods) {
+  describe(`assert.${method}`, () => {
+    for (const { actual, expected, shouldPass } of testCases[method]) {
+      it(`should ${shouldPass ? 'pass' : 'fail'} with (${actual}, ${expected})`, () => {
+        assert[shouldPass ? 'doesNotThrow' : 'throws'](
+          () => assert[method](actual, expected),
+          new RegExp(`Expected ${actual} to be ${comparison[method]} ${expected}`)
+        );
+      });
+    }
+  });
+}