q5 2.9.21 → 2.9.23

package/p5-tests/unit/utilities/conversion.js

@@ -0,0 +1,329 @@
+suite('Conversion', function() {
+  var myp5;
+
+  setup(function(done) {
+    new p5(function(p) {
+      p.setup = function() {
+        myp5 = p;
+        done();
+      };
+    });
+  });
+
+  teardown(function() {
+    myp5.remove();
+  });
+
+  var result;
+
+  suite('p5.prototype.float', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.float);
+      assert.typeOf(myp5.float, 'function');
+    });
+
+    test('should convert a string to its floating point representation', function() {
+      result = myp5.float('56.99998');
+      assert.typeOf(result, 'Number');
+      assert.strictEqual(result, 56.99998);
+    });
+
+    test('should return NaN for invalid string', function() {
+      result = myp5.float('cat');
+      assert.isNaN(result);
+    });
+
+    test('should return Infinity for Infinity', function() {
+      result = myp5.float(Infinity);
+      assert.strictEqual(result, Infinity);
+    });
+
+    test('should return -Infinity for -Infinity', function() {
+      result = myp5.float(-Infinity);
+      assert.strictEqual(result, -Infinity);
+    });
+
+    test('should return array of floating points and Nan', function() {
+      result = myp5.float(['1', '2.0', '3.1', 'giraffe']);
+      assert.typeOf(result, 'Array');
+      assert.deepEqual(result, [1, 2.0, 3.1, NaN]);
+    });
+  });
+
+  suite('p5.prototype.int', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.int);
+      assert.typeOf(myp5.int, 'function');
+    });
+
+    test('should convert false to its integer representation i.e. 0', function() {
+      result = myp5.int(false);
+      assert.typeOf(result, 'Number');
+      assert.strictEqual(result, 0);
+    });
+
+    test('should convert true to its integer representation i.e. 1', function() {
+      result = myp5.int(true);
+      assert.strictEqual(result, 1);
+    });
+
+    test('should convert a string to its integer representation', function() {
+      result = myp5.int('1001');
+      assert.strictEqual(result, 1001);
+    });
+
+    test('should return NaN for invalid string', function() {
+      result = myp5.int('cat');
+      assert.isNaN(result);
+    });
+
+    test('should return Infinity for Infinity', function() {
+      result = myp5.int(Infinity);
+      assert.strictEqual(result, Infinity);
+    });
+
+    test('should return -Infinity for -Infinity', function() {
+      result = myp5.int(-Infinity);
+      assert.strictEqual(result, -Infinity);
+    });
+
+    test('should convert float to its integer representation', function() {
+      result = myp5.int('-1001.9');
+      assert.strictEqual(result, -1001);
+    });
+
+    test('should return array of integers and NaN', function() {
+      result = myp5.int(['1', '2.3', '-3.5', 'giraffe', false, 4.7]);
+      assert.typeOf(result, 'Array');
+      assert.deepEqual(result, [1, 2, -3, NaN, 0, 4]);
+    });
+  });
+
+  suite('p5.prototype.str', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.str);
+      assert.typeOf(myp5.str, 'function');
+    });
+
+    test('should convert false to string', function() {
+      result = myp5.str(false);
+      assert.typeOf(result, 'String');
+      assert.strictEqual(result, 'false');
+    });
+
+    test('should convert true to string', function() {
+      result = myp5.str(true);
+      assert.strictEqual(result, 'true');
+    });
+
+    test('should convert a number to string', function() {
+      result = myp5.str(45);
+      assert.strictEqual(result, '45');
+    });
+
+    test('should return array of strings', function() {
+      result = myp5.str([1, 2.3, true, -4.5]);
+      assert.typeOf(result, 'Array');
+      assert.deepEqual(result, ['1', '2.3', 'true', '-4.5']);
+    });
+  });
+
+  suite('p5.prototype.boolean', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.boolean);
+      assert.typeOf(myp5.boolean, 'function');
+    });
+
+    test('should convert 1 to true', function() {
+      result = myp5.boolean(1);
+      assert.strictEqual(result, true);
+    });
+
+    test('should convert a number to true', function() {
+      result = myp5.boolean(154);
+      assert.strictEqual(result, true);
+    });
+
+    test('should return true for Infinity', function() {
+      result = myp5.boolean(Infinity);
+      assert.strictEqual(result, true);
+    });
+
+    test('should convert 0 to false', function() {
+      result = myp5.boolean(0);
+      assert.strictEqual(result, false);
+    });
+
+    test('should convert a string to false', function() {
+      result = myp5.boolean('1');
+      assert.strictEqual(result, false);
+    });
+
+    test('should convert a string to false', function() {
+      result = myp5.boolean('0');
+      assert.strictEqual(result, false);
+    });
+
+    test('should convert "true" to true', function() {
+      result = myp5.boolean('true');
+      assert.strictEqual(result, true);
+    });
+
+    test('should return false for empty string', function() {
+      result = myp5.boolean('');
+      assert.strictEqual(result, false);
+    });
+
+    test('should return array of boolean', function() {
+      result = myp5.boolean([1, true, -4.5, Infinity, 'cat', '23']);
+      assert.typeOf(result, 'Array');
+      assert.deepEqual(result, [true, true, true, true, false, false]);
+    });
+  });
+
+  suite('p5.prototype.byte', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.byte);
+      assert.typeOf(myp5.byte, 'function');
+    });
+
+    test('should return 127 for 127', function() {
+      result = myp5.byte(127);
+      assert.strictEqual(result, 127);
+    });
+
+    test('should return -128 for 128', function() {
+      result = myp5.byte(128);
+      assert.strictEqual(result, -128);
+    });
+
+    test('should return 23 for 23.4', function() {
+      result = myp5.byte(23.4);
+      assert.strictEqual(result, 23);
+    });
+
+    test('should return 1 for true', function() {
+      result = myp5.byte(true);
+      assert.strictEqual(result, 1);
+    });
+
+    test('should return 23 for "23.4"', function() {
+      result = myp5.byte('23.4');
+      assert.strictEqual(result, 23);
+    });
+
+    test('should return NaN for invalid string', function() {
+      result = myp5.byte('cat');
+      assert.isNaN(result);
+    });
+
+    test('should return array', function() {
+      result = myp5.byte([0, 255, '100']);
+      assert.typeOf(result, 'Array');
+      assert.deepEqual(result, [0, -1, 100]);
+    });
+  });
+
+  suite('p5.prototype.char', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.char);
+      assert.typeOf(myp5.char, 'function');
+    });
+
+    test('should return the char representation of the number', function() {
+      result = myp5.char(65);
+      assert.typeOf(result, 'String');
+      assert.strictEqual(result, 'A');
+    });
+
+    test('should return the char representation of the string', function() {
+      result = myp5.char('65');
+      assert.strictEqual(result, 'A');
+    });
+
+    test('should return array', function() {
+      result = myp5.char([65, 66, '67']);
+      assert.typeOf(result, 'Array');
+      assert.deepEqual(result, ['A', 'B', 'C']);
+    });
+  });
+
+  suite('p5.prototype.unchar', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.unchar);
+      assert.typeOf(myp5.unchar, 'function');
+    });
+
+    test('should return the integer representation of char', function() {
+      result = myp5.unchar('A');
+      assert.typeOf(result, 'Number');
+      assert.strictEqual(result, 65);
+    });
+
+    test('should return array of numbers', function() {
+      result = myp5.unchar(['A', 'B', 'C']);
+      assert.typeOf(result, 'Array');
+      assert.deepEqual(result, [65, 66, 67]);
+    });
+  });
+
+  suite('p5.prototype.hex', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.hex);
+      assert.typeOf(myp5.hex, 'function');
+    });
+
+    test('should return the hex representation of the number', function() {
+      result = myp5.hex(65);
+      assert.typeOf(result, 'String');
+      assert.strictEqual(result, '00000041');
+    });
+
+    test('should return FFFFFFFF for Infinity', function() {
+      result = myp5.hex(Infinity);
+      assert.typeOf(result, 'String');
+      assert.strictEqual(result, 'FFFFFFFF');
+    });
+
+    test('should return 00000000 for -Infinity', function() {
+      result = myp5.hex(-Infinity);
+      assert.typeOf(result, 'String');
+      assert.strictEqual(result, '00000000');
+    });
+
+    test('should return array', function() {
+      result = myp5.hex([65, 66, 67]);
+      assert.typeOf(result, 'Array');
+      assert.deepEqual(result, ['00000041', '00000042', '00000043']);
+    });
+  });
+
+  suite('p5.prototype.unhex', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.unhex);
+      assert.typeOf(myp5.unchar, 'function');
+    });
+
+    test('should return the integer representation of hex', function() {
+      result = myp5.unhex('00000041');
+      assert.typeOf(result, 'Number');
+      assert.strictEqual(result, 65);
+    });
+
+    test('should return the NaN for empty string', function() {
+      result = myp5.unhex('');
+      assert.isNaN(result);
+    });
+
+    test.skip('should return the NaN for invalid hex string', function() {
+      result = myp5.unhex('cat');
+      assert.isNaN(result);
+    });
+
+    test('should return array of numbers', function() {
+      result = myp5.unhex(['00000041', '00000042', '00000043']);
+      assert.typeOf(result, 'Array');
+      assert.deepEqual(result, [65, 66, 67]);
+    });
+  });
+});

