q5 2.9.21 → 2.9.23

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

@@ -0,0 +1,293 @@
+suite('Structure', function() {
+  var myp5;
+
+  setup(function(done) {
+    new p5(function(p) {
+      p.setup = function() {
+        myp5 = p;
+        done();
+      };
+    });
+  });
+
+  teardown(function() {
+    myp5.remove();
+  });
+
+  suite('p5.prototype.loop and p5.prototype.noLoop', function() {
+    test('noLoop should stop', function() {
+      return new Promise(function(resolve, reject) {
+        var c0 = myp5.frameCount;
+        myp5.noLoop();
+        myp5.draw = function() {
+          var c1 = myp5.frameCount;
+          // Allow one final draw to run
+          if (c1 > c0 + 1) {
+            reject('Entered draw');
+          }
+        };
+        setTimeout(resolve, 100);
+      });
+    });
+
+    test('loop should restart', function() {
+      return new Promise(function(resolve, reject) {
+        var c0 = myp5.frameCount;
+        myp5.noLoop();
+        myp5.draw = function() {
+          var c1 = myp5.frameCount;
+          // Allow one final draw to run
+          if (c1 > c0 + 1) {
+            reject('Entered draw');
+          }
+        };
+        setTimeout(resolve, 100);
+      }).then(function() {
+        return new Promise(function(resolve, reject) {
+          myp5.draw = resolve;
+          myp5.loop();
+          setTimeout(function() {
+            reject('Failed to restart draw.');
+          }, 100);
+        });
+      });
+    });
+  });
+
+  suite('p5.prototype.push and p5.prototype.pop', function() {
+    function getRenderState() {
+      var state = {};
+      for (var key in myp5._renderer) {
+        var value = myp5._renderer[key];
+        if (
+          typeof value !== 'function' &&
+          key !== '_cachedFillStyle' &&
+          key !== '_cachedStrokeStyle'
+        ) {
+          state[key] = value;
+        }
+      }
+      return state;
+    }
+
+    function assertCanPreserveRenderState(work) {
+      var originalState = getRenderState();
+      myp5.push();
+      work();
+      myp5.pop();
+      assert.deepEqual(getRenderState(), originalState);
+    }
+
+    test('leak no state after fill()', function() {
+      myp5.noFill();
+      assertCanPreserveRenderState(function() {
+        myp5.fill('red');
+      });
+    });
+
+    test('leak no state after noFill()', function() {
+      myp5.fill('red');
+      assertCanPreserveRenderState(function() {
+        myp5.noFill();
+      });
+    });
+
+    test('leak no state after stroke()', function() {
+      myp5.noStroke();
+      assertCanPreserveRenderState(function() {
+        myp5.stroke('red');
+      });
+    });
+
+    test('leak no state after noStroke()', function() {
+      myp5.stroke('red');
+      assertCanPreserveRenderState(function() {
+        myp5.noStroke();
+      });
+    });
+
+    test('leak no state after tint()', function() {
+      myp5.noTint();
+      assertCanPreserveRenderState(function() {
+        myp5.tint(255, 0, 0);
+      });
+    });
+
+    test('leak no state after noTint()', function() {
+      myp5.tint(255, 0, 0);
+      assertCanPreserveRenderState(function() {
+        myp5.noTint();
+      });
+    });
+
+    test('leak no state after strokeWeight()', function() {
+      myp5.strokeWeight(1);
+      assertCanPreserveRenderState(function() {
+        myp5.strokeWeight(10);
+      });
+    });
+
+    test('leak no state after strokeCap()', function() {
+      myp5.strokeCap(myp5.ROUND);
+      assertCanPreserveRenderState(function() {
+        myp5.strokeCap(myp5.SQUARE);
+      });
+    });
+
+    test('leak no state after strokeJoin()', function() {
+      myp5.strokeJoin(myp5.BEVEL);
+      assertCanPreserveRenderState(function() {
+        myp5.strokeJoin(myp5.MITER);
+      });
+    });
+
+    test('leak no state after imageMode()', function() {
+      myp5.imageMode(myp5.CORNER);
+      assertCanPreserveRenderState(function() {
+        myp5.imageMode(myp5.CENTER);
+      });
+    });
+
+    test('leak no state after rectMode()', function() {
+      myp5.rectMode(myp5.CORNER);
+      assertCanPreserveRenderState(function() {
+        myp5.rectMode(myp5.CENTER);
+      });
+    });
+
+    test('leak no state after ellipseMode()', function() {
+      myp5.ellipseMode(myp5.CORNER);
+      assertCanPreserveRenderState(function() {
+        myp5.ellipseMode(myp5.CENTER);
+      });
+    });
+
+    test('leak no state after colorMode()', function() {
+      myp5.colorMode(myp5.HSB);
+      assertCanPreserveRenderState(function() {
+        myp5.colorMode(myp5.RGB);
+      });
+    });
+
+    test('leak no state after textAlign()', function() {
+      myp5.textAlign(myp5.RIGHT, myp5.BOTTOM);
+      assertCanPreserveRenderState(function() {
+        myp5.textAlign(myp5.CENTER, myp5.CENTER);
+      });
+    });
+
+    test('leak no state after textFont()', function() {
+      myp5.textFont('Georgia');
+      assertCanPreserveRenderState(function() {
+        myp5.textFont('Helvetica');
+      });
+    });
+
+    test('leak no state after textStyle()', function() {
+      myp5.textStyle(myp5.ITALIC);
+      assertCanPreserveRenderState(function() {
+        myp5.textStyle(myp5.BOLD);
+      });
+    });
+
+    test('leak no state after textSize()', function() {
+      myp5.textSize(12);
+      assertCanPreserveRenderState(function() {
+        myp5.textSize(16);
+      });
+    });
+
+    test('leak no state after textLeading()', function() {
+      myp5.textLeading(20);
+      assertCanPreserveRenderState(function() {
+        myp5.textLeading(30);
+      });
+    });
+  });
+
+  suite('p5.prototype.redraw', function() {
+    var iframe;
+
+    teardown(function() {
+      if (iframe) {
+        iframe.teardown();
+        iframe = null;
+      }
+    });
+
+    test('resets the rendering matrix between frames', function() {
+      return new Promise(function(resolve, reject) {
+        myp5.draw = function() {
+          myp5.background(0);
+          myp5.stroke(255);
+          myp5.point(10, 10);
+          if (myp5.get(10, 10)[0] === 0) {
+            reject(new Error("Drawing matrix doesn't appear to be reset"));
+          }
+          myp5.rotate(10);
+        };
+        myp5.redraw(10);
+        resolve();
+      });
+    });
+
+    test('instance redraw is independent of window', function() {
+      // callback for p5 instance mode.
+      // It does not call noLoop so redraw will be called many times.
+      // Redraw is not supposed to call window.draw even though no draw is defined in cb
+      function cb(s) {
+        s.setup = function() {
+          setTimeout(window.afterSetup, 1000);
+        };
+      }
+      return new Promise(function(resolve) {
+        iframe = createP5Iframe(
+          [
+            P5_SCRIPT_TAG,
+            '<script>',
+            'globalDraws = 0;',
+            'function setup() { noLoop(); }',
+            'function draw() { window.globalDraws++; }',
+            'new p5(' + cb.toString() + ');',
+            '</script>'
+          ].join('\n')
+        );
+        iframe.elt.contentWindow.afterSetup = resolve;
+      }).then(function() {
+        var win = iframe.elt.contentWindow;
+        assert.strictEqual(win.globalDraws, 1);
+      });
+    });
+  });
+
+  suite('loop', function() {
+    testSketchWithPromise('loop in setup does not call draw', function(
+      sketch,
+      resolve,
+      reject
+    ) {
+      sketch.setup = function() {
+        sketch.loop();
+        resolve();
+      };
+
+      sketch.draw = function() {
+        reject(new Error('Entered draw during loop()'));
+      };
+    });
+
+    testSketchWithPromise('loop in draw does not call draw', function(
+      sketch,
+      resolve,
+      reject
+    ) {
+      sketch.draw = function() {
+        if (sketch.frameCount > 1) {
+          reject(new Error('re-entered draw during loop() call'));
+        }
+        sketch.loop();
+        resolve();
+      };
+    });
+  });
+});

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

