q5 2.9.22 → 2.9.23

package/p5-tests/unit/core/2d_primitives.js

@@ -0,0 +1,490 @@
+suite('2D Primitives', function() {
+  var myp5;
+
+  setup(function(done) {
+    new p5(function(p) {
+      p.setup = function() {
+        myp5 = p;
+        done();
+      };
+    });
+  });
+
+  teardown(function() {
+    myp5.remove();
+  });
+
+  suite('p5.prototype.arc', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.arc);
+      assert.typeOf(myp5.arc, 'function');
+    });
+    test('no friendly-err-msg', function() {
+      assert.doesNotThrow(
+        function() {
+          myp5.arc(1, 1, 10.5, 10, 0, Math.PI, 'pie');
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('missing param #4, #5', function() {
+      assert.validationError(function() {
+        myp5.arc(1, 1, 10.5, 10);
+      });
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.arc('a', 1, 10.5, 10, 0, Math.PI, 'pie');
+      });
+    });
+  });
+
+  suite('p5.prototype.ellipse', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.ellipse);
+      assert.typeOf(myp5.ellipse, 'function');
+    });
+    test('no friendly-err-msg', function() {
+      assert.doesNotThrow(
+        function() {
+          myp5.ellipse(0, 0, 100);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('missing param #2', function() {
+      assert.validationError(function() {
+        myp5.ellipse(0, 0);
+      });
+    });
+    test('missing param #2', function() {
+      assert.validationError(function() {
+        var size;
+        myp5.ellipse(0, 0, size);
+      });
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.ellipse('a', 0, 100, 100);
+      });
+    });
+  });
+
+  suite('p5.prototype.line', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.line);
+      assert.typeOf(myp5.line, 'function');
+    });
+    test('no friendly-err-msg, 2D', function() {
+      assert.doesNotThrow(
+        function() {
+          myp5.line(0, 0, 100, 100);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('no friendly-err-msg, 3D', function() {
+      assert.doesNotThrow(
+        function() {
+          myp5.line(0, 0, 100, 100, 20, Math.PI);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('missing param #3', function() {
+      assert.validationError(function() {
+        myp5.line(0, 0, Math.PI);
+      });
+    });
+    test('missing param #4 ', function() {
+      // this err case escapes
+      assert.validationError(function() {
+        var x3;
+        myp5.line(0, 0, 100, 100, x3, Math.PI);
+      });
+    });
+    test('wrong param type at #1', function() {
+      assert.validationError(function() {
+        myp5.line(0, 'a', 100, 100);
+      });
+    });
+  });
+
+  suite('p5.prototype.point', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.point);
+      assert.typeOf(myp5.point, 'function');
+    });
+    test('no friendly-err-msg, 2D', function() {
+      assert.doesNotThrow(
+        function() {
+          myp5.point(Math.PI, 0);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('no friendly-err-msg, 3D', function() {
+      assert.doesNotThrow(
+        function() {
+          myp5.point(Math.PI, 0, 100);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('missing param #1', function() {
+      assert.validationError(function() {
+        myp5.point(0);
+      });
+    });
+    /* this is not an error because 2d point exists.
+    test('missing param #3', function() {
+      // this err case escapes
+      assert.validationError(function() {
+        var z;
+        myp5.point(0, Math.PI, z);
+      });
+    });
+    */
+    test('wrong param type at #1', function() {
+      assert.validationError(function() {
+        myp5.point(Math.PI, 'a');
+      });
+    });
+  });
+
+  suite('p5.prototype.quad', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.quad);
+      assert.typeOf(myp5.quad, 'function');
+    });
+    test('no friendly-err-msg, 2D', function() {
+      assert.doesNotThrow(
+        function() {
+          myp5.quad(Math.PI, 0, Math.PI, 5.1, 10, 5.1, 10, 0);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('missing param #7', function() {
+      assert.validationError(function() {
+        myp5.quad(Math.PI, 0, Math.PI, 5.1, 10, 5.1, 10);
+      });
+    });
+    test('wrong param type at #1', function() {
+      assert.validationError(function() {
+        myp5.quad(Math.PI, 'a', Math.PI, 5.1, 10, 5.1, 10, 0);
+      });
+    });
+  });
+
+  suite('p5.prototype.rect', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.rect);
+      assert.typeOf(myp5.rect, 'function');
+    });
+    test('no friendly-err-msg, format I', function() {
+      assert.doesNotThrow(
+        function() {
+          myp5.rect(0, 0, 100);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('no friendly-err-msg, format II', function() {
+      assert.doesNotThrow(
+        function() {
+          myp5.rect(0, 0, 100, 100, 1, Math.PI, 1, Math.PI);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('missing param #4', function() {
+      // this err case escapes
+      assert.validationError(function() {
+        var r1;
+        myp5.rect(0, 0, 100, 100, r1, Math.PI, 1, Math.PI);
+      });
+    });
+    test('wrong param type at #1', function() {
+      assert.validationError(function() {
+        myp5.rect(0, 'a', 100, 100);
+      });
+    });
+  });
+
+  suite('p5.prototype.triangle', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.triangle);
+      assert.typeOf(myp5.triangle, 'function');
+    });
+    test('no friendly-err-msg', function() {
+      assert.doesNotThrow(
+        function() {
+          myp5.triangle(Math.PI, 0, Math.PI, 5.1, 10, 5.1);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('missing param #5', function() {
+      assert.validationError(function() {
+        myp5.triangle(Math.PI, 0, Math.PI, 5.1, 10);
+      });
+    });
+    test('wrong param type at #1', function() {
+      assert.validationError(function() {
+        myp5.triangle(Math.PI, 'a', Math.PI, 5.1, 10, 5.1);
+      });
+    });
+  });
+  suite('p5.prototype.square', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.square);
+      assert.typeOf(myp5.square, 'function');
+    });
+    test('no friendly-err-msg, format I', function() {
+      assert.doesNotThrow(
+        function() {
+          myp5.square(0, 0, 100);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('no friendly-err-msg, format II', function() {
+      assert.doesNotThrow(
+        function() {
+          myp5.square(0, 0, 100, 100, Math.PI);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('missing param #2', function() {
+      assert.validationError(function() {
+        myp5.square(0, 0);
+      });
+    });
+    test('wrong param type at #1', function() {
+      assert.validationError(function() {
+        myp5.square(0, 'a', 100);
+      });
+    });
+  });
+
+  suite('p5.prototype._normalizeArcAngles', function() {
+    test('start/stop both at zero', function() {
+      var i, j, angles;
+      for (i = -2; i <= 2; i++) {
+        for (j = -2; j <= 2; j++) {
+          angles = myp5._normalizeArcAngles(
+            2 * Math.PI * i,
+            2 * Math.PI * j,
+            500,
+            5,
+            false
+          );
+          assert.approximately(angles.start, 0, 0.000005);
+          assert.approximately(angles.stop, 0, 0.000005);
+          assert.isTrue(angles.correspondToSamePoint);
+        }
+      }
+    });
+    test('start/stop same but non-zero', function() {
+      var i, j, angles;
+      for (i = -2; i <= 2; i++) {
+        for (j = -2; j <= 2; j++) {
+          angles = myp5._normalizeArcAngles(
+            2 * Math.PI * i + 1,
+            2 * Math.PI * j + 1,
+            500,
+            5,
+            false
+          );
+          assert.approximately(angles.start, 1, 0.000005);
+          assert.approximately(angles.stop, 1, 0.000005);
+          assert.isTrue(angles.correspondToSamePoint);
+        }
+      }
+    });
+    test('start/stop both close to zero, start < stop', function() {
+      var i, j, angles;
+      for (i = -2; i <= 2; i++) {
+        for (j = -2; j <= 2; j++) {
+          angles = myp5._normalizeArcAngles(
+            2 * Math.PI * i - 0.000001,
+            2 * Math.PI * j + 0.000001,
+            500,
+            5,
+            false
+          );
+          assert.approximately(angles.start, 2 * Math.PI - 0.000001, 0.000005);
+          assert.approximately(angles.stop, 2 * Math.PI + 0.000001, 0.000005);
+          assert.isTrue(angles.correspondToSamePoint);
+        }
+      }
+    });
+    test('start/stop both close to zero, start > stop', function() {
+      var i, j, angles;
+      for (i = -2; i <= 2; i++) {
+        for (j = -2; j <= 2; j++) {
+          angles = myp5._normalizeArcAngles(
+            2 * Math.PI * i + 0.000001,
+            2 * Math.PI * j - 0.000001,
+            500,
+            5,
+            false
+          );
+          assert.approximately(angles.start, 0.000001, 0.000005);
+          assert.approximately(angles.stop, 2 * Math.PI - 0.000001, 0.000005);
+          assert.isTrue(angles.correspondToSamePoint);
+        }
+      }
+    });
+    test('start/stop both close to same non-zero, start < stop', function() {
+      var i, j, angles;
+      for (i = -2; i <= 2; i++) {
+        for (j = -2; j <= 2; j++) {
+          angles = myp5._normalizeArcAngles(
+            2 * Math.PI * i + 0.999999,
+            2 * Math.PI * j + 1.000001,
+            500,
+            5,
+            false
+          );
+          assert.approximately(angles.start, 0.999999, 0.000005);
+          assert.approximately(angles.stop, 1.000001, 0.000005);
+          assert.isTrue(angles.correspondToSamePoint);
+        }
+      }
+    });
+    test('start/stop both close to same non-zero, start > stop', function() {
+      var i, j, angles;
+      for (i = -2; i <= 2; i++) {
+        for (j = -2; j <= 2; j++) {
+          angles = myp5._normalizeArcAngles(
+            2 * Math.PI * i + 1.000001,
+            2 * Math.PI * j + 0.999999,
+            500,
+            5,
+            false
+          );
+          assert.approximately(angles.start, 1.000001, 0.000005);
+          assert.approximately(angles.stop, 2 * Math.PI + 0.999999, 0.000005);
+          assert.isTrue(angles.correspondToSamePoint);
+        }
+      }
+    });
+    test('start/stop around zero but not close, start < stop', function() {
+      var i, j, angles;
+      for (i = -2; i <= 2; i++) {
+        for (j = -2; j <= 2; j++) {
+          angles = myp5._normalizeArcAngles(
+            2 * Math.PI * i - 0.1,
+            2 * Math.PI * j + 0.1,
+            500,
+            5,
+            false
+          );
+          assert.approximately(angles.start, 2 * Math.PI - 0.1, 0.000005);
+          assert.approximately(angles.stop, 2 * Math.PI + 0.1, 0.000005);
+          assert.isFalse(angles.correspondToSamePoint);
+        }
+      }
+    });
+    test('start/stop around zero but not close, start > stop', function() {
+      var i, j, angles;
+      for (i = -2; i <= 2; i++) {
+        for (j = -2; j <= 2; j++) {
+          angles = myp5._normalizeArcAngles(
+            2 * Math.PI * i + 0.1,
+            2 * Math.PI * j - 0.1,
+            500,
+            5,
+            false
+          );
+          assert.approximately(angles.start, 0.1, 0.000005);
+          assert.approximately(angles.stop, 2 * Math.PI - 0.1, 0.000005);
+          assert.isFalse(angles.correspondToSamePoint);
+        }
+      }
+    });
+    test('start/stop away from zero and not close, start < stop', function() {
+      var i, j, angles;
+      for (i = -2; i <= 2; i++) {
+        for (j = -2; j <= 2; j++) {
+          angles = myp5._normalizeArcAngles(
+            2 * Math.PI * i + 0.9,
+            2 * Math.PI * j + 1.1,
+            500,
+            5,
+            false
+          );
+          assert.approximately(angles.start, 0.9, 0.000005);
+          assert.approximately(angles.stop, 1.1, 0.000005);
+          assert.isFalse(angles.correspondToSamePoint);
+        }
+      }
+    });
+    test('start/stop away from zero and not close, start > stop', function() {
+      var i, j, angles;
+      for (i = -2; i <= 2; i++) {
+        for (j = -2; j <= 2; j++) {
+          angles = myp5._normalizeArcAngles(
+            2 * Math.PI * i + 1.1,
+            2 * Math.PI * j + 0.9,
+            500,
+            5,
+            false
+          );
+          assert.approximately(angles.start, 1.1, 0.000005);
+          assert.approximately(angles.stop, 2 * Math.PI + 0.9, 0.000005);
+          assert.isFalse(angles.correspondToSamePoint);
+        }
+      }
+    });
+    test('scaling correction, quadrants 1 and 3', function() {
+      var i, j, angles;
+      for (i = -2; i <= 2; i++) {
+        for (j = -2; j <= 2; j++) {
+          angles = myp5._normalizeArcAngles(
+            2 * Math.PI * (i + 40 / 360),
+            2 * Math.PI * (j + 230 / 360),
+            500,
+            5,
+            true
+          );
+          assert.approximately(angles.start, 1.558879, 0.000005);
+          assert.approximately(angles.stop, 4.703998, 0.000005);
+          assert.isFalse(angles.correspondToSamePoint);
+        }
+      }
+    });
+    test('scaling correction, quadrants 2 and 4', function() {
+      var i, j, angles;
+      for (i = -2; i <= 2; i++) {
+        for (j = -2; j <= 2; j++) {
+          angles = myp5._normalizeArcAngles(
+            2 * Math.PI * (i + 320 / 360),
+            2 * Math.PI * (j + 130 / 360),
+            500,
+            5,
+            true
+          );
+          assert.approximately(angles.start, 4.724306, 0.000005);
+          assert.approximately(angles.stop, 7.862372, 0.000005);
+          assert.isFalse(angles.correspondToSamePoint);
+        }
+      }
+    });
+  });
+});

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

@@ -0,0 +1,115 @@
+suite('Attributes', function() {
+  var myp5;
+
+  setup(function(done) {
+    new p5(function(p) {
+      p.setup = function() {
+        myp5 = p;
+        done();
+      };
+    });
+  });
+
+  teardown(function() {
+    myp5.remove();
+  });
+
+  suite('p5.prototype.ellipseMode', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.ellipseMode);
+      assert.typeOf(myp5.ellipseMode, 'function');
+    });
+    test('missing param #0', function() {
+      assert.validationError(function() {
+        myp5.ellipseMode();
+      });
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.ellipseMode(myp5.BEVEL);
+      });
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.ellipseMode(20);
+      });
+    });
+  });
+
+  suite('p5.prototype.rectMode', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.rectMode);
+      assert.typeOf(myp5.rectMode, 'function');
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.rectMode(myp5.MITER);
+      });
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.rectMode(64);
+      });
+    });
+  });
+
+  suite('p5.prototype.noSmooth', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.noSmooth);
+      assert.typeOf(myp5.noSmooth, 'function');
+    });
+  });
+
+  suite('p5.prototype.smooth', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.smooth);
+      assert.typeOf(myp5.smooth, 'function');
+    });
+  });
+
+  suite('p5.prototype.strokeCap', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.strokeCap);
+      assert.typeOf(myp5.strokeCap, 'function');
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.strokeCap(myp5.CORNER);
+      });
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.strokeCap(40);
+      });
+    });
+  });
+
+  suite('p5.prototype.strokeJoin', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.strokeJoin);
+      assert.typeOf(myp5.strokeJoin, 'function');
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.strokeJoin(myp5.CORNER);
+      });
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.strokeJoin(35);
+      });
+    });
+  });
+
+  suite('p5.prototype.strokeWeight', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.strokeWeight);
+      assert.typeOf(myp5.strokeWeight, 'function');
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        myp5.strokeWeight('a');
+      });
+    });
+  });
+});