q5 2.9.21 → 2.9.23

package/p5-tests/unit/math/random.js

@@ -0,0 +1,177 @@
+suite('Random', function() {
+  var myp5;
+
+  setup(function(done) {
+    new p5(function(p) {
+      p.setup = function() {
+        myp5 = p;
+        done();
+      };
+    });
+  });
+
+  teardown(function() {
+    myp5.remove();
+  });
+
+  suite('p5.prototype.random', function() {
+    var result;
+
+    var results = [];
+
+    suite('random()', function() {
+      setup(function() {
+        myp5.randomSeed(99);
+        for (var i = 0; i < 5; i++) {
+          results[i] = myp5.random();
+        }
+        myp5.randomSeed(99);
+        for (i = 5; i < 10; i++) {
+          results[i] = myp5.random();
+        }
+      });
+      test('should return a number', function() {
+        for (var i = 0; i < 10; i++) {
+          assert.typeOf(results[i], 'number');
+        }
+      });
+      test('should return a number 0 <= n < 1', function() {
+        for (var i = 0; i < 10; i++) {
+          assert.isTrue(results[i] >= 0);
+          assert.isTrue(results[i] < 1);
+        }
+      });
+      test('should return same sequence of numbers', function() {
+        for (var i = 0; i < 5; i++) {
+          assert.isTrue(results[i] === results[i + 5]);
+        }
+      });
+    });
+
+    suite('random(5)', function() {
+      test('should return a number 0 <= n < 5', function() {
+        result = myp5.random(5);
+        assert.isTrue(result >= 0);
+        assert.isTrue(result < 5);
+      });
+    });
+
+    suite('random(1, 10)', function() {
+      test('should return a number 1 <= n < 10', function() {
+        result = myp5.random(1, 10);
+        assert.isTrue(result >= 1);
+        assert.isTrue(result < 10);
+      });
+    });
+
+    suite('random(["apple", "pear", "orange", "grape"])', function() {
+      test('should return a fruit', function() {
+        var fruits = ['apple', 'pear', 'orange', 'grape'];
+        result = myp5.random(fruits);
+        assert.include(fruits, result);
+      });
+    });
+  });
+  suite('instance mode', function() {
+    var instances = [];
+
+    function addInstance(max, done) {
+      new p5(function(p) {
+        p.setup = function() {
+          instances.push(p);
+          if (instances.length >= max) {
+            done();
+          }
+        };
+      });
+    }
+
+    setup(function(done) {
+      var instanceCount = 2;
+      for (var i = 0; i < instanceCount; i++) {
+        addInstance(instanceCount, done);
+      }
+    });
+
+    teardown(function() {
+      instances.forEach(function(instance) {
+        instance.remove();
+      });
+    });
+
+    test('should be independent', function() {
+      var SEED = 42;
+
+      instances.forEach(function(instance) {
+        instance.randomSeed(SEED);
+      });
+
+      for (var i = 0; i < 10; i++) {
+        instances.reduce(function(prev, instance) {
+          var randomValue = instance.random();
+          if (prev != null) {
+            assert.equal(randomValue, prev);
+          }
+
+          return randomValue;
+        }, null);
+      }
+    });
+  });
+
+  suite('p5.prototype.randomGaussian', function() {
+    suite('instance mode', function() {
+      var instances = [];
+
+      function addInstance(max, done) {
+        new p5(function(p) {
+          p.setup = function() {
+            instances.push(p);
+            if (instances.length >= max) {
+              done();
+            }
+          };
+        });
+      }
+
+      setup(function(done) {
+        var instanceCount = 2;
+        for (var i = 0; i < instanceCount; i++) {
+          addInstance(instanceCount, done);
+        }
+      });
+
+      teardown(function() {
+        instances.forEach(function(instance) {
+          instance.remove();
+        });
+      });
+
+      test('should be independent', function() {
+        var SEED = 42;
+
+        instances.forEach(function(instance) {
+          instance.randomSeed(SEED);
+        });
+
+        for (var i = 0; i < 10; i++) {
+          instances.reduce(function(prev, instance) {
+            var randomValue = instance.randomGaussian(0, 15);
+            if (prev != null) {
+              assert.equal(randomValue, prev);
+            }
+
+            return randomValue;
+          }, null);
+        }
+      });
+    });
+
+    suite('randomGaussian(42, 0)', function() {
+      test('should return 42', function() {
+        result = myp5.randomGaussian(42, 0);
+        assert.isTrue(result === 42);
+      });
+    });
+  });
+});