package/p5-tests/unit/utilities/time_date.js

@@ -0,0 +1,133 @@
+suite('time and date', function() {
+  var myp5;
+
+  setup(function(done) {
+    new p5(function(p) {
+      p.setup = function() {
+        myp5 = p;
+        done();
+      };
+    });
+  });
+
+  teardown(function() {
+    myp5.remove();
+  });
+
+  var result;
+
+  suite('p5.prototype.year', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.year);
+      assert.typeOf(myp5.year, 'function');
+    });
+
+    test('should return this year', function() {
+      result = myp5.year();
+      var jsYear = new Date().getFullYear();
+      assert.equal(result, jsYear);
+    });
+  });
+
+  suite('p5.prototype.day', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.day);
+      assert.typeOf(myp5.day, 'function');
+    });
+
+    test('should return todays day', function() {
+      var jsDay = new Date().getDate();
+      result = myp5.day();
+      assert.equal(result, jsDay);
+    });
+  });
+
+  suite('p5.prototype.month', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.month);
+      assert.typeOf(myp5.month, 'function');
+    });
+
+    test("should return today's month", function() {
+      result = myp5.month();
+      var jsMonth = new Date().getMonth() + 1;
+      assert.equal(result, jsMonth);
+    });
+  });
+
+  suite('p5.prototype.hour', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.hour);
+      assert.typeOf(myp5.hour, 'function');
+    });
+
+    test('should return this hour', function() {
+      var jsHour = new Date().getHours();
+      result = myp5.hour();
+      assert.equal(result, jsHour);
+    });
+  });
+
+  suite('p5.prototype.second', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.second);
+      assert.typeOf(myp5.second, 'function');
+    });
+
+    test('should return this second', function() {
+      var jsSecond = new Date().getSeconds();
+      result = myp5.second();
+      assert.equal(result, jsSecond); //(Math.abs(jsSecond - result), '==', 0, 'everything is ok'); // in my testing, found this might be off by 1 second
+    });
+  });
+
+  suite('p5.prototype.minute', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.minute);
+      assert.typeOf(myp5.minute, 'function');
+    });
+
+    test('should return a number that is this minute', function() {
+      var jsMinute = new Date().getMinutes();
+      result = myp5.minute();
+      assert.isNumber(result);
+      assert.isNumber(jsMinute);
+      assert.equal(result, jsMinute);
+    });
+  });
+
+  suite('p5.prototype.millis', function() {
+    test('should be a function', function() {
+      assert.ok(myp5.millis);
+      assert.typeOf(myp5.millis, 'function');
+    });
+
+    test('result should be a number', function() {
+      assert.isNumber(myp5.millis());
+    });
+
+    test('result should be greater than running time', function() {
+      var runningTime = 50;
+      var init_date = window.performance.now();
+      // wait :\
+      while (window.performance.now() - init_date <= runningTime) {
+        /* no-op */
+      }
+      assert.operator(myp5.millis(), '>', runningTime, 'everything is ok');
+    });
+
+    test('result should be > newResult', function() {
+      var runningTime = 50;
+      var init_date = Date.now();
+      var result = myp5.millis();
+      // wait :\
+      while (Date.now() - init_date <= runningTime) {
+        /* no-op */
+      }
+      var newResult = myp5.millis();
+      assert.operator(newResult, '>', result, 'everything is ok');
+    });
+  });
+
+  forceError();
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "q5",
-	"version": "2.9.21",
+	"version": "2.9.23",
 	"description": "A sequel to p5.js that's optimized for interactive art",
 	"author": "quinton-ashley",
 	"contributors": [