q5 2.9.22 → 2.9.23

package/p5-tests/unit/io/loadShader.js

@@ -0,0 +1,176 @@
+suite('loadShader', function() {
+  var invalidFile = '404file';
+  var vertFile = 'unit/assets/vert.glsl';
+  var fragFile = 'unit/assets/frag.glsl';
+
+  test('_friendlyFileLoadError is called', async function() {
+    const _friendlyFileLoadErrorStub = sinon.stub(p5, '_friendlyFileLoadError');
+    try {
+      await promisedSketch(function(sketch, resolve, reject) {
+        sketch.preload = function() {
+          sketch.loadShader(invalidFile, invalidFile, reject, resolve);
+        };
+      });
+      expect(
+        _friendlyFileLoadErrorStub.calledOnce,
+        'p5._friendlyFileLoadError was not called'
+      ).to.be.true;
+    } finally {
+      _friendlyFileLoadErrorStub.restore();
+    }
+  });
+
+  testSketchWithPromise('error with vert prevents sketch continuing', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    sketch.preload = function() {
+      sketch.loadShader(invalidFile, fragFile);
+      setTimeout(resolve, 50);
+    };
+
+    sketch.setup = function() {
+      reject(new Error('Setup called'));
+    };
+
+    sketch.draw = function() {
+      reject(new Error('Draw called'));
+    };
+  });
+
+  testSketchWithPromise('error with frag prevents sketch continuing', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    sketch.preload = function() {
+      sketch.loadShader(vertFile, invalidFile);
+      setTimeout(resolve, 50);
+    };
+
+    sketch.setup = function() {
+      reject(new Error('Setup called'));
+    };
+
+    sketch.draw = function() {
+      reject(new Error('Draw called'));
+    };
+  });
+
+  testSketchWithPromise('error callback is called for vert', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    sketch.preload = function() {
+      sketch.loadShader(
+        invalidFile,
+        fragFile,
+        function() {
+          reject(new Error('Success callback executed.'));
+        },
+        function() {
+          // Wait a bit so that if both callbacks are executed we will get an error.
+          setTimeout(resolve, 50);
+        }
+      );
+    };
+  });
+
+  testSketchWithPromise('error callback is called for frag', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    sketch.preload = function() {
+      sketch.loadShader(
+        vertFile,
+        invalidFile,
+        function() {
+          reject(new Error('Success callback executed.'));
+        },
+        function() {
+          // Wait a bit so that if both callbacks are executed we will get an error.
+          setTimeout(resolve, 50);
+        }
+      );
+    };
+  });
+
+  testSketchWithPromise('loading correctly triggers setup', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    sketch.preload = function() {
+      sketch.loadShader(vertFile, fragFile);
+    };
+
+    sketch.setup = function() {
+      resolve();
+    };
+  });
+
+  testSketchWithPromise('success callback is called', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    var hasBeenCalled = false;
+    sketch.preload = function() {
+      sketch.loadShader(
+        vertFile,
+        fragFile,
+        function() {
+          hasBeenCalled = true;
+        },
+        function(err) {
+          reject(new Error('Error callback was entered: ' + err));
+        }
+      );
+    };
+
+    sketch.setup = function() {
+      if (!hasBeenCalled) {
+        reject(new Error('Setup called prior to success callback'));
+      } else {
+        setTimeout(resolve, 50);
+      }
+    };
+  });
+
+  test('returns an object with correct data', async function() {
+    const shader = await promisedSketch(function(sketch, resolve, reject) {
+      var _shader;
+      sketch.preload = function() {
+        _shader = sketch.loadShader(vertFile, fragFile, function() {}, reject);
+      };
+
+      sketch.setup = function() {
+        resolve(_shader);
+      };
+    });
+    assert.instanceOf(shader, p5.Shader);
+  });
+
+  test('passes an object with correct data to callback', async function() {
+    const model = await promisedSketch(function(sketch, resolve, reject) {
+      sketch.preload = function() {
+        sketch.loadShader(vertFile, fragFile, resolve, reject);
+      };
+    });
+    assert.instanceOf(model, p5.Shader);
+  });
+
+  test('does not run setup after complete when called outside of preload', async function() {
+    let setupCallCount = 0;
+    await promisedSketch(function(sketch, resolve, reject) {
+      sketch.setup = function() {
+        setupCallCount++;
+        sketch.loadShader(vertFile, fragFile, resolve, reject);
+      };
+    });
+    assert.equal(setupCallCount, 1);
+  });
+});

