es6-fuzz 4.0.1 → 5.0.0

package/test/edge-cases.js

@@ -0,0 +1,244 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Triangle = require('../lib/curve/triangle');
+const Trapezoid = require('../lib/curve/trapezoid');
+const Grade = require('../lib/curve/grade');
+const ReverseGrade = require('../lib/curve/reverse-grade');
+const Sigmoid = require('../lib/curve/sigmoid');
+const Constant = require('../lib/curve/constant');
+const FuzzyFunction = require('../lib/curve/fuzzy-function');
+
+describe('Edge Cases', function() {
+  describe('Triangle degenerate cases', function() {
+    it('should handle triangle with all points equal (x0=x1=x2)', function() {
+      const triangle = new Triangle(5, 5, 5);
+      assert.equal(triangle.fuzzify(4.9), 0);
+      assert.equal(triangle.fuzzify(5), 1);
+      assert.equal(triangle.fuzzify(5.1), 0);
+    });
+
+    it('should handle triangle with x0=x1 (right angle left)', function() {
+      const triangle = new Triangle(5, 5, 10);
+      assert.equal(triangle.fuzzify(4.9), 0);
+      assert.equal(triangle.fuzzify(5), 1);
+      assert.equal(triangle.fuzzify(7.5), 0.5);
+      assert.equal(triangle.fuzzify(10), 0);
+    });
+
+    it('should handle triangle with x1=x2 (right angle right)', function() {
+      const triangle = new Triangle(0, 5, 5);
+      assert.equal(triangle.fuzzify(0), 0);
+      assert.equal(triangle.fuzzify(2.5), 0.5);
+      assert.equal(triangle.fuzzify(5), 1);
+      assert.equal(triangle.fuzzify(5.1), 0);
+    });
+  });
+
+  describe('Trapezoid special cases', function() {
+    it('should handle square trapezoid (x1=x2)', function() {
+      const trapezoid = new Trapezoid(0, 5, 5, 10);
+      assert.equal(trapezoid.fuzzify(-1), 0);
+      assert.equal(trapezoid.fuzzify(0), 0);
+      assert.equal(trapezoid.fuzzify(2.5), 0.5);
+      assert.equal(trapezoid.fuzzify(5), 1);
+      assert.equal(trapezoid.fuzzify(7.5), 0.5);
+      assert.equal(trapezoid.fuzzify(10), 0);
+      assert.equal(trapezoid.fuzzify(11), 0);
+    });
+
+    it('should handle degenerate trapezoid (x0=x1 and x2=x3)', function() {
+      const trapezoid = new Trapezoid(5, 5, 10, 10);
+      assert.equal(trapezoid.fuzzify(4.9), 0);
+      assert.equal(trapezoid.fuzzify(5), 1);
+      assert.equal(trapezoid.fuzzify(7.5), 1);
+      assert.equal(trapezoid.fuzzify(10), 1);
+      assert.equal(trapezoid.fuzzify(10.1), 0);
+    });
+
+    it('should handle very narrow trapezoid (x1 and x2 very close)', function() {
+      const trapezoid = new Trapezoid(0, 4.999, 5.001, 10);
+      assert.equal(trapezoid.fuzzify(5), 1);
+      assert(Math.abs(trapezoid.fuzzify(4.999) - 1) < 0.01);
+      assert(Math.abs(trapezoid.fuzzify(5.001) - 1) < 0.01);
+    });
+
+    it('should handle all points equal (degenerate to point)', function() {
+      const trapezoid = new Trapezoid(5, 5, 5, 5);
+      assert.equal(trapezoid.fuzzify(4.9), 0);
+      assert.equal(trapezoid.fuzzify(5), 1);
+      assert.equal(trapezoid.fuzzify(5.1), 0);
+    });
+  });
+
+  describe('Grade edge cases', function() {
+    it('should handle vertical grade (x0=x1)', function() {
+      const grade = new Grade(5, 5);
+      assert.equal(grade.fuzzify(4.9), 0);
+      assert.equal(grade.fuzzify(5), 1);
+      assert.equal(grade.fuzzify(5.1), 1);
+      assert.equal(grade.fuzzify(100), 1);
+    });
+
+    it('should handle very steep grade', function() {
+      const grade = new Grade(5, 5.0001);
+      assert.equal(grade.fuzzify(4.9), 0);
+      assert(grade.fuzzify(5.00005) > 0.4);
+      assert.equal(grade.fuzzify(5.1), 1);
+    });
+  });
+
+  describe('ReverseGrade edge cases', function() {
+    it('should handle vertical reverse grade (x0=x1)', function() {
+      const reverseGrade = new ReverseGrade(5, 5);
+      assert.equal(reverseGrade.fuzzify(4.9), 1);
+      assert.equal(reverseGrade.fuzzify(5), 1);
+      assert.equal(reverseGrade.fuzzify(5.1), 0);
+      assert.equal(reverseGrade.fuzzify(100), 0);
+    });
+
+    it('should handle very steep reverse grade', function() {
+      const reverseGrade = new ReverseGrade(5, 5.0001);
+      assert.equal(reverseGrade.fuzzify(4.9), 1);
+      assert(reverseGrade.fuzzify(5.00005) < 0.6);
+      assert.equal(reverseGrade.fuzzify(5.1), 0);
+    });
+  });
+
+  describe('Sigmoid edge cases', function() {
+    it('should handle zero slope (becomes step function)', function() {
+      const sigmoid = new Sigmoid(5, 0);
+      // With zero slope, sigmoid becomes a step function
+      assert.equal(sigmoid.fuzzify(4.9), 0);
+      assert.equal(sigmoid.fuzzify(5), 0.5);
+      assert.equal(sigmoid.fuzzify(5.1), 1);
+    });
+
+    it('should handle very small slope (near step function)', function() {
+      const sigmoid = new Sigmoid(5, 0.0001);
+      assert(sigmoid.fuzzify(4.99) < 0.01);
+      assert(sigmoid.fuzzify(5) === 0.5);
+      assert(sigmoid.fuzzify(5.01) > 0.99);
+    });
+
+    it('should handle very large slope (near constant 0.5)', function() {
+      const sigmoid = new Sigmoid(5, 10000);
+      assert(Math.abs(sigmoid.fuzzify(0) - 0.5) < 0.1);
+      assert(sigmoid.fuzzify(5) === 0.5);
+      assert(Math.abs(sigmoid.fuzzify(10) - 0.5) < 0.1);
+    });
+
+    it('should handle negative slope', function() {
+      const sigmoid = new Sigmoid(5, -1);
+      // Negative slope reverses the sigmoid
+      assert(sigmoid.fuzzify(3) > 0.5);
+      assert(sigmoid.fuzzify(5) === 0.5);
+      assert(sigmoid.fuzzify(7) < 0.5);
+    });
+  });
+
+  describe('Shapes with negative x values', function() {
+    it('should handle triangle with negative x values', function() {
+      const triangle = new Triangle(-10, -5, 0);
+      assert.equal(triangle.fuzzify(-15), 0);
+      assert.equal(triangle.fuzzify(-10), 0);
+      assert.equal(triangle.fuzzify(-7.5), 0.5);
+      assert.equal(triangle.fuzzify(-5), 1);
+      assert.equal(triangle.fuzzify(-2.5), 0.5);
+      assert.equal(triangle.fuzzify(0), 0);
+      assert.equal(triangle.fuzzify(5), 0);
+    });
+
+    it('should handle trapezoid with negative x values', function() {
+      const trapezoid = new Trapezoid(-20, -15, -5, 0);
+      assert.equal(trapezoid.fuzzify(-25), 0);
+      assert.equal(trapezoid.fuzzify(-20), 0);
+      assert.equal(trapezoid.fuzzify(-17.5), 0.5);
+      assert.equal(trapezoid.fuzzify(-15), 1);
+      assert.equal(trapezoid.fuzzify(-10), 1);
+      assert.equal(trapezoid.fuzzify(-5), 1);
+      assert.equal(trapezoid.fuzzify(-2.5), 0.5);
+      assert.equal(trapezoid.fuzzify(0), 0);
+    });
+  });
+
+  describe('Shapes with very large x values', function() {
+    it('should handle Infinity gracefully', function() {
+      const triangle = new Triangle(0, 10, 20);
+      const trapezoid = new Trapezoid(0, 10, 20, 30);
+      const grade = new Grade(0, 10);
+      const reverseGrade = new ReverseGrade(0, 10);
+      const sigmoid = new Sigmoid(10, 1);
+
+      assert.equal(triangle.fuzzify(Infinity), 0);
+      assert.equal(triangle.fuzzify(-Infinity), 0);
+      assert.equal(trapezoid.fuzzify(Infinity), 0);
+      assert.equal(trapezoid.fuzzify(-Infinity), 0);
+      assert.equal(grade.fuzzify(Infinity), 1);
+      assert.equal(grade.fuzzify(-Infinity), 0);
+      assert.equal(reverseGrade.fuzzify(Infinity), 0);
+      assert.equal(reverseGrade.fuzzify(-Infinity), 1);
+      assert.equal(sigmoid.fuzzify(Infinity), 1);
+      assert.equal(sigmoid.fuzzify(-Infinity), 0);
+    });
+
+    it('should handle very large numbers', function() {
+      const triangle = new Triangle(0, 1e10, 2e10);
+      assert.equal(triangle.fuzzify(0), 0);
+      assert.equal(triangle.fuzzify(1e10), 1);
+      assert.equal(triangle.fuzzify(2e10), 0);
+      assert.equal(triangle.fuzzify(1.5e10), 0.5);
+    });
+  });
+
+  describe('Constant edge values', function() {
+    it('should handle all possible constant values', function() {
+      assert.equal(new Constant(0).fuzzify(), 0);
+      assert.equal(new Constant(0.5).fuzzify(), 0.5);
+      assert.equal(new Constant(1).fuzzify(), 1);
+      assert.equal(new Constant(-1).fuzzify(), -1);
+      assert.equal(new Constant(2).fuzzify(), 2);
+      assert.equal(new Constant(-0.5).fuzzify(), -0.5);
+      assert.equal(new Constant(1.5).fuzzify(), 1.5);
+    });
+
+    it('should ignore x parameter in fuzzify', function() {
+      const constant = new Constant(0.7);
+      assert.equal(constant.fuzzify(0), 0.7);
+      assert.equal(constant.fuzzify(100), 0.7);
+      assert.equal(constant.fuzzify(-100), 0.7);
+      assert.equal(constant.fuzzify(Infinity), 0.7);
+    });
+  });
+
+  describe('FuzzyFunction edge cases', function() {
+    it('should throw error for functions returning values outside [0,1]', function() {
+      const func1 = new FuzzyFunction(x => x * 2); // Returns > 1 for x > 0.5
+      assert.equal(func1.fuzzify(0.3), 0.6);
+      assert.equal(func1.fuzzify(0.5), 1); // Exactly 1 is valid
+      assert.throws(() => func1.fuzzify(0.7), /fuzzified result must be smaller than 1/);
+      
+      const func2 = new FuzzyFunction(x => x - 1); // Returns < 0 for x < 1
+      assert.throws(() => func2.fuzzify(0.5), /fuzzified result must be smaller than 1/);
+      assert.equal(func2.fuzzify(1), 0); // Exactly 0 is valid
+      assert.throws(() => func2.fuzzify(0.8), /fuzzified result must be smaller than 1/);
+    });
+
+    it('should handle complex mathematical functions', function() {
+      const sinFunc = new FuzzyFunction(x => (Math.sin(x) + 1) / 2);
+      assert(sinFunc.fuzzify(0) === 0.5);
+      assert(sinFunc.fuzzify(Math.PI / 2) === 1);
+      assert(sinFunc.fuzzify(3 * Math.PI / 2) === 0);
+    });
+
+    it('should handle functions that throw errors', function() {
+      const errorFunc = new FuzzyFunction(x => {
+        if (x < 0) throw new Error('Negative input');
+        return x;
+      });
+      
+      assert.equal(errorFunc.fuzzify(0.5), 0.5);
+      assert.throws(() => errorFunc.fuzzify(-1), /Negative input/);
+    });
+  });
+});