package/p5-tests/unit/math/trigonometry.js

@@ -0,0 +1,144 @@
+suite('Trigonometry', function() {
+  var theta = 90;
+  var x = 0;
+  var y = 1;
+  var ratio = 0.5;
+  var RADIANS = 'radians';
+  var DEGREES = 'degrees';
+  var myp5;
+
+  setup(function(done) {
+    new p5(function(p) {
+      p.setup = function() {
+        myp5 = p;
+        done();
+      };
+    });
+  });
+
+  teardown(function() {
+    myp5.remove();
+  });
+
+  var handleDegreesAndRadians = function(func) {
+    test('should handle degrees', function() {
+      myp5.angleMode(DEGREES);
+      var degToRad = myp5.radians(theta);
+      assert.equal(Math[func](degToRad), myp5[func](theta));
+    });
+
+    test('should handle radians', function() {
+      myp5.angleMode(RADIANS);
+      assert.equal(Math[func](theta), myp5[func](theta));
+    });
+  };
+
+  var ahandleDegreesAndRadians = function(func) {
+    test('should handle degrees', function() {
+      myp5.angleMode(DEGREES);
+      assert.equal(myp5.degrees(Math[func](ratio)), myp5[func](ratio));
+    });
+
+    test('should handle radians', function() {
+      myp5.angleMode(RADIANS);
+      assert.equal(Math[func](ratio), myp5[func](ratio));
+    });
+  };
+
+  suite('p5.prototype.angleMode', function() {
+    test('should set constant to DEGREES', function() {
+      myp5.angleMode(DEGREES);
+      assert.equal(myp5.angleMode(), 'degrees');
+    });
+
+    test('should set constant to RADIANS', function() {
+      myp5.angleMode(RADIANS);
+      assert.equal(myp5.angleMode(), 'radians');
+    });
+
+    test('wrong param type', function() {
+      assert.validationError(function() {
+        myp5.angleMode('wtflolzkk');
+      });
+    });
+
+    test('should return radians', function() {
+      myp5.angleMode(RADIANS);
+      assert.equal(myp5.angleMode(), 'radians');
+    });
+
+    test('should return degrees', function() {
+      myp5.angleMode(DEGREES);
+      assert.equal(myp5.angleMode(), 'degrees');
+    });
+
+    test('should always be RADIANS or DEGREES', function() {
+      myp5.angleMode('wtflolzkk');
+      assert.equal(myp5.angleMode(), 'radians');
+    });
+  });
+
+  suite('p5.prototype.degrees', function() {
+    test('should return the angle in radians when angleMode is DEGREES', function() {
+      myp5.angleMode(DEGREES);
+      var angleInRad = 360 * theta / (2 * Math.PI); // This is degToRad conversion
+      assert.equal(myp5.degrees(theta), angleInRad);
+    });
+
+    test('should return the angle in radians when angleMode is RADIANS', function() {
+      myp5.angleMode(RADIANS);
+      var angleInRad = 360 * theta / (2 * Math.PI); // This is degToRad conversion
+      assert.equal(myp5.degrees(theta), angleInRad);
+    });
+  });
+
+  suite('p5.prototype.radians', function() {
+    test('should return the angle in degrees when angleMode is RADIANS', function() {
+      myp5.angleMode(RADIANS);
+      var angleInDeg = 2 * Math.PI * theta / 360; // This is RadToDeg conversion
+      assert.equal(myp5.radians(theta), angleInDeg);
+    });
+
+    test('should return the angle in degrees when angleMode is DEGREES', function() {
+      myp5.angleMode(DEGREES);
+      var angleInDeg = 2 * Math.PI * theta / 360; // This is RadToDeg conversion
+      assert.equal(myp5.radians(theta), angleInDeg);
+    });
+  });
+
+  suite('p5.prototype.asin', function() {
+    ahandleDegreesAndRadians('asin');
+  });
+
+  suite('p5.prototype.atan', function() {
+    ahandleDegreesAndRadians('atan');
+  });
+
+  suite('p5.prototype.acos', function() {
+    ahandleDegreesAndRadians('acos');
+  });
+
+  suite('p5.prototype.sin', function() {
+    handleDegreesAndRadians('sin');
+  });
+
+  suite('p5.prototype.cos', function() {
+    handleDegreesAndRadians('cos');
+  });
+
+  suite('p5.prototype.tan', function() {
+    handleDegreesAndRadians('tan');
+  });
+
+  suite('p5.prototype.atan2', function() {
+    test('should handle degrees', function() {
+      myp5.angleMode(DEGREES);
+      assert.equal(myp5.degrees(Math.atan2(y, x)), myp5.atan2(y, x));
+    });
+
+    test('should handle radians', function() {
+      myp5.angleMode(RADIANS);
+      assert.equal(Math.atan2(y, x), myp5.atan2(y, x));
+    });
+  });
+});