package/p5-tests/unit/io/loadStrings.js

@@ -0,0 +1,140 @@
+suite('loadStrings', function() {
+  const invalidFile = '404file';
+  const validFile = 'unit/assets/sentences.txt';
+  const fileWithEmptyLines = 'unit/assets/empty_lines.txt';
+  const fileWithManyLines = 'unit/assets/many_lines.txt';
+
+  test('_friendlyFileLoadError is called', async function() {
+    const _friendlyFileLoadErrorStub = sinon.stub(p5, '_friendlyFileLoadError');
+    try {
+      await promisedSketch(function(sketch, resolve, reject) {
+        sketch.preload = function() {
+          sketch.loadStrings(invalidFile, reject, resolve);
+        };
+      });
+      expect(
+        _friendlyFileLoadErrorStub.calledOnce,
+        'p5._friendlyFileLoadError was not called'
+      ).to.be.true;
+    } finally {
+      _friendlyFileLoadErrorStub.restore();
+    }
+  });
+
+  testSketchWithPromise('error prevents sketch continuing', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    sketch.preload = function() {
+      sketch.loadStrings(invalidFile, reject, function() {
+        setTimeout(resolve, 50);
+      });
+    };
+
+    sketch.setup = function() {
+      reject(new Error('Entered setup'));
+    };
+
+    sketch.draw = function() {
+      reject(new Error('Entered draw'));
+    };
+  });
+
+  testSketchWithPromise('error callback is called', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    sketch.preload = function() {
+      sketch.loadStrings(
+        invalidFile,
+        function() {
+          reject(new Error('Success callback executed.'));
+        },
+        function() {
+          // Wait a bit so that if both callbacks are executed we will get an error.
+          setTimeout(resolve, 50);
+        }
+      );
+    };
+  });
+
+  testSketchWithPromise('loading correctly triggers setup', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    sketch.preload = function() {
+      sketch.loadStrings(validFile);
+    };
+
+    sketch.setup = resolve();
+  });
+
+  testSketchWithPromise('success callback is called', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    sketch.preload = function() {
+      sketch.loadStrings(validFile, resolve, function(err) {
+        reject(new Error('Error callback was entered: ' + err));
+      });
+    };
+
+    sketch.setup = function() {
+      reject(new Error('Setup called prior to success callback'));
+    };
+  });
+
+  test('returns an array of strings', async function() {
+    const strings = await promisedSketch(function(sketch, resolve, reject) {
+      let strings;
+      sketch.preload = function() {
+        strings = sketch.loadStrings(validFile, function() {}, reject);
+      };
+
+      sketch.setup = function() {
+        resolve(strings);
+      };
+    });
+
+    assert.isArray(strings);
+    for (let i = 0; i < strings.length; i++) {
+      assert.isString(strings[i]);
+    }
+  });
+
+  test('passes an array to success callback', async function() {
+    const strings = await promisedSketch(function(sketch, resolve, reject) {
+      sketch.preload = function() {
+        sketch.loadStrings(validFile, resolve, reject);
+      };
+    });
+    assert.isArray(strings);
+    for (let i = 0; i < strings.length; i++) {
+      assert.isString(strings[i]);
+    }
+  });
+
+  test('should include empty strings', async function() {
+    const strings = await promisedSketch(function(sketch, resolve, reject) {
+      sketch.preload = function() {
+        sketch.loadStrings(fileWithEmptyLines, resolve, reject);
+      };
+    });
+    assert.isArray(strings, 'Array passed to callback function');
+    assert.lengthOf(strings, 6, 'length of data is 6');
+  });
+
+  test('can load file with many lines', async function() {
+    const strings = await promisedSketch(function(sketch, resolve, reject) {
+      sketch.preload = function() {
+        sketch.loadStrings(fileWithManyLines, resolve, reject);
+      };
+    });
+    assert.isArray(strings, 'Array passed to callback function');
+    assert.lengthOf(strings, 131073, 'length of data is 131073');
+  });
+});

package/p5-tests/unit/io/loadTable.js