@@ -0,0 +1,144 @@
+suite('Transform', function() {
+  var sketch1; // sketch without WEBGL Mode
+  var sketch2; // skecth with WEBGL mode
+  setup(function(done) {
+    new p5(function(p) {
+      p.setup = function() {
+        sketch1 = p;
+      };
+    });
+    new p5(function(p) {
+      p.setup = function() {
+        p.createCanvas(100, 100, p.WEBGL);
+        sketch2 = p;
+      };
+    });
+    done();
+  });
+
+  teardown(function() {
+    sketch1.remove();
+    sketch2.remove();
+  });
+
+  suite('p5.prototype.rotate', function() {
+    test('should be a function', function() {
+      assert.ok(sketch1.rotate);
+      assert.typeOf(sketch1.rotate, 'function');
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        sketch1.rotate('a');
+      });
+    });
+    test('wrong param type at #1', function() {
+      assert.validationError(function() {
+        sketch1.rotate(sketch1.PI, 'x');
+      });
+    });
+  });
+
+  suite('p5.prototype.rotateX', function() {
+    test('should be a function', function() {
+      assert.ok(sketch1.rotateX);
+      assert.typeOf(sketch1.rotateX, 'function');
+    });
+    test('throws error. should be used in WEBGL mode', function() {
+      assert.throws(function() {
+        sketch1.rotateX(100);
+      }, Error);
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        sketch2.rotateX('x');
+      });
+    });
+  });
+
+  suite('p5.prototype.rotateY', function() {
+    test('should be a function', function() {
+      assert.ok(sketch1.rotateY);
+      assert.typeOf(sketch1.rotateY, 'function');
+    });
+    test('throws error. should be used in WEBGL mode', function() {
+      assert.throws(function() {
+        sketch1.rotateY(100);
+      }, Error);
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        sketch2.rotateY('x');
+      });
+    });
+  });
+
+  suite('p5.prototype.rotateZ', function() {
+    test('should be a function', function() {
+      assert.ok(sketch1.rotateZ);
+      assert.typeOf(sketch1.rotateZ, 'function');
+    });
+    test('throws error. should be used in WEBGL mode', function() {
+      assert.throws(function() {
+        sketch1.rotateZ(100);
+      }, Error);
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        sketch2.rotateZ('x');
+      });
+    });
+  });
+
+  suite('p5.prototype.scale', function() {
+    test('should be a function', function() {
+      assert.ok(sketch1.scale);
+      assert.typeOf(sketch1.scale, 'function');
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        sketch1.scale('a');
+      });
+    });
+  });
+
+  suite('p5.prototype.shearX', function() {
+    test('should be a function', function() {
+      assert.ok(sketch1.shearX);
+      assert.typeOf(sketch1.shearX, 'function');
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        sketch1.shearX('a');
+      });
+    });
+  });
+
+  suite('p5.prototype.shearY', function() {
+    test('should be a function', function() {
+      assert.ok(sketch1.shearY);
+      assert.typeOf(sketch1.shearY, 'function');
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        sketch1.shearY('a');
+      });
+    });
+  });
+
+  suite('p5.prototype.translate', function() {
+    test('should be a function', function() {
+      assert.ok(sketch1.translate);
+      assert.typeOf(sketch1.translate, 'function');
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        sketch1.translate('a', 10);
+      });
+    });
+    test('missing param #1', function() {
+      assert.validationError(function() {
+        sketch1.translate(10);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,28 @@
+suite('Version', function() {
+  var myp5;
+
+  setup(function(done) {
+    new p5(function(p) {
+      p.setup = function() {
+        myp5 = p;
+        done();
+      };
+    });
+  });
+
+  teardown(function() {
+    myp5.remove();
+  });
+
+  test('exists on p5 object', function() {
+    assert.isString(p5.VERSION);
+    // ensure the string isn't empty
+    assert.isTrue(p5.VERSION.length > 0);
+  });
+
+  test('exists on instance of p5 sketch', function() {
+    assert.isString(myp5.VERSION);
+    // ensure the string isn't empty
+    assert.isTrue(myp5.VERSION.length > 0);
+  });
+});

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

@@ -0,0 +1,137 @@
+suite('Vertex', function() {
+  var myp5;
+  let _friendlyErrorSpy;
+  setup(function(done) {
+    _friendlyErrorSpy = sinon.spy(p5, '_friendlyError');
+    new p5(function(p) {
+      p.setup = function() {
+        myp5 = p;
+        done();
+      };
+    });
+  });
+
+  teardown(function() {
+    _friendlyErrorSpy.restore();
+    myp5.remove();
+  });
+
+  suite('p5.prototype.beginShape', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.beginShape);
+      assert.typeOf(myp5.beginShape, 'function');
+    });
+    test('no friendly-err-msg. missing param #0', function() {
+      assert.doesNotThrow(
+        function() {
+          myp5.beginShape();
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.beginShape(myp5.BEVEL);
+      });
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.beginShape(20);
+      });
+    });
+  });
+
+  suite('p5.prototype.quadraticVertex', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.quadraticVertex);
+      assert.typeOf(myp5.quadraticVertex, 'function');
+    });
+    test('missing param #3', function() {
+      assert.validationError(function() {
+        myp5.quadraticVertex(80, 20, 50);
+      });
+    });
+    test('missing param #5', function() {
+      assert.validationError(function() {
+        myp5.quadraticVertex(80, 20, 50, 50, 10);
+      });
+    });
+    test('_friendlyError is called. vertex() should be used once before quadraticVertex()', function() {
+      myp5.quadraticVertex(80, 20, 50, 50, 10, 20);
+      assert(_friendlyErrorSpy.calledOnce, 'p5._friendlyError was not called');
+    });
+  });
+
+  suite('p5.prototype.bezierVertex', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.bezierVertex);
+      assert.typeOf(myp5.bezierVertex, 'function');
+    });
+    test('missing param #6', function() {
+      assert.validationError(function() {
+        myp5.bezierVertex(25, 30, 25, -30, -25);
+      });
+    });
+    test('missing param #8-9', function() {
+      assert.validationError(function() {
+        myp5.bezierVertex(25, 30, 25, -30, -25, 30, 20);
+      });
+    });
+    test('_friendlyError is called. vertex() should be used once before bezierVertex()', function() {
+      myp5.bezierVertex(25, 30, 25, -30, -25, 30);
+      assert(_friendlyErrorSpy.calledOnce, 'p5._friendlyError was not called');
+    });
+  });
+
+  suite('p5.prototype.curveVertex', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.curveVertex);
+      assert.typeOf(myp5.curveVertex, 'function');
+    });
+    test('missing param #1', function() {
+      assert.validationError(function() {
+        myp5.curveVertex(40);
+      });
+    });
+  });
+
+  suite('p5.prototype.endShape', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.endShape);
+      assert.typeOf(myp5.endShape, 'function');
+    });
+    test('no friendly-err-msg. missing param #0', function() {
+      assert.doesNotThrow(
+        function() {
+          myp5.endShape();
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.endShape(20);
+      });
+    });
+  });
+
+  suite('p5.prototype.vertex', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.vertex);
+      assert.typeOf(myp5.vertex, 'function');
+    });
+    // p5.prototype.vertex parameter validation is absent
+    test.skip('missing param #1', function() {
+      assert.validationError(function() {
+        myp5.vertex(10);
+      });
+    });
+    test.skip('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.vertex('a', 1);
+      });
+    });
+  });
+});