package/p5-tests/unit/spec.js

@@ -0,0 +1,50 @@
+var spec = {
+	// color: ['color_conversion', 'creating_reading', 'p5.Color', 'setting'],
+	core: [
+		'2d_primitives',
+		'attributes',
+		'curves',
+		'environment',
+		// 'error_helpers',
+		'main',
+		// 'p5.Element',
+		'p5.Graphics',
+		'preload',
+		'rendering',
+		'structure',
+		'transform',
+		'version',
+		'vertex'
+	],
+	// dom: ['dom'],
+	events: ['keyboard', 'mouse', 'touch', 'acceleration'],
+	image: [
+		'p5.Image',
+		'loading',
+		'pixels',
+		'filters',
+		'downloading'
+	],
+	io: [
+		'files',
+		// 'loadBytes',
+		// 'loadStrings',
+		// 'loadXML',
+		'loadJSON',
+		// 'loadTable',
+		// 'saveTable',
+		'loadImage'
+		// 'loadModel',
+		// 'loadShader'
+	],
+	math: ['calculation', 'noise', 'p5.Vector', 'random', 'trigonometry'],
+	typography: ['attributes', 'loadFont', 'p5.Font'],
+	utilities: ['conversion', 'time_date']
+};
+
+Object.keys(spec).map(function (folder) {
+	spec[folder].map(function (file) {
+		var string = ['<script src="unit/', folder, '/', file, '.js" type="text/javascript" ></script>'];
+		document.write(string.join(''));
+	});
+});

package/p5-tests/unit/typography/attributes.js