@@ -0,0 +1,183 @@
+suite('loadTable', function() {
+  var invalidFile = '404file';
+  var validFile = 'unit/assets/csv.csv';
+
+  test('_friendlyFileLoadError is called', async function() {
+    const _friendlyFileLoadErrorStub = sinon.stub(p5, '_friendlyFileLoadError');
+    try {
+      await promisedSketch(function(sketch, resolve, reject) {
+        sketch.preload = function() {
+          sketch.loadTable(invalidFile, reject, resolve);
+        };
+      });
+      expect(
+        _friendlyFileLoadErrorStub.calledOnce,
+        'p5._friendlyFileLoadError was not called'
+      ).to.be.true;
+    } finally {
+      _friendlyFileLoadErrorStub.restore();
+    }
+  });
+
+  testSketchWithPromise('error prevents sketch continuing', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    sketch.preload = function() {
+      sketch.loadTable(invalidFile);
+      setTimeout(resolve, 50);
+    };
+
+    sketch.setup = function() {
+      reject(new Error('Setup called'));
+    };
+
+    sketch.draw = function() {
+      reject(new Error('Draw called'));
+    };
+  });
+
+  testSketchWithPromise('error callback is called', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    sketch.preload = function() {
+      sketch.loadTable(
+        invalidFile,
+        function() {
+          reject(new Error('Success callback executed.'));
+        },
+        function() {
+          // Wait a bit so that if both callbacks are executed we will get an error.
+          setTimeout(resolve, 50);
+        }
+      );
+    };
+  });
+
+  testSketchWithPromise('loading correctly triggers setup', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    sketch.preload = function() {
+      sketch.loadTable(validFile);
+    };
+
+    sketch.setup = function() {
+      resolve();
+    };
+  });
+
+  testSketchWithPromise('success callback is called', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    var hasBeenCalled = false;
+    sketch.preload = function() {
+      sketch.loadTable(
+        validFile,
+        function() {
+          hasBeenCalled = true;
+        },
+        function(err) {
+          reject(new Error('Error callback was entered: ' + err));
+        }
+      );
+    };
+
+    sketch.setup = function() {
+      if (!hasBeenCalled) {
+        reject(new Error('Setup called prior to success callback'));
+      } else {
+        setTimeout(resolve, 50);
+      }
+    };
+  });
+
+  test('returns an object with correct data', async function() {
+    const table = await promisedSketch(function(sketch, resolve, reject) {
+      let _table;
+      sketch.preload = function() {
+        _table = sketch.loadTable(validFile, function() {}, reject);
+      };
+
+      sketch.setup = function() {
+        resolve(_table);
+      };
+    });
+    assert.equal(table.getRowCount(), 4);
+    assert.strictEqual(table.getRow(1).getString(0), 'David');
+    assert.strictEqual(table.getRow(1).getNum(1), 31);
+  });
+
+  test('passes an object to success callback for object JSON', async function() {
+    const table = await promisedSketch(function(sketch, resolve, reject) {
+      sketch.preload = function() {
+        sketch.loadTable(validFile, resolve, reject);
+      };
+    });
+    assert.equal(table.getRowCount(), 4);
+    assert.strictEqual(table.getRow(1).getString(0), 'David');
+    assert.strictEqual(table.getRow(1).getNum(1), 31);
+  });
+
+  test('csv option returns the correct data', async function() {
+    const table = await promisedSketch(function(sketch, resolve, reject) {
+      sketch.preload = function() {
+        sketch.loadTable(validFile, 'csv', resolve, reject);
+      };
+    });
+    assert.equal(table.getRowCount(), 4);
+    assert.strictEqual(table.getRow(1).getString(0), 'David');
+    assert.strictEqual(table.getRow(1).getNum(1), 31);
+  });
+
+  test('using the header option works', async function() {
+    const table = await promisedSketch(function(sketch, resolve, reject) {
+      sketch.preload = function() {
+        sketch.loadTable(validFile, 'header', resolve, reject);
+      };
+    });
+    assert.equal(table.getRowCount(), 3);
+    assert.strictEqual(table.getRow(0).getString('name'), 'David');
+    assert.strictEqual(table.getRow(0).getNum('age'), 31);
+  });
+
+  test('allows the csv and header options together', async function() {
+    const table = await promisedSketch(function(sketch, resolve, reject) {
+      sketch.preload = function() {
+        sketch.loadTable(validFile, 'csv', 'header', resolve, reject);
+      };
+    });
+    assert.equal(table.getRowCount(), 3);
+    assert.strictEqual(table.getRow(0).getString('name'), 'David');
+    assert.strictEqual(table.getRow(0).getNum('age'), 31);
+  });
+
+  test('CSV files should handle commas within quoted fields', async function() {
+    const table = await promisedSketch(function(sketch, resolve, reject) {
+      sketch.preload = function() {
+        sketch.loadTable(validFile, resolve, reject);
+      };
+    });
+    assert.equal(table.getRowCount(), 4);
+    assert.equal(table.getRow(2).get(0), 'David, Jr.');
+    assert.equal(table.getRow(2).getString(0), 'David, Jr.');
+    assert.equal(table.getRow(2).get(1), '11');
+    assert.equal(table.getRow(2).getString(1), 11);
+  });
+
+  test('CSV files should handle escaped quotes and returns within quoted fields', async function() {
+    const table = await promisedSketch(function(sketch, resolve, reject) {
+      sketch.preload = function() {
+        sketch.loadTable(validFile, resolve, reject);
+      };
+    });
+    assert.equal(table.getRowCount(), 4);
+    assert.equal(table.getRow(3).get(0), 'David,\nSr. "the boss"');
+  });
+});