package/test/error-handling.js

@@ -0,0 +1,229 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('assert');
+const Logic = require('../lib/logic');
+const Triangle = require('../lib/curve/triangle');
+const Trapezoid = require('../lib/curve/trapezoid');
+const Grade = require('../lib/curve/grade');
+const ReverseGrade = require('../lib/curve/reverse-grade');
+const Sigmoid = require('../lib/curve/sigmoid');
+const Constant = require('../lib/curve/constant');
+const FuzzyFunction = require('../lib/curve/fuzzy-function');
+const Shape = require('../lib/curve/shape');
+
+describe('Error Handling', function() {
+  describe('Logic class validation', function() {
+    it('should throw error when calling defuzzify without init', function() {
+      const logic = new Logic();
+      assert.throws(() => logic.defuzzify(5), /init needs to be called before performing logic/);
+    });
+
+    it('should throw error when calling and() without init', function() {
+      const logic = new Logic();
+      const triangle = new Triangle(0, 5, 10);
+      assert.throws(() => logic.and('hot', triangle), /init needs to be called before performing logic/);
+    });
+
+    it('should throw error when calling or() without init', function() {
+      const logic = new Logic();
+      const triangle = new Triangle(0, 5, 10);
+      assert.throws(() => logic.or('hot', triangle), /init needs to be called before performing logic/);
+    });
+
+    it('should throw error when calling not() without init', function() {
+      const logic = new Logic();
+      const triangle = new Triangle(0, 5, 10);
+      assert.throws(() => logic.not('hot', triangle), /init needs to be called before performing logic/);
+    });
+
+    it('should throw error for invalid output names with numbers', function() {
+      const logic = new Logic();
+      const triangle = new Triangle(0, 5, 10);
+      assert.throws(() => logic.init('hot123', triangle), /Output names can only be strings without space/);
+    });
+
+    it('should throw error for invalid output names with spaces', function() {
+      const logic = new Logic();
+      const triangle = new Triangle(0, 5, 10);
+      assert.throws(() => logic.init('hot cold', triangle), /Output names can only be strings without space/);
+    });
+
+    it('should throw error for invalid output names with special chars', function() {
+      const logic = new Logic();
+      const triangle = new Triangle(0, 5, 10);
+      assert.throws(() => logic.init('hot-cold', triangle), /Output names can only be strings without space/);
+      assert.throws(() => logic.init('hot_cold', triangle), /Output names can only be strings without space/);
+      assert.throws(() => logic.init('hot.cold', triangle), /Output names can only be strings without space/);
+    });
+
+    it('should allow valid output names', function() {
+      const logic = new Logic();
+      const triangle = new Triangle(0, 5, 10);
+      assert.doesNotThrow(() => logic.init('hot', triangle));
+      assert.doesNotThrow(() => logic.init('Hot', triangle));
+      assert.doesNotThrow(() => logic.init('HOT', triangle));
+      assert.doesNotThrow(() => logic.init('veryHot', triangle));
+    });
+  });
+
+  describe('Shape constructor validation', function() {
+    it('should handle NaN parameters', function() {
+      const triangle = new Triangle(NaN, 5, 10);
+      // NaN in x0 means x <= NaN is false, so it falls through to other conditions
+      // The result depends on the specific implementation
+      const result = triangle.fuzzify(5);
+      assert(typeof result === 'number');
+      
+      const trapezoid = new Trapezoid(0, NaN, 10, 15);
+      const result2 = trapezoid.fuzzify(5);
+      assert(typeof result2 === 'number');
+      
+      const grade = new Grade(NaN, 10);
+      const result3 = grade.fuzzify(5);
+      assert(typeof result3 === 'number');
+    });
+
+    it('should handle Infinity parameters', function() {
+      // Triangle with Infinity produces NaN in division
+      const triangle = new Triangle(0, 10, Infinity);
+      assert.equal(triangle.fuzzify(0), 0);
+      assert.equal(triangle.fuzzify(10), 1);
+      assert(isNaN(triangle.fuzzify(20))); // (Infinity - 20) / (Infinity - 10) = NaN
+      
+      const grade = new Grade(0, Infinity);
+      assert.equal(grade.fuzzify(0), 0);
+      assert.equal(grade.fuzzify(1000), 0); // 1000/Infinity = 0
+      assert.equal(grade.fuzzify(Infinity), 1); // Only at infinity
+    });
+
+    it('should handle undefined parameters with defaults', function() {
+      // Most shapes don't have default parameters, they'll get undefined
+      const sigmoid = new Sigmoid(); // Has defaults
+      assert.equal(sigmoid.fuzzify(0), 0.5); // Default center=0, slope=1
+    });
+  });
+
+  describe('FuzzyFunction validation', function() {
+    it('should throw error when callback is not a function', function() {
+      assert.throws(() => {
+        const func = new FuzzyFunction('not a function');
+        func.fuzzify(5);
+      }, TypeError);
+    });
+
+    it('should throw error when callback is null', function() {
+      assert.throws(() => {
+        const func = new FuzzyFunction(null);
+        func.fuzzify(5);
+      }, TypeError);
+    });
+
+    it('should throw error when callback is undefined', function() {
+      assert.throws(() => {
+        const func = new FuzzyFunction(undefined);
+        func.fuzzify(5);
+      }, TypeError);
+    });
+
+    it('should throw error when callback returns non-number', function() {
+      const func = new FuzzyFunction(() => 'string');
+      // FuzzyFunction doesn't validate type, only range [0,1]
+      // String will fail the >= 0 check
+      assert.throws(() => func.fuzzify(5), /fuzzified result must be smaller than 1/);
+      
+      const func2 = new FuzzyFunction(() => null);
+      // null converts to 0 in comparisons, so it passes the validation
+      assert.equal(func2.fuzzify(5), null); // Returns null as is
+      
+      const func3 = new FuzzyFunction(() => undefined);
+      // undefined doesn't pass the range check
+      assert.throws(() => func3.fuzzify(5), /fuzzified result must be smaller than 1/);
+    });
+
+    it('should handle callback that sometimes returns valid values', function() {
+      const func = new FuzzyFunction(x => {
+        if (x < 0) return -1; // Invalid
+        if (x > 1) return 2; // Invalid
+        return x; // Valid for [0,1]
+      });
+      
+      assert.equal(func.fuzzify(0.5), 0.5);
+      assert.throws(() => func.fuzzify(-1), /fuzzified result must be smaller than 1/);
+      assert.throws(() => func.fuzzify(2), /fuzzified result must be smaller than 1/);
+    });
+  });
+
+  describe('ES6 class instantiation', function() {
+    it('should throw error when calling shapes without new keyword', function() {
+      assert.throws(() => Triangle(0, 5, 10), /Class constructor .* cannot be invoked without 'new'/);
+      assert.throws(() => Trapezoid(0, 5, 10, 15), /Class constructor .* cannot be invoked without 'new'/);
+      assert.throws(() => Grade(0, 10), /Class constructor .* cannot be invoked without 'new'/);
+      assert.throws(() => ReverseGrade(0, 10), /Class constructor .* cannot be invoked without 'new'/);
+      assert.throws(() => Sigmoid(5, 1), /Class constructor .* cannot be invoked without 'new'/);
+      assert.throws(() => Constant(0.5), /Class constructor .* cannot be invoked without 'new'/);
+      assert.throws(() => Shape(0, 5, 10, 15), /Class constructor .* cannot be invoked without 'new'/);
+      assert.throws(() => FuzzyFunction(x => x), /Class constructor .* cannot be invoked without 'new'/);
+      assert.throws(() => Logic(), /Class constructor .* cannot be invoked without 'new'/);
+    });
+  });
+
+  describe('Empty rules array handling', function() {
+    it('should handle defuzzify with no rules', function() {
+      const logic = new Logic();
+      // Init is called but rules array is empty
+      logic.initCalled = true; // Bypass init check
+      logic.rules = []; // Empty rules
+      
+      const result = logic.defuzzify(5);
+      assert.equal(result.defuzzified, 'none');
+      assert.equal(result.fuzzified, 0);
+      assert.deepEqual(result.rules, []);
+    });
+  });
+
+  describe('Invalid chaining sequences', function() {
+    it('should handle multiple init calls', function() {
+      const logic = new Logic();
+      const triangle1 = new Triangle(0, 5, 10);
+      const triangle2 = new Triangle(10, 15, 20);
+      
+      logic.init('cold', triangle1);
+      // Second init should work (not throw)
+      assert.doesNotThrow(() => logic.init('hot', triangle2));
+      
+      // But rules should contain both
+      assert.equal(logic.rules.length, 2);
+    });
+
+    it('should handle chaining after defuzzify', function() {
+      const logic = new Logic();
+      const triangle = new Triangle(0, 5, 10);
+      
+      logic.init('cold', triangle).and('warm', new Triangle(5, 10, 15));
+      const result1 = logic.defuzzify(7.5);
+      
+      // Can continue chaining after defuzzify
+      logic.or('hot', new Triangle(10, 15, 20));
+      const result2 = logic.defuzzify(12.5);
+      
+      assert.equal(logic.rules.length, 3);
+    });
+  });
+
+  describe('Property immutability', function() {
+    it('should verify shape properties are read-only', function() {
+      const triangle = new Triangle(0, 5, 10);
+      
+      // Attempt to modify properties should throw in strict mode
+      assert.throws(() => {
+        'use strict';
+        triangle.x0 = 100;
+      }, /Cannot assign to read only property/);
+      
+      // Properties should be unchanged
+      assert.equal(triangle.x0, 0);
+      assert.equal(triangle.x1, 5);
+      assert.equal(triangle.x2, 10);
+    });
+  });
+});

package/test/example-test.js

@@ -1,3 +1,4 @@
+const { describe, it, beforeEach } = require('node:test');
 const assert = require('assert');
 const Logic = require('../lib/logic');
 const Triangle = require('../lib/curve/triangle');

package/test/init-called.test.js

@@ -1,3 +1,4 @@
+const { describe, it } = require('node:test');
 const assert = require('assert');
 const Logic = require('../lib/logic');
 const Triangle = require('../lib/curve/triangle');