@@ -0,0 +1,120 @@
+suite('Typography Attributes', function() {
+  let myp5;
+
+  setup(function(done) {
+    new p5(function(p) {
+      p.setup = function() {
+        myp5 = p;
+        done();
+      };
+    });
+  });
+
+  teardown(function() {
+    myp5.remove();
+  });
+
+  suite('p5.prototype.textAlign', function() {
+    test('wrong param at #0', function() {
+      assert.validationError(function() {
+        myp5.textAlign('a');
+      });
+    });
+    test('wrong param at #1', function() {
+      assert.validationError(function() {
+        myp5.textAlign(myp5.CENTER, 'a');
+      });
+    });
+    test('wrong param at #0. vertAlign as #0 param.', function() {
+      assert.validationError(function() {
+        myp5.textAlign(myp5.BOTTOM);
+      });
+    });
+    test('wrong param at #1. horizAlign as #1 param.', function() {
+      assert.validationError(function() {
+        myp5.textAlign(myp5.CENTER, myp5.LEFT);
+      });
+    });
+  });
+
+  suite('p5.prototype.textLeading', function() {
+    test('sets and gets the spacing value', function() {
+      myp5.textLeading(20);
+      assert.strictEqual(myp5.textLeading(), 20);
+    });
+    test('should work for negative spacing value', function() {
+      myp5.textLeading(-20);
+      assert.strictEqual(myp5.textLeading(), -20);
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.textLeading('C');
+      });
+    });
+    test.skip('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.textLeading('25');
+      });
+    });
+  });
+
+  suite('p5.prototype.textSize', function() {
+    test('sets and gets the font size', function() {
+      myp5.textSize(24);
+      assert.strictEqual(myp5.textSize(), 24);
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.textSize('A');
+      });
+    });
+    test.skip('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.textSize('30');
+      });
+    });
+  });
+
+  suite('p5.prototype.textStyle', function() {
+    test('sets and gets the font style', function() {
+      myp5.textStyle(myp5.ITALIC);
+      assert.strictEqual(myp5.textStyle(), myp5.ITALIC);
+    });
+    test('wrong param at #0', function() {
+      assert.validationError(function() {
+        myp5.textStyle('a');
+      });
+    });
+  });
+
+  suite('p5.prototype.textWidth', function() {
+    test('should return a number for char input', function() {
+      assert.isNumber(myp5.textWidth('P'));
+    });
+    test('should return a number for string input.', function() {
+      assert.isNumber(myp5.textWidth('p5.js'));
+    });
+    // Either should not throw error
+    test('should return a number for number input', function() {
+      assert.isNumber(myp5.textWidth('p5.js'));
+    });
+  });
+
+  suite('p5.prototype.textAscent', function() {
+    test('should return a number', function() {
+      assert.isNumber(myp5.textAscent());
+    });
+  });
+
+  suite('p5.prototype.textDescent', function() {
+    test('should return a number', function() {
+      assert.isNumber(myp5.textDescent());
+    });
+  });
+
+  suite('p5.prototype.textWrap', function() {
+    test('returns textWrap text attribute', function() {
+      assert.strictEqual(myp5.textWrap(myp5.WORD), myp5.WORD);
+    });
+  });
+});

package/p5-tests/unit/typography/loadFont.js

@@ -0,0 +1,162 @@
+suite('Loading Displaying Fonts', function() {
+  var myp5;
+
+  setup(function(done) {
+    new p5(function(p) {
+      p.setup = function() {
+        myp5 = p;
+        done();
+      };
+    });
+  });
+
+  teardown(function() {
+    myp5.remove();
+  });
+
+  suite('p5.prototype.loadFont', function() {
+    var invalidFile = '404file';
+    var fontFile = 'manual-test-examples/p5.Font/acmesa.ttf';
+
+    test('_friendlyFileLoadError is called', async function() {
+      const _friendlyFileLoadErrorStub = sinon.stub(
+        p5,
+        '_friendlyFileLoadError'
+      );
+      try {
+        await promisedSketch(function(sketch, resolve, reject) {
+          sketch.preload = function() {
+            sketch.loadFont(invalidFile, reject, resolve);
+          };
+        });
+        expect(
+          _friendlyFileLoadErrorStub.calledOnce,
+          'p5._friendlyFileLoadError was not called'
+        ).to.be.true;
+      } finally {
+        _friendlyFileLoadErrorStub.restore();
+      }
+    });
+
+    testSketchWithPromise('error prevents sketch continuing', function(
+      sketch,
+      resolve,
+      reject
+    ) {
+      sketch.preload = function() {
+        sketch.loadFont(invalidFile, reject, function() {
+          setTimeout(resolve, 50);
+        });
+      };
+
+      sketch.setup = function() {
+        reject(new Error('Setup called'));
+      };
+
+      sketch.draw = function() {
+        reject(new Error('Draw called'));
+      };
+    });
+
+    testSketchWithPromise('error callback is called', function(
+      sketch,
+      resolve,
+      reject
+    ) {
+      sketch.preload = function() {
+        sketch.loadFont(
+          invalidFile,
+          function() {
+            reject(new Error('Success callback executed.'));
+          },
+          function() {
+            // Wait a bit so that if both callbacks are executed we will get an error.
+            setTimeout(resolve, 50);
+          }
+        );
+      };
+    });
+
+    testSketchWithPromise('loading correctly triggers setup', function(
+      sketch,
+      resolve,
+      reject
+    ) {
+      sketch.preload = function() {
+        sketch.loadFont(fontFile);
+      };
+
+      sketch.setup = function() {
+        resolve();
+      };
+    });
+
+    testSketchWithPromise('success callback is called', function(
+      sketch,
+      resolve,
+      reject
+    ) {
+      var hasBeenCalled = false;
+      sketch.preload = function() {
+        sketch.loadFont(
+          fontFile,
+          function() {
+            hasBeenCalled = true;
+          },
+          function(err) {
+            reject(new Error('Error callback was entered: ' + err));
+          }
+        );
+      };
+
+      sketch.setup = function() {
+        if (!hasBeenCalled) {
+          reject(new Error('Setup called prior to success callback'));
+        } else {
+          setTimeout(resolve, 50);
+        }
+      };
+    });
+
+    test('returns a p5.Font object', async function() {
+      const font = await promisedSketch(function(sketch, resolve, reject) {
+        let _font;
+        sketch.preload = function() {
+          _font = sketch.loadFont(fontFile, function() {}, reject);
+        };
+
+        sketch.setup = function() {
+          resolve(_font);
+        };
+      });
+      assert.instanceOf(font, p5.Font);
+    });
+
+    test('passes a p5.Font object to success callback', async function() {
+      const font = await promisedSketch(function(sketch, resolve, reject) {
+        sketch.preload = function() {
+          sketch.loadFont(fontFile, resolve, reject);
+        };
+      });
+      assert.isObject(font);
+    });
+  });
+
+  suite('p5.prototype.textFont', function() {
+    test('sets the current font as Georgia', function() {
+      myp5.textFont('Georgia');
+      assert.strictEqual(myp5.textFont(), 'Georgia');
+    });
+
+    test('sets the current font as Helvetica', function() {
+      myp5.textFont('Helvetica');
+      assert.strictEqual(myp5.textFont(), 'Helvetica');
+    });
+
+    test('sets the current font and text size', function() {
+      myp5.textFont('Courier New', 24);
+      assert.strictEqual(myp5.textFont(), 'Courier New');
+      assert.strictEqual(myp5.textSize(), 24);
+    });
+  });
+});