package/p5-tests/unit/io/loadXML.js

@@ -0,0 +1,127 @@
+suite('loadXML', function() {
+  var invalidFile = '404file';
+  var validFile = 'unit/assets/books.xml';
+
+  test('_friendlyFileLoadError is called', async function() {
+    const _friendlyFileLoadErrorStub = sinon.stub(p5, '_friendlyFileLoadError');
+    try {
+      await promisedSketch(function(sketch, resolve, reject) {
+        sketch.preload = function() {
+          sketch.loadXML(invalidFile, reject, resolve);
+        };
+      });
+      expect(
+        _friendlyFileLoadErrorStub.calledOnce,
+        'p5._friendlyFileLoadError was not called'
+      ).to.be.true;
+    } finally {
+      _friendlyFileLoadErrorStub.restore();
+    }
+  });
+
+  testSketchWithPromise('error prevents sketch continuing', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    sketch.preload = function() {
+      sketch.loadXML(invalidFile);
+      setTimeout(resolve, 50);
+    };
+
+    sketch.setup = function() {
+      reject(new Error('Setup called'));
+    };
+
+    sketch.draw = function() {
+      reject(new Error('Draw called'));
+    };
+  });
+
+  testSketchWithPromise('error callback is called', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    sketch.preload = function() {
+      sketch.loadXML(
+        invalidFile,
+        function() {
+          reject(new Error('Success callback executed.'));
+        },
+        function() {
+          // Wait a bit so that if both callbacks are executed we will get an error.
+          setTimeout(resolve, 50);
+        }
+      );
+    };
+  });
+
+  testSketchWithPromise('loading correctly triggers setup', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    sketch.preload = function() {
+      sketch.loadXML(validFile);
+    };
+
+    sketch.setup = function() {
+      resolve();
+    };
+  });
+
+  testSketchWithPromise('success callback is called', function(
+    sketch,
+    resolve,
+    reject
+  ) {
+    var hasBeenCalled = false;
+    sketch.preload = function() {
+      sketch.loadXML(
+        validFile,
+        function() {
+          hasBeenCalled = true;
+        },
+        function(err) {
+          reject(new Error('Error callback was entered: ' + err));
+        }
+      );
+    };
+
+    sketch.setup = function() {
+      if (!hasBeenCalled) {
+        reject(new Error('Setup called prior to success callback'));
+      } else {
+        setTimeout(resolve, 50);
+      }
+    };
+  });
+
+  test('returns an object with correct data', async function() {
+    const xml = await promisedSketch(function(sketch, resolve, reject) {
+      let _xml;
+      sketch.preload = function() {
+        _xml = sketch.loadXML(validFile, function() {}, reject);
+      };
+
+      sketch.setup = function() {
+        resolve(_xml);
+      };
+    });
+    assert.isObject(xml);
+    var children = xml.getChildren('book');
+    assert.lengthOf(children, 12);
+  });
+
+  test('passes an object with correct data', async function() {
+    const xml = await promisedSketch(function(sketch, resolve, reject) {
+      sketch.preload = function() {
+        sketch.loadXML(validFile, resolve, reject);
+      };
+    });
+    assert.isObject(xml);
+    var children = xml.getChildren('book');
+    assert.lengthOf(children, 12);
+  });
+});