utilities/conversion.js: add unit tests

Author: ihsavru

src/utilities/conversion.js

@@ -122,7 +122,7 @@ p5.prototype.str = function(n) {
  * print(boolean(1)); // true
  * print(boolean('true')); // true
  * print(boolean('abcd')); // false
- * print(boolean([0, 12, 'true'])); // [false, true, false]
+ * print(boolean([0, 12, 'true'])); // [false, true, true]
  * </code></div>
  */
 p5.prototype.boolean = function(n) {

test/unit/utilities/conversion.js

@@ -0,0 +1,313 @@
+suite.only('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 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 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 Infinity for Infinity', function() {
+      result = myp5.hex(Infinity);
+      assert.typeOf(result, 'Number');
+      assert.strictEqual(result, Infinity);
+    });
+
+    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('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]);
+    });
+  });
+});