q5 2.9.22 → 2.9.23

package/p5-tests/unit/core/p5.Graphics.js

@@ -0,0 +1,179 @@
+suite('Graphics', function() {
+  var myp5;
+
+  setup(function(done) {
+    new p5(function(p) {
+      p.setup = function() {
+        myp5 = p;
+        done();
+      };
+    });
+  });
+
+  teardown(function() {
+    myp5.remove();
+  });
+
+  function assertValidGraphSizes(graph, w, h, density) {
+    assert.strictEqual(graph.pixelDensity(), density, 'invalid pixel density');
+    assert.strictEqual(graph.width, w, 'invalid width');
+    assert.strictEqual(graph.height, h, 'invalid height');
+  }
+
+  function assertValidCanvasSizes(canvas, w, h, density) {
+    assert.strictEqual(canvas.width, w * density, 'canvas.width');
+    assert.strictEqual(canvas.height, h * density, 'canvas.height');
+    assert.strictEqual(
+      canvas.style.width,
+      '' + w + 'px',
+      'invalid canvas.style.width'
+    );
+    assert.strictEqual(
+      canvas.style.height,
+      '' + h + 'px',
+      'invalid canvas.style.height'
+    );
+  }
+
+  function assertValidPixels(graph, w, h, density) {
+    graph.loadPixels();
+    var real = graph.pixels.length;
+    var expected = w * density * h * density * 4;
+    assert.strictEqual(real, expected, 'invalid number of pixels');
+  }
+
+  suite('p5.prototype.createGraphics', function() {
+    test('it creates a graphics', function() {
+      var graph = myp5.createGraphics(10, 17);
+      assert.isObject(graph);
+    });
+
+  });
+
+  suite('p5.Graphics', function() {
+    test('it has necessary properties', function() {
+      var graph = myp5.createGraphics(10, 17);
+      assert.property(graph, 'width');
+      assert.property(graph, 'height');
+      assert.property(graph, 'canvas');
+      assert.property(graph, 'pixelDensity');
+      assert.property(graph, 'loadPixels');
+      assert.property(graph, 'pixels');
+    });
+
+    test('it has consistent sizes', function() {
+      var graph = myp5.createGraphics(10, 17);
+      graph.pixelDensity(1);
+      assertValidGraphSizes(graph, 10, 17, 1);
+    });
+
+    test('its canvas has consistent sizes', function() {
+      var graph = myp5.createGraphics(10, 17);
+      graph.pixelDensity(1);
+      assertValidCanvasSizes(graph.canvas, 10, 17, 1);
+    });
+
+    test('it has a valid pixels array', function() {
+      var graph = myp5.createGraphics(10, 17);
+      graph.pixelDensity(1);
+      assertValidPixels(graph, 10, 17, 1);
+    });
+  });
+
+  suite('p5.Graphics.pixelDensity', function() {
+    test('it can change density', function() {
+      var graph = myp5.createGraphics(10, 17);
+      graph.pixelDensity(1);
+      assert.strictEqual(graph.pixelDensity(), 1);
+      graph.pixelDensity(3);
+      assert.strictEqual(graph.pixelDensity(), 3);
+    });
+
+    test('it keeps valid sizes after change', function() {
+      var graph = myp5.createGraphics(10, 17);
+      graph.pixelDensity(1);
+      assertValidGraphSizes(graph, 10, 17, 1);
+      graph.pixelDensity(3);
+      assertValidGraphSizes(graph, 10, 17, 3);
+    });
+
+    test('its canvas keeps valid sizes after change', function() {
+      var graph = myp5.createGraphics(10, 17);
+      graph.pixelDensity(1);
+      assertValidCanvasSizes(graph.canvas, 10, 17, 1);
+      graph.pixelDensity(3);
+      assertValidCanvasSizes(graph.canvas, 10, 17, 3);
+    });
+
+    test('it keeps a valid pixel array after change', function() {
+      var graph = myp5.createGraphics(10, 17);
+      graph.pixelDensity(1);
+      assertValidPixels(graph, 10, 17, 1);
+
+      graph.pixelDensity(3);
+      assertValidPixels(graph, 10, 17, 3);
+    });
+  });
+
+  suite('p5.Graphics.resizeCanvas', function() {
+    test('it can call resizeCanvas', function() {
+      var graph = myp5.createGraphics(10, 17);
+      var resize = function() {
+        graph.resizeCanvas(19, 16);
+      };
+      assert.doesNotThrow(resize);
+    });
+
+    test('it resizes properly with pixelDensity 1', function() {
+      var graph = myp5.createGraphics(10, 17);
+      graph.pixelDensity(1);
+      graph.resizeCanvas(19, 16);
+      assertValidGraphSizes(graph, 19, 16, 1);
+    });
+
+    test('its canvas resizes properly with pixelDensity 1', function() {
+      var graph = myp5.createGraphics(10, 17);
+      graph.pixelDensity(1);
+      graph.resizeCanvas(19, 16);
+      assertValidCanvasSizes(graph.canvas, 19, 16, 1);
+    });
+
+    test('it resizes properly the pixels array with density 1', function() {
+      var graph = myp5.createGraphics(10, 17);
+      graph.pixelDensity(1);
+      graph.resizeCanvas(19, 16);
+      assertValidPixels(graph, 19, 16, 1);
+    });
+
+    test('it resizes properly with pixelDensity 2', function() {
+      var graph = myp5.createGraphics(10, 17);
+      graph.pixelDensity(2);
+      graph.resizeCanvas(19, 16);
+      assertValidGraphSizes(graph, 19, 16, 2);
+    });
+
+    test('its canvas resizes properly with pixelDensity 2', function() {
+      var graph = myp5.createGraphics(10, 17);
+      graph.pixelDensity(2);
+      graph.resizeCanvas(19, 16);
+      assertValidCanvasSizes(graph.canvas, 19, 16, 2);
+    });
+
+    test('it resizes properly the pixels array with density 2', function() {
+      var graph = myp5.createGraphics(10, 17);
+      graph.pixelDensity(2);
+      graph.resizeCanvas(19, 16);
+      assertValidPixels(graph, 19, 16, 2);
+    });
+  });
+
+  suite('p5.Graphics.remove()', function() {
+    test('it sets properties to undefined after removal', function() {
+      var graph = myp5.createGraphics(10, 17);
+      graph.remove();
+      assert.isUndefined(graph.canvas);
+      assert.isUndefined(graph._renderer);
+      assert.isUndefined(graph.elt);
+    });
+  });
+});

