Added float tests for evaluateEquals

Author: MitMaro

src/Runtime.js

@@ -7,23 +7,19 @@ const RuntimeError = require('./error/Runtime');
 const Parser = require('./Parser');
 const Lexer = require('./Lexer');
 
-// credit: http://stackoverflow.com/a/3886106/124861
-function isFloat(n) {
-	return Number(n) === n && n % 1 !== 0;
+// credit: http://stackoverflow.com/a/9716515/124861
+function isNumeric(n) {
+	return !isNaN(parseFloat(n)) && isFinite(n);
 }
 
 function floatEqual(a, b, epsilon = Number.EPSILON) {
 	if (a === b) {
 		return true;
 	}
 
-	if (isNaN(a) || isNaN(b) || !isFinite(a) || !isFinite(b)) {
-		return false;
-	}
-
 	const diff = Math.abs(a - b);
 
-	return diff < epsilon ? true : diff <= Math.max(Math.abs(a), Math.abs(b)) * epsilon;
+	return diff <= epsilon || diff <= Math.min(Math.abs(a), Math.abs(b)) * epsilon;
 }
 
 const {
@@ -49,7 +45,8 @@ const {
 } = require('./constants');
 
 class Runner {
-	constructor() {
+	constructor(options = { epsilon: Number.EPSILON }) {
+		this.epsilon = options.epsilon;
 		this.astCache = {};
 		this.result = [];
 	}
@@ -181,8 +178,8 @@ class Runner {
 	}
 
 	evaluateEquals(leftValue, rightValue, strict = false) {
-		if (isFloat(leftValue) && isFloat(rightValue)) {
-			return floatEqual(leftValue, rightValue);
+		if (isNumeric(leftValue) && isNumeric(rightValue)) {
+			return floatEqual(leftValue, rightValue, this.epsilon);
 		}
 		// eslint-disable-next-line eqeqeq
 		return strict ? leftValue === rightValue : leftValue == rightValue;

test/.eslintrc

@@ -3,3 +3,4 @@ extends: mitmaro/mocha
 rules:
     func-names: off
     no-undefined: off
+    max-nested-callbacks: off

test/Runtime/Runtime.evaluateEquals.spec.js

@@ -3,34 +3,113 @@
 const expect = require('chai').expect;
 const Runtime = require('../../src/Runtime');
 
+const runtime = new Runtime();
+
 describe('Runtime.evaluateEquals', function() {
 	it('should compare same loose equals on non-float', function() {
-		const runtime = new Runtime();
-
 		expect(runtime.evaluateEquals(1, true)).to.be.true;
 	});
 
 	it('should compare different loose equals on non-float', function() {
-		const runtime = new Runtime();
-
 		expect(runtime.evaluateEquals(0, true)).to.be.false;
 	});
 
 	it('should compare same strict equals on non-float', function() {
-		const runtime = new Runtime();
-
 		expect(runtime.evaluateEquals('foo', 'foo', true)).to.be.true;
 	});
 
 	it('should compare different types strict equals on non-float', function() {
-		const runtime = new Runtime();
-
 		expect(runtime.evaluateEquals(true, 1, true)).to.be.false;
 	});
 
 	it('should compare different values strict equals on non-float', function() {
-		const runtime = new Runtime();
-
 		expect(runtime.evaluateEquals('foo', 'bar', true)).to.be.false;
 	});
+
+	// cases adapted from: http://floating-point-gui.de/errors/NearlyEqualsTest.java
+	describe('with numeric values', function() {
+		[
+			[1000000, 1000001],
+			[1000001, 1000000],
+			[-1000000, -1000001],
+			[-1000001, -1000000],
+			[1.0000001, 1.0000002],
+			[1.0000002, 1.0000001],
+			[-1.0000001, -1.0000002],
+			[-1.0000002, -1.0000001],
+			[0.000000001000001, 0.000000001000002],
+			[0.000000001000002, 0.000000001000001],
+			[-0.000000001000001, -0.000000001000002],
+			[-0.000000001000002, -0.000000001000001],
+			[0.0, 0.0],
+			[0.0, -0.0],
+			[-0.0, -0.0],
+			[0, Math.pow(10, -40), 0.01],
+			[Math.pow(10, -40), 0, 0.01],
+			[0, -Math.pow(10, -40), 0.01],
+			[-Math.pow(10, -40), 0, 0.01],
+			[Number.MAX_VALUE, Number.MAX_VALUE],
+			[Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY],
+			[Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY],
+			[10 * Number.MIN_VALUE, 10 * -Number.MIN_VALUE],
+			[Number.MIN_VALUE, Number.MIN_VALUE],
+			[Number.MIN_VALUE, -Number.MIN_VALUE],
+			[-Number.MIN_VALUE, Number.MIN_VALUE],
+			[Number.MIN_VALUE, 0],
+			[0, Number.MIN_VALUE],
+			[-Number.MIN_VALUE, 0],
+			[0, -Number.MIN_VALUE]
+		].forEach((c) => {
+			const epsilon = c[2] || 0.00001;
+
+			it(`should compare ${c[0]} to be equal to ${c[1]} with epsilon ${epsilon}`, function() {
+				runtime.epsilon = epsilon;
+				expect(runtime.evaluateEquals(...c)).to.be.true;
+			});
+		});
+		[
+			[10000, 10001],
+			[10001, 10000],
+			[-10000, -10001],
+			[-10001, -10000],
+			[1.0002, 1.0001],
+			[1.0001, 1.0002],
+			[-1.0001, -1.0002],
+			[-1.0002, -1.0001],
+			[Number.MAX_VALUE, -Number.MAX_VALUE],
+			[-Number.MAX_VALUE, Number.MAX_VALUE],
+			[Number.MAX_VALUE, Number.MAX_VALUE / 2],
+			[Number.MAX_VALUE, -Number.MAX_VALUE / 2],
+			[-Number.MAX_VALUE, Number.MAX_VALUE / 2],
+			[Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY],
+			[Number.POSITIVE_INFINITY, Number.MAX_VALUE],
+			[Number.NEGATIVE_INFINITY, -Number.MAX_VALUE],
+			[Number.NaN, Number.NaN],
+			[Number.NaN, 0.0],
+			[-0.0, Number.NaN],
+			[Number.NaN, -0.0],
+			[0.0, Number.NaN],
+			[Number.NaN, Number.POSITIVE_INFINITY],
+			[Number.POSITIVE_INFINITY, Number.NaN],
+			[Number.NaN, Number.NEGATIVE_INFINITY],
+			[Number.NEGATIVE_INFINITY, Number.NaN],
+			[Number.NaN, Number.MAX_VALUE],
+			[Number.MAX_VALUE, Number.NaN],
+			[Number.NaN, -Number.MAX_VALUE],
+			[-Number.MAX_VALUE, Number.NaN],
+			[Number.NaN, Number.MIN_VALUE],
+			[Number.MIN_VALUE, Number.NaN],
+			[Number.NaN, -Number.MIN_VALUE],
+			[-Number.MIN_VALUE, Number.NaN],
+			[1.000000001, -1.0],
+			[-1.0, 1.000000001],
+			[-1.000000001, 1.0],
+			[1.0, -1.000000001]
+		].forEach((c) => {
+			it(`should compare ${c[0]} to be not equal to ${c[1]} with epsilon  0.00001`, function() {
+				runtime.epsilon = 0.00001;
+				expect(runtime.evaluateEquals(...c)).to.be.false;
+			});
+		});
+	});
 });