package/p5-tests/unit/typography/p5.Font.js

@@ -0,0 +1,63 @@
+suite('p5.Font', function() {
+  var myp5;
+
+  setup(function(done) {
+    new p5(function(p) {
+      p.setup = function() {
+        myp5 = p;
+        done();
+      };
+    });
+  });
+
+  teardown(function() {
+    myp5.remove();
+  });
+
+  suite('p5.Font.prototype.textBounds', function() {
+    test('returns a tight bounding box for the given text string', async function() {
+      let fontFile = 'manual-test-examples/p5.Font/acmesa.ttf';
+      const bbox = await promisedSketch(function(sketch, resolve, reject) {
+        let _font;
+        let textString = 'Lorem ipsum dolor sit amet.';
+        sketch.preload = function() {
+          _font = sketch.loadFont(fontFile, function() {}, reject);
+        };
+        sketch.setup = function() {
+          let _bbox = _font.textBounds(textString, 10, 30, 12);
+          resolve(_bbox);
+        };
+      });
+      assert.isObject(bbox);
+      assert.property(bbox, 'x');
+      assert.property(bbox, 'y');
+      assert.property(bbox, 'w');
+      assert.property(bbox, 'h');
+    });
+  });
+
+  suite('p5.Font.prototype.textToPoints', function() {
+    test('returns array of points', async function() {
+      let fontFile = 'manual-test-examples/p5.Font/acmesa.ttf';
+      const points = await promisedSketch(function(sketch, resolve, reject) {
+        let _font;
+        sketch.preload = function() {
+          _font = sketch.loadFont(fontFile, function() {}, reject);
+        };
+        sketch.setup = function() {
+          let _points = _font.textToPoints('p5', 0, 0, 10, {
+            sampleFactor: 5,
+            simplifyThreshold: 0
+          });
+          resolve(_points);
+        };
+      });
+      assert.isArray(points);
+      points.forEach(p => {
+        assert.property(p, 'x');
+        assert.property(p, 'y');
+        assert.property(p, 'alpha');
+      });
+    });
+  });
+});