package/p5-tests/unit/core/preload.js

@@ -0,0 +1,285 @@
+suite('preloads', () => {
+  let preloadCache = null;
+  setup(() => {
+    preloadCache = p5.prototype._promisePreloads;
+    p5.prototype._promisePreloads = [...preloadCache];
+  });
+
+  teardown(() => {
+    p5.prototype._promisePreloads = preloadCache;
+  });
+
+  suite('From external sources', () => {
+    test('Extension preload causes setup to wait', () => {
+      let resolved = false;
+      const target = {
+        async testPreloadFunction() {
+          await new Promise(res => setTimeout(res, 10));
+          resolved = true;
+        }
+      };
+
+      p5.prototype._promisePreloads.push({
+        target,
+        method: 'testPreloadFunction'
+      });
+
+      return promisedSketch((sketch, resolve, reject) => {
+        sketch.preload = () => {
+          target.testPreloadFunction();
+        };
+
+        sketch.setup = () => {
+          if (resolved) {
+            resolve();
+          } else {
+            reject(new Error('Sketch enetered setup too early.'));
+          }
+        };
+      });
+    });
+
+    test('Extension preload error causes setup to not execute', () => {
+      const target = {
+        async testPreloadFunction() {
+          throw new Error('Testing Error');
+        }
+      };
+
+      p5.prototype._promisePreloads.push({
+        target,
+        method: 'testPreloadFunction'
+      });
+
+      return promisedSketch((sketch, resolve, reject) => {
+        sketch.preload = () => {
+          target.testPreloadFunction();
+          setTimeout(resolve, 10);
+        };
+
+        sketch.setup = () => {
+          reject('Sketch should not enter setup');
+        };
+      });
+    });
+
+    suite('addCallbacks', () => {
+      test('Extension is passed all arguments when not using addCallbacks', () => {
+        const target = {
+          async testPreloadFunction(...args) {
+            assert.lengthOf(args, 3);
+          }
+        };
+
+        p5.prototype._promisePreloads.push({
+          target,
+          method: 'testPreloadFunction',
+          addCallbacks: false
+        });
+
+        return promisedSketch((sketch, resolve, reject) => {
+          sketch.preload = () => {
+            target
+              .testPreloadFunction(() => {}, () => {}, () => {})
+              .catch(reject);
+          };
+
+          sketch.setup = resolve;
+        });
+      });
+
+      test('Extension gets stripped arguments when using addCallbacks', () => {
+        const target = {
+          async testPreloadFunction(...args) {
+            assert.lengthOf(args, 1);
+          }
+        };
+
+        p5.prototype._promisePreloads.push({
+          target,
+          method: 'testPreloadFunction',
+          addCallbacks: true
+        });
+
+        return promisedSketch((sketch, resolve, reject) => {
+          sketch.preload = () => {
+            target
+              .testPreloadFunction(() => {}, () => {}, () => {})
+              .catch(reject);
+          };
+
+          sketch.setup = resolve;
+        });
+      });
+
+      test('Extension with addCallbacks supports success callback', () => {
+        const target = {
+          async testPreloadFunction(...args) {
+            assert.lengthOf(args, 1);
+          }
+        };
+
+        p5.prototype._promisePreloads.push({
+          target,
+          method: 'testPreloadFunction',
+          addCallbacks: true
+        });
+
+        let success = 0;
+
+        return promisedSketch((sketch, resolve, reject) => {
+          sketch.preload = () => {
+            target
+              .testPreloadFunction(0, () => {
+                success++;
+              })
+              .catch(reject);
+            target
+              .testPreloadFunction(
+                () => {},
+                () => {
+                  success++;
+                },
+                () => {
+                  reject(new Error('Failure callback executed'));
+                }
+              )
+              .catch(reject);
+          };
+
+          sketch.setup = () => {
+            if (success !== 2) {
+              reject(
+                new Error(`Not all success callbacks were run: ${success}/2`)
+              );
+            }
+            resolve();
+          };
+        });
+      });
+    });
+
+    suite('legacyPreload', () => {
+      test('Extension legacy preload causes setup to wait', () => {
+        let resolved = false;
+        const target = {
+          async testPreloadFunction() {
+            await new Promise(res => setTimeout(res, 10));
+            resolved = true;
+          }
+        };
+
+        p5.prototype._promisePreloads.push({
+          target,
+          method: 'testPreloadFunction',
+          legacyPreloadSetup: {
+            method: 'testPreloadLegacy'
+          }
+        });
+
+        return promisedSketch((sketch, resolve, reject) => {
+          sketch.preload = () => {
+            target.testPreloadLegacy();
+          };
+
+          sketch.setup = () => {
+            if (resolved) {
+              resolve();
+            } else {
+              reject(new Error('Sketch enetered setup too early.'));
+            }
+          };
+        });
+      });
+
+      test('Extension legacy preload error causes setup to not execute', () => {
+        const target = {
+          async testPreloadFunction() {
+            throw new Error('Testing Error');
+          }
+        };
+
+        p5.prototype._promisePreloads.push({
+          target,
+          method: 'testPreloadFunction',
+          legacyPreloadSetup: {
+            method: 'testPreloadLegacy'
+          }
+        });
+
+        return promisedSketch((sketch, resolve, reject) => {
+          sketch.preload = () => {
+            target.testPreloadLegacy();
+            setTimeout(resolve, 10);
+          };
+
+          sketch.setup = () => {
+            reject('Sketch should not enter setup');
+          };
+        });
+      });
+
+      test('Extension legacy preload returns objects correctly', async () => {
+        let testItem = {
+          test: true,
+          otherTest: []
+        };
+        const target = {
+          async testPreloadFunction() {
+            return testItem;
+          }
+        };
+
+        p5.prototype._promisePreloads.push({
+          target,
+          method: 'testPreloadFunction',
+          legacyPreloadSetup: {
+            method: 'testPreloadLegacy'
+          }
+        });
+
+        let testResult;
+
+        await promisedSketch((sketch, resolve, reject) => {
+          sketch.preload = () => {
+            testResult = target.testPreloadLegacy();
+          };
+
+          sketch.setup = resolve();
+        });
+
+        assert.deepEqual(testResult, testItem);
+      });
+
+      test('Extension legacy preload returns arrays correctly', async () => {
+        let testItem = [true, [], {}];
+        const target = {
+          async testPreloadFunction() {
+            return testItem;
+          }
+        };
+
+        p5.prototype._promisePreloads.push({
+          target,
+          method: 'testPreloadFunction',
+          legacyPreloadSetup: {
+            method: 'testPreloadLegacy',
+            createBaseObject: () => []
+          }
+        });
+
+        let testResult;
+
+        await promisedSketch((sketch, resolve, reject) => {
+          sketch.preload = () => {
+            testResult = target.testPreloadLegacy();
+          };
+
+          sketch.setup = resolve();
+        });
+
+        assert.deepEqual(testResult, testItem);
+      });
+    });
+  });
+});

package/p5-tests/unit/core/rendering.js

@@ -0,0 +1,116 @@
+suite('Rendering', function() {
+  var myp5;
+
+  setup(function(done) {
+    new p5(function(p) {
+      p.setup = function() {
+        myp5 = p;
+        done();
+      };
+    });
+  });
+
+  teardown(function() {
+    myp5.remove();
+  });
+
+  suite('p5.prototype.createCanvas', function() {
+    test('should have correct initial colors', function() {
+      var white = myp5.color(255, 255, 255).levels;
+      var black = myp5.color(0, 0, 0).levels;
+      assert.deepEqual(myp5.color(myp5._renderer._getFill()).levels, white);
+      assert.deepEqual(myp5.color(myp5._renderer._getStroke()).levels, black);
+      assert.deepEqual(myp5.color(myp5.drawingContext.fillStyle).levels, white);
+      assert.deepEqual(
+        myp5.color(myp5.drawingContext.strokeStyle).levels,
+        black
+      );
+      myp5.createCanvas(100, 100);
+      assert.deepEqual(myp5.color(myp5._renderer._getFill()).levels, white);
+      assert.deepEqual(myp5.color(myp5._renderer._getStroke()).levels, black);
+      assert.deepEqual(myp5.color(myp5.drawingContext.fillStyle).levels, white);
+      assert.deepEqual(
+        myp5.color(myp5.drawingContext.strokeStyle).levels,
+        black
+      );
+    });
+  });
+
+  suite('p5.prototype.resizeCanvas', function() {
+    // let glStub;
+
+    // afterEach(() => {
+    //   if (glStub) {
+    //     glStub.restore();
+    //     glStub = null;
+    //   }
+    // });
+
+    test('should resize canvas', function() {
+      myp5.resizeCanvas(10, 20);
+      assert.equal(myp5.canvas.width, 10 * myp5.pixelDensity());
+      assert.equal(myp5.canvas.height, 20 * myp5.pixelDensity());
+    });
+
+    test('should restore fill color', function() {
+      myp5.fill('#f0f0f0');
+      myp5.resizeCanvas(10, 10);
+      assert.equal(myp5.drawingContext.fillStyle, '#f0f0f0');
+    });
+
+    test('should restore stroke color', function() {
+      myp5.stroke('#f0f0f0');
+      myp5.resizeCanvas(10, 10);
+      assert.equal(myp5.drawingContext.strokeStyle, '#f0f0f0');
+    });
+
+    test('should restore stroke weight', function() {
+      myp5.strokeWeight(323);
+      myp5.resizeCanvas(10, 10);
+      assert.equal(myp5.drawingContext.lineWidth, 323);
+    });
+
+    test('should restore stroke cap', function() {
+      myp5.strokeCap(myp5.PROJECT);
+      myp5.resizeCanvas(10, 10);
+      assert.equal(myp5.drawingContext.lineCap, myp5.PROJECT);
+    });
+  });
+
+  suite('p5.prototype.blendMode', function() {
+    var drawX = function() {
+      myp5.strokeWeight(30);
+      myp5.stroke(80, 150, 255);
+      myp5.line(25, 25, 75, 75);
+      myp5.stroke(255, 50, 50);
+      myp5.line(75, 25, 25, 75);
+    };
+    test('should be a function', function() {
+      assert.ok(myp5.blendMode);
+      assert.typeOf(myp5.blendMode, 'function');
+    });
+    test('should be able to ADD', function() {
+      myp5.blendMode(myp5.ADD);
+      drawX();
+    });
+    test('should be able to MULTIPLY', function() {
+      myp5.blendMode(myp5.MULTIPLY);
+      drawX();
+    });
+  });
+
+  suite('p5.prototype.setAttributes', function() {
+    test('_glAttributes should be null at start', function() {
+      assert.deepEqual(myp5._glAttributes, null);
+    });
+    test('_glAttributes should modify with setAttributes', function() {
+      myp5.setAttributes({ antialias: false, perPixelLighting: true });
+      assert.deepEqual(myp5._glAttributes.antialias, false);
+      assert.deepEqual(myp5._glAttributes.perPixelLighting, true);
+    });
+    test('_glAttributes.antialias modify with smooth()', function() {
+      myp5.smooth();
+      assert.deepEqual(myp5._glAttributes.antialias, true);
+    });
+  